{"version":3,"sources":["../src/contracts/handlers/registry.ts","../src/script/default.ts","../src/identity/descriptor.ts","../src/contracts/metadata.ts","../src/contracts/handlers/helpers.ts","../src/contracts/handlers/default.ts","../src/script/delegate.ts","../src/contracts/handlers/delegate.ts","../src/arkade/opcodes.ts","../src/arkade/bignum.ts","../src/arkade/script.ts","../src/utils/keys.ts","../src/arkade/tweak.ts","../src/script/vhtlc.ts","../src/contracts/handlers/vhtlc.ts","../src/contracts/handlers/vhtlcV2.ts","../src/contracts/handlers/boarding.ts","../src/arkade/program.ts","../src/contracts/handlers/arkade.ts","../src/contracts/handlers/index.ts"],"names":["DefaultVtxo","Script","VtxoScript","MultisigTapscript","CSVMultisigTapscript","hex","expand","networks","sequenceToTimelock","SCRIPT_QUERY_CHUNK_SIZE","getNormalizedVtxos","DEFAULT_PAGE_SIZE","timelockToSequence","DelegateVtxo","OP","__export","ScriptNum","P","schnorr","bytesToNumberBE","secp256k1","VHTLC","ConditionMultisigTapscript","CLTVMultisigTapscript","ConditionCSVMultisigTapscript"],"mappings":"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","file":"chunk-FUW3OM5X.cjs","sourcesContent":["import { ContractHandler } from \"../types\";\n\n/**\n * Registry for contract handlers.\n *\n * Each contract type (\"default\", \"vhtlc\", etc.) has a handler that knows\n * how to create VtxoScripts, serialize params, and select spending paths.\n *\n * @example\n * ```typescript\n * // Register a custom handler\n * contractHandlers.register(myCustomHandler);\n *\n * // Get handler for a type\n * const handler = contractHandlers.get(\"vhtlc\");\n * const script = handler.createScript(contract.params);\n * ```\n */\nclass ContractHandlerRegistry {\n    private handlers = new Map<string, ContractHandler<unknown>>();\n\n    /**\n     * Register a contract handler.\n     *\n     * @param handler - The handler to register\n     * @throws If a handler for this type is already registered\n     */\n    register(handler: ContractHandler<unknown>): void {\n        if (this.handlers.has(handler.type)) {\n            throw new Error(`Contract handler for type '${handler.type}' is already registered`);\n        }\n        this.handlers.set(handler.type, handler);\n    }\n\n    /**\n     * Get a handler by type.\n     *\n     * @param type - The contract type\n     * @returns The handler, or undefined if not found\n     */\n    get(type: string): ContractHandler<unknown> | undefined {\n        return this.handlers.get(type);\n    }\n\n    /**\n     * Get a handler by type, throwing if not found.\n     *\n     * @param type - The contract type\n     * @returns The handler\n     * @throws If no handler is registered for this type\n     */\n    getOrThrow(type: string): ContractHandler<unknown> {\n        const handler = this.get(type);\n        if (!handler) {\n            throw new Error(`No contract handler registered for type '${type}'`);\n        }\n        return handler;\n    }\n\n    /**\n     * Check if a handler is registered.\n     *\n     * @param type - The contract type\n     */\n    has(type: string): boolean {\n        return this.handlers.has(type);\n    }\n\n    /**\n     * Get all registered types.\n     */\n    getRegisteredTypes(): string[] {\n        return Array.from(this.handlers.keys());\n    }\n\n    /**\n     * Unregister a handler (mainly for testing).\n     */\n    unregister(type: string): boolean {\n        return this.handlers.delete(type);\n    }\n\n    /**\n     * Clear all handlers (mainly for testing).\n     */\n    clear(): void {\n        this.handlers.clear();\n    }\n}\n\n/**\n * Global registry of contract handlers.\n */\nexport const contractHandlers = new ContractHandlerRegistry();\n","import { Bytes } from \"@scure/btc-signer/utils.js\";\nimport { TapLeafScript, VtxoScript } from \"./base\";\nimport { CSVMultisigTapscript, MultisigTapscript, RelativeTimelock } from \"./tapscript\";\nimport { hex } from \"@scure/base\";\n\n/**\n * DefaultVtxo is the default implementation of a VtxoScript.\n * It contains 1 forfeit path and 1 exit path.\n * - forfeit = (Alice + Server)\n * - exit = (Alice) after csvTimelock\n */\nexport namespace DefaultVtxo {\n    /**\n     * Options is the options for the DefaultVtxo.Script class.\n     * csvTimelock is the exit path timelock, default is 144 blocks (1 day).\n     */\n    export interface Options {\n        pubKey: Bytes;\n        serverPubKey: Bytes;\n        csvTimelock: RelativeTimelock;\n    }\n\n    /**\n     * DefaultVtxo.Script is the class letting to create the vtxo script.\n     * @example\n     * ```typescript\n     * const vtxoScript = new DefaultVtxo.Script({\n     *     pubKey: new Uint8Array(32),\n     *     serverPubKey: new Uint8Array(32),\n     *     csvTimelock: {\n     *         value: 605184n,\n     *         type: \"seconds\"\n     *     }\n     * });\n     *\n     * console.log(\"script pub key:\", vtxoScript.pkScript)\n     * ```\n     */\n    export class Script extends VtxoScript {\n        static readonly DEFAULT_TIMELOCK: RelativeTimelock = {\n            value: 144n,\n            type: \"blocks\",\n        }; // 1 day in blocks\n\n        readonly forfeitScript: string;\n        readonly exitScript: string;\n\n        /** Create the default virtual output script with one forfeit path and one exit path. */\n        constructor(readonly options: Options) {\n            const { pubKey, serverPubKey, csvTimelock } = options;\n\n            const forfeitScript = MultisigTapscript.encode({\n                pubkeys: [pubKey, serverPubKey],\n            }).script;\n\n            const exitScript = CSVMultisigTapscript.encode({\n                timelock: csvTimelock,\n                pubkeys: [pubKey],\n            }).script;\n\n            super([forfeitScript, exitScript]);\n\n            this.forfeitScript = hex.encode(forfeitScript);\n            this.exitScript = hex.encode(exitScript);\n        }\n\n        /** Return the forfeit tapleaf script. */\n        forfeit(): TapLeafScript {\n            return this.findLeaf(this.forfeitScript);\n        }\n\n        /** Return the unilateral exit tapleaf script. */\n        exit(): TapLeafScript {\n            return this.findLeaf(this.exitScript);\n        }\n    }\n}\n","import { expand, networks } from \"@bitcoinerlab/descriptors-scure\";\nimport { hex } from \"@scure/base\";\n\n/**\n * True iff `descriptor` is a Bitcoin mainnet descriptor (xpub-prefixed\n * BIP32 key).\n *\n * Note: testnet, signet, regtest, mutinynet, and other non-mainnet\n * networks all share the same `tpub` BIP32 version bytes — they cannot\n * be distinguished from one another at the descriptor level. Callers\n * that need a `Network` constants object for `expand()` pick\n * `networks.bitcoin` vs `networks.testnet` themselves; callers that\n * need the *actual* network the wallet is on must track that\n * out-of-band.\n */\nexport function isMainnetDescriptor(descriptor: string): boolean {\n    return !descriptor.includes(\"tpub\");\n}\n\n/**\n * Shared \"does `candidate` belong to the identity backed by\n * `ourDescriptor`?\" predicate.\n *\n * - HD descriptors (expanding to a `bip32` key) match by account xpub\n *   on both sides — index-agnostic, so a wildcard template and any\n *   concrete index under it all collapse to the same xpub.\n * - Bare `tr(pubkey)` candidates fall back to comparing the candidate\n *   pubkey against `ourXOnlyPubkey` (the cached pubkey on the identity\n *   side, since pulling it from `ourDescriptor` would require an index\n *   substitution the caller already performed).\n */\nexport function descriptorIsOurs(\n    candidate: string,\n    ourDescriptor: string,\n    ourXOnlyPubkey: Uint8Array,\n): boolean {\n    if (!isDescriptor(candidate)) return false;\n    try {\n        const candidateInfo = expand({\n            descriptor: candidate,\n            network: isMainnetDescriptor(candidate) ? networks.bitcoin : networks.testnet,\n        }).expansionMap?.[\"@0\"];\n        if (!candidateInfo) return false;\n\n        if (candidateInfo.bip32) {\n            const ourBip32 = expand({\n                descriptor: ourDescriptor,\n                network: isMainnetDescriptor(ourDescriptor) ? networks.bitcoin : networks.testnet,\n            }).expansionMap?.[\"@0\"]?.bip32;\n            if (!ourBip32) return false;\n            return ourBip32.toBase58() === candidateInfo.bip32.toBase58();\n        }\n        if (candidateInfo.pubkey) {\n            // For tr() the library hands back a 32-byte x-only key, but\n            // strip a leading parity byte defensively so a 33-byte\n            // compressed key (mismatched length) doesn't silently\n            // false-negative against our 32-byte x-only side.\n            const candidatePub =\n                candidateInfo.pubkey.length === 33\n                    ? candidateInfo.pubkey.subarray(1)\n                    : candidateInfo.pubkey;\n            if (candidatePub.length !== ourXOnlyPubkey.length) return false;\n            return hex.encode(candidatePub) === hex.encode(ourXOnlyPubkey);\n        }\n        return false;\n    } catch {\n        return false;\n    }\n}\n\n/**\n * Check if a string is a descriptor of the shape `tr(...)`.\n *\n * This is a shape check only — it does not validate the inner key material.\n * Use {@link expand} (via {@link extractPubKey} / {@link parseHDDescriptor})\n * for full parsing. The guard rejects empty bodies and missing/trailing\n * parentheses so callers can safely branch on descriptor vs. raw pubkey.\n */\nexport function isDescriptor(value: string): boolean {\n    if (typeof value !== \"string\") return false;\n    if (!value.startsWith(\"tr(\") || !value.endsWith(\")\")) return false;\n    // body length > 0 after stripping \"tr(\" and \")\"\n    return value.length > \"tr()\".length;\n}\n\n/**\n * Normalize a value to descriptor format.\n * If already a descriptor, return as-is. If hex pubkey, wrap as tr(pubkey).\n * Throws when the value is empty or not a string so we never produce\n * malformed descriptors like `tr()` that downstream parsers would reject.\n */\nexport function normalizeToDescriptor(value: string): string {\n    if (typeof value !== \"string\" || value.length === 0) {\n        throw new Error(\"normalizeToDescriptor: expected a non-empty string value\");\n    }\n    if (isDescriptor(value)) {\n        return value;\n    }\n    return `tr(${value})`;\n}\n\n/**\n * Extract the public key from a simple descriptor.\n * For simple descriptors (tr(pubkey)), extracts the pubkey using the library.\n * For HD descriptors, throws — use DescriptorProvider to derive the key.\n */\nexport function extractPubKey(descriptor: string): string {\n    if (!isDescriptor(descriptor)) {\n        return descriptor;\n    }\n\n    const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;\n    const expansion = expand({ descriptor, network });\n\n    if (!expansion.expansionMap) {\n        throw new Error(\"Cannot extract pubkey from descriptor: expansion failed.\");\n    }\n\n    const key = expansion.expansionMap[\"@0\"];\n\n    // HD descriptors (have a bip32 key) require DescriptorProvider for derivation\n    if (key?.bip32) {\n        throw new Error(\n            \"Cannot extract pubkey from HD descriptor without derivation. \" +\n                \"Use DescriptorProvider to derive the key from the xpub.\",\n        );\n    }\n\n    if (!key?.pubkey) {\n        throw new Error(\"Cannot extract pubkey from descriptor: no key found.\");\n    }\n\n    return hex.encode(key.pubkey);\n}\n\n/**\n * Extract the x-only (32-byte) pubkey from a materialized descriptor.\n * Handles both static `tr(pubkey)` and materialized HD\n * `tr([fp/..]xpub/0/<i>)` shapes via the descriptors-scure expansion map.\n * Throws a plain Error when the descriptor is non-rangeable / unparseable;\n * callers that need a typed error wrap this.\n */\nexport function deriveDescriptorLeafPubKey(descriptor: string): Uint8Array {\n    const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;\n    let expansion;\n    try {\n        expansion = expand({ descriptor, network });\n    } catch (e) {\n        throw new Error(\n            `Cannot derive leaf pubkey from descriptor (length=${descriptor.length}): ` +\n                `ensure it is materialized (no wildcard) and parsable.`,\n            { cause: e },\n        );\n    }\n    const key = expansion.expansionMap?.[\"@0\"];\n    if (!key?.pubkey) {\n        throw new Error(\n            `Cannot derive leaf pubkey from descriptor (length=${descriptor.length}): ` +\n                `parsed but no '@0' pubkey in the expansion map.`,\n        );\n    }\n    return key.pubkey;\n}\n\n/**\n * Compressed (33-byte) counterpart of {@link deriveDescriptorLeafPubKey}, for\n * protocols that key on the parity byte (Boltz swap keys).\n *\n * Only HD descriptors are supported: a bare `tr(xonly)` has lost its parity and\n * synthesizing `02||xonly` would silently produce the wrong key half the time.\n */\nexport function deriveDescriptorLeafCompressedPubKey(descriptor: string): Uint8Array {\n    const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;\n    let expansion;\n    try {\n        expansion = expand({ descriptor, network });\n    } catch (e) {\n        throw new Error(\n            `Cannot derive compressed leaf pubkey from descriptor (length=${descriptor.length}): ` +\n                `ensure it is materialized (no wildcard) and parsable.`,\n            { cause: e },\n        );\n    }\n    const key = expansion.expansionMap?.[\"@0\"];\n    if (!key?.bip32) {\n        throw new Error(\n            `Cannot derive compressed leaf pubkey from descriptor (length=${descriptor.length}): ` +\n                `not an HD descriptor, so the key parity is unrecoverable.`,\n        );\n    }\n    // derivePath returns a fresh node; keyPath is relative to the xpub and the\n    // library's derivePath prepends \"m/\" itself.\n    return key.keyPath\n        ? key.bip32.derivePath(key.keyPath.replace(/^\\//, \"\")).publicKey\n        : key.bip32.publicKey;\n}\n\n/** Parsed HD descriptor components. */\nexport interface ParsedHDDescriptor {\n    fingerprint: string;\n    basePath: string;\n    xpub: string;\n    derivationPath: string;\n}\n\n/**\n * Parse an HD descriptor into its components.\n * HD descriptors have the format: tr([fingerprint/path']xpub/derivation)\n * Returns null if the descriptor is not in HD format.\n */\nexport function parseHDDescriptor(descriptor: string): ParsedHDDescriptor | null {\n    if (!isDescriptor(descriptor)) {\n        return null;\n    }\n\n    let expansion;\n    try {\n        const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;\n        expansion = expand({ descriptor, network });\n    } catch {\n        return null;\n    }\n\n    const key = expansion.expansionMap?.[\"@0\"];\n    if (!key?.masterFingerprint || !key.originPath || !key.keyPath || !key.bip32) {\n        return null;\n    }\n\n    return {\n        fingerprint: hex.encode(key.masterFingerprint),\n        basePath: key.originPath.replace(/^\\//, \"\"),\n        xpub: key.bip32.toBase58(),\n        derivationPath: key.keyPath.replace(/^\\//, \"\"),\n    };\n}\n\n/**\n * The descriptor that names an identity's own key: the whole of a static\n * wallet's key policy, and the descriptor a record bound before an `auto`\n * wallet became HD carries.\n *\n * One spelling, deliberately. Every site that mints this must produce\n * byte-identical output for one identity, or a stored descriptor stops\n * round-tripping through `signerForDescriptor` and `contractSigner`'s\n * pubkey-equality check — a record the wallet can sign for, refused as\n * foreign.\n */\nexport async function identityDescriptor(identity: {\n    xOnlyPublicKey(): Promise<Uint8Array>;\n}): Promise<string> {\n    return normalizeToDescriptor(hex.encode(await identity.xOnlyPublicKey()));\n}\n","/**\n * Sentinel stored in `contract.metadata.source` to mark a contract the\n * wallet generated for its own rotating receive address. Lives here (the\n * contracts layer) so contract handlers can tag/discover without importing\n * the wallet module. Re-exported from `wallet/walletReceiveRotator` for\n * backward compatibility of existing import paths.\n *\n * Tagging makes the boot lookup unambiguous — the rotator filters on\n * `metadata.source === WALLET_RECEIVE_SOURCE` rather than on \"any active\n * default contract\", so a contract repo that also holds default contracts\n * created for other reasons (legacy timelock variants, external\n * integrations) doesn't confuse the wallet's display state.\n */\nexport const WALLET_RECEIVE_SOURCE = \"wallet-receive\";\n","import { hex } from \"@scure/base\";\nimport { sequenceToTimelock } from \"../../utils/timelock\";\nimport { Contract, DiscoveredContract, PathContext, PathSelection } from \"../types\";\nimport type { CandidateDeps, Discoverable, DiscoveryDeps } from \"../types\";\nimport {\n    isDescriptor,\n    extractPubKey,\n    normalizeToDescriptor,\n    deriveDescriptorLeafPubKey,\n} from \"../../identity/descriptor\";\nimport type { IndexerProvider } from \"../../providers/indexer\";\nimport { getNormalizedVtxos } from \"../../wallet/vtxo\";\nimport { DefaultVtxo } from \"../../script/default\";\nimport type { TapLeafScript } from \"../../script/base\";\nimport type { RelativeTimelock } from \"../../script/tapscript\";\nimport { WALLET_RECEIVE_SOURCE } from \"../metadata\";\nimport { DEFAULT_PAGE_SIZE, SCRIPT_QUERY_CHUNK_SIZE } from \"../constants\";\n\n/**\n * Extract raw hex pubkey from a value that may be a descriptor or raw hex.\n * Returns undefined for HD descriptors or unparseable values so role\n * resolution stays best-effort and never throws.\n */\nfunction extractRawPubKey(value: string): string | undefined {\n    if (!isDescriptor(value)) {\n        return value.toLowerCase();\n    }\n    try {\n        return extractPubKey(value).toLowerCase();\n    } catch {\n        return undefined;\n    }\n}\n\n/**\n * Resolve wallet's role from explicit role or by matching descriptor/pubkey.\n */\nexport function resolveRole(\n    contract: Contract,\n    context: PathContext,\n): \"sender\" | \"receiver\" | undefined {\n    // Explicit role takes precedence\n    if (context.role === \"sender\" || context.role === \"receiver\") {\n        return context.role;\n    }\n\n    const senderKey = contract.params.sender ? extractRawPubKey(contract.params.sender) : undefined;\n    const receiverKey = contract.params.receiver\n        ? extractRawPubKey(contract.params.receiver)\n        : undefined;\n\n    const matchRole = (rawWalletKey: string | undefined): \"sender\" | \"receiver\" | undefined => {\n        if (!rawWalletKey) return undefined;\n        if (senderKey && rawWalletKey === senderKey) {\n            return \"sender\";\n        }\n        if (receiverKey && rawWalletKey === receiverKey) {\n            return \"receiver\";\n        }\n        return undefined;\n    };\n\n    // Try the preferred descriptor first. If it cannot be resolved\n    // (for example an HD descriptor without derivation support), fall back\n    // to walletPubKey for backward compatibility.\n    if (context.walletDescriptor) {\n        const walletDescriptorKey = extractRawPubKey(context.walletDescriptor);\n        const matchedRole = matchRole(walletDescriptorKey);\n        if (matchedRole) {\n            return matchedRole;\n        }\n\n        if (!walletDescriptorKey && context.walletPubKey) {\n            return matchRole(extractRawPubKey(context.walletPubKey));\n        }\n        return undefined;\n    }\n\n    if (context.walletPubKey) {\n        return matchRole(extractRawPubKey(context.walletPubKey));\n    }\n\n    return undefined;\n}\n\n/**\n * Extract pubkey bytes from a persisted param that may hold either a\n * descriptor or a raw hex key.\n *\n * Shared by every descriptor-capable handler (`default` / `delegate` /\n * `boarding` — see `DESCRIPTOR_CAPABLE_CONTRACT_TYPES`) so a rotated row whose\n * key param was persisted in descriptor form deserializes identically\n * whichever handler owns it.\n */\nexport function extractPubKeyBytes(value: string): Uint8Array {\n    return hex.decode(extractPubKey(normalizeToDescriptor(value)));\n}\n\n/**\n * Decode a persisted `csvTimelock` param, restoring the default when absent.\n *\n * The param may be missing or empty on legacy/minimal rows (e.g. hex pubkeys\n * written with no timelock). The script classes no longer apply their own\n * fallback, and an unguarded decode does *not* fail loudly: `Number(\"\")` /\n * `Number(undefined)` is `NaN`, and `bip68.decode(NaN)` returns\n * `{ blocks: 0 }`, so `sequenceToTimelock` silently yields a zero timelock —\n * an exit path that reads as immediately spendable. Restore the documented\n * default instead of decoding a NaN.\n */\nexport function deserializeCsvTimelock(value: string | undefined): RelativeTimelock {\n    return value !== undefined && value !== \"\"\n        ? sequenceToTimelock(Number(value))\n        : DefaultVtxo.Script.DEFAULT_TIMELOCK;\n}\n\n/**\n * BIP65 threshold: locktime values below this are interpreted as block heights,\n * values at or above are interpreted as Unix timestamps (seconds).\n */\nconst CLTV_HEIGHT_THRESHOLD = 500_000_000n;\n\n/**\n * Check if an absolute (CLTV) locktime is currently satisfied.\n *\n * Following the BIP65 convention:\n * - locktime < 500_000_000  → interpreted as a block height; compared against `context.blockHeight`\n * - locktime >= 500_000_000 → interpreted as a Unix timestamp (seconds); compared against `context.currentTime`\n *\n * Returns false if the relevant context field is missing.\n */\nexport function isCltvSatisfied(context: PathContext, locktime: bigint): boolean {\n    // Deliberately the same clock `cltvMaturity` reads. Offering a path and\n    // refusing one are two answers to one question, and sourcing them from\n    // different clocks lets a wallet offer a leaf its own guard would reject.\n    return cltvMaturity(context, locktime) === \"satisfied\";\n}\n\n/**\n * How an absolute (CLTV) locktime stands against `context`, keeping \"not yet\"\n * and \"cannot tell\" apart.\n *\n * {@link isCltvSatisfied} folds both into `false`, which is the right answer\n * for OFFERING a path — an unknown maturity is not an invitation to spend. It\n * is the wrong answer for REFUSING one: a height-typed locktime with no\n * `blockHeight` in context is unreadable, not immature, and turning that into a\n * refusal would reject spends that are perfectly valid. Anything that fails a\n * caller rather than merely withholding an option must ask this instead.\n *\n * - `satisfied` — matured; the leaf behind it is spendable now.\n * - `pending`   — definitively not matured yet, with a maturity to quote.\n * - `unknown`   — height-typed with no chain tip supplied. Say nothing.\n */\nexport type CltvMaturity = \"satisfied\" | \"pending\" | \"unknown\";\n\nexport function cltvMaturity(context: PathContext, locktime: bigint): CltvMaturity {\n    if (locktime < CLTV_HEIGHT_THRESHOLD) {\n        if (context.blockHeight === undefined) return \"unknown\";\n        return BigInt(context.blockHeight) >= locktime ? \"satisfied\" : \"pending\";\n    }\n    // Chain time where we have it. The wall-clock fallback is a decent estimate\n    // and a poor authority: the server matures this against median-time-past,\n    // which trails wall clock, so a drifting host reads the boundary wrong in\n    // whichever direction it drifted — including \"not yet\" for something the\n    // chain already accepts.\n    return nowSeconds(context) >= locktime ? \"satisfied\" : \"pending\";\n}\n\n/** Chain time if the context carries it, else the local clock. Seconds. */\nfunction nowSeconds(context: PathContext): bigint {\n    return BigInt(Math.floor(context.chainTime ?? context.currentTime / 1000));\n}\n\n/** Whether `locktime` is height-typed (BIP65), for phrasing a maturity. */\nexport function isHeightLocktime(locktime: bigint): boolean {\n    return locktime < CLTV_HEIGHT_THRESHOLD;\n}\n\n/**\n * The VHTLC spendability refusal, shared by the v1 and v2 handlers.\n *\n * Both versions gate the sender's only collaborative leaf —\n * `refundWithoutReceiver` — on `refundLocktime`. Before it matures the sender\n * has nothing collaborative to spend: `claim` belongs to the receiver and needs\n * a preimage, and `refund` / `nonInteractiveRefund` need the receiver's\n * signature, which is precisely what a refunding sender cannot get. So an\n * explicit `settle({ inputs })` naming that lockup is refusable with certainty\n * rather than guessed at.\n *\n * Lives here rather than in either handler because v1 and v2 differ only in\n * which preimage fragment their claim leaves are built from; a rule applied to\n * one and not the other is the realistic drift, and the same reasoning already\n * keeps their path selection in step.\n *\n * Silent in every case that is not a certainty:\n * - not collaborative — a unilateral spend answers to its CSV, not this\n * - not the sender — the receiver's claim turns on a preimage this cannot see\n * - maturity `unknown` — height-typed with no chain tip; unreadable, not immature\n */\nexport function assertVhtlcSpendableNow(contract: Contract, context: PathContext): void {\n    if (!context.collaborative) return;\n    if (resolveRole(contract, context) !== \"sender\") return;\n\n    const raw = contract.params?.refundLocktime;\n    if (raw === undefined) return;\n    let refundLocktime: bigint;\n    try {\n        refundLocktime = BigInt(raw);\n    } catch {\n        // Unparseable params are someone else's error to report, not ours to\n        // guess at — createScript already refuses them with a better message.\n        return;\n    }\n\n    if (cltvMaturity(context, refundLocktime) !== \"pending\") return;\n\n    const [matures, now] = isHeightLocktime(refundLocktime)\n        ? [`block ${refundLocktime}`, `${context.blockHeight}`]\n        : [\n              `${new Date(Number(refundLocktime) * 1000).toISOString()}`,\n              new Date(context.currentTime).toISOString(),\n          ];\n    // Addressed to the sender — the only role that reaches here. Do not offer\n    // them the preimage claim: that is the receiver's leaf and the receiver's\n    // secret, and suggesting it sends the reader looking for a key they will\n    // never hold.\n    throw new Error(\n        `vhtlc ${contract.script} cannot be spent yet: its refund path opens at ${matures}, ` +\n            `now ${now}. Until then the lockup is the receiver's to claim, and the server ` +\n            `rejects a spend of it. Retry after ${matures}, or wait for the receiver to ` +\n            `claim it with the preimage.`,\n    );\n}\n\n/**\n * Check if a CSV timelock is currently satisfied for the given context/virtual output.\n */\nexport function isCsvSpendable(context: PathContext, sequence?: number): boolean {\n    if (sequence === undefined) return true;\n    if (!context.vtxo) return false;\n    const timelock = sequenceToTimelock(sequence);\n\n    if (timelock.type === \"blocks\") {\n        if (context.blockHeight === undefined || context.vtxo.status.block_height === undefined) {\n            return false;\n        }\n        return context.blockHeight - context.vtxo.status.block_height >= Number(timelock.value);\n    }\n\n    if (timelock.type === \"seconds\") {\n        // The input's own confirmation time is the CSV's origin — a relative\n        // timelock is measured from when THIS coin confirmed, not from now.\n        // Absent, the age is unknowable and the answer is no.\n        const blockTime = context.vtxo.status.block_time;\n        if (blockTime === undefined) return false;\n        return Number(nowSeconds(context)) - blockTime >= Number(timelock.value);\n    }\n\n    return false;\n}\n\n/**\n * The tapleaf surface shared by `DefaultVtxo.Script` and\n * `DelegateVtxo.Script`. Structural rather than nominal: the two classes are\n * siblings (delegate wraps a default rather than extending it), so a shared\n * interface is what lets both feed the forfeit/exit path helpers below.\n */\nexport interface ForfeitExitScript {\n    forfeit(): TapLeafScript;\n    exit(): TapLeafScript;\n}\n\n/**\n * BIP68 sequence for a contract's exit path, or `undefined` when the contract\n * carries no `csvTimelock` param (an exit with no relative timelock).\n */\nexport function exitSequence(contract: Contract): number | undefined {\n    return contract.params.csvTimelock ? Number(contract.params.csvTimelock) : undefined;\n}\n\n/**\n * The `forfeit`-or-`exit` selection every forfeit/exit contract shares:\n * collaborative spending takes the forfeit path, otherwise the exit path once\n * its CSV has matured. Returns null when neither is available.\n */\nexport function selectForfeitOrExitPath(\n    script: ForfeitExitScript,\n    contract: Contract,\n    context: PathContext,\n): PathSelection | null {\n    if (context.collaborative) {\n        return { leaf: script.forfeit() };\n    }\n\n    const sequence = exitSequence(contract);\n    if (!isCsvSpendable(context, sequence)) {\n        return null;\n    }\n    return { leaf: script.exit(), sequence };\n}\n\n/**\n * Every forfeit/exit path that exists at all: forfeit when the server\n * cooperates, plus exit unconditionally (its CSV is checked at tx build time,\n * not here).\n */\nexport function forfeitExitAllPaths(\n    script: ForfeitExitScript,\n    contract: Contract,\n    context: PathContext,\n): PathSelection[] {\n    const paths: PathSelection[] = [];\n\n    if (context.collaborative) {\n        paths.push({ leaf: script.forfeit() });\n    }\n\n    const exitPath: PathSelection = { leaf: script.exit() };\n    const sequence = exitSequence(contract);\n    if (sequence !== undefined) {\n        exitPath.sequence = sequence;\n    }\n    paths.push(exitPath);\n\n    return paths;\n}\n\n/**\n * The subset of {@link forfeitExitAllPaths} spendable *right now* — the exit\n * path is dropped until its CSV has matured.\n */\nexport function forfeitExitSpendablePaths(\n    script: ForfeitExitScript,\n    contract: Contract,\n    context: PathContext,\n): PathSelection[] {\n    const paths: PathSelection[] = [];\n\n    if (context.collaborative) {\n        paths.push({ leaf: script.forfeit() });\n    }\n\n    const sequence = exitSequence(contract);\n    if (isCsvSpendable(context, sequence)) {\n        const exitPath: PathSelection = { leaf: script.exit() };\n        if (sequence !== undefined) {\n            exitPath.sequence = sequence;\n        }\n        paths.push(exitPath);\n    }\n\n    return paths;\n}\n\n/**\n * Batched discovery probe: given candidate pkScripts a discovery pass built\n * (the signer × CSV-timelock cross-product, possibly across several wallet\n * indices), return the subset the indexer has at least one VTXO for — in any\n * state, since restore counts a spent-but-used script as activity.\n *\n * Collapses what used to be one `getVtxos` call per candidate script into a\n * single call per page, the same batching shape as\n * {@link ContractManager.fetchContractVtxosBulk}: the indexer reports each\n * returned VTXO's `script`, which is matched back to the candidate set. It\n * pages only as far as needed to observe every candidate (stopping early once\n * all are seen), and otherwise to the end of history, so the discovered set is\n * identical to the prior per-script path — a heavily-reused candidate cannot\n * starve another candidate off the first page.\n *\n * Scripts beyond {@link SCRIPT_QUERY_CHUNK_SIZE} are split into sequential\n * chunks (a URL-length budget, see the constant). Chunks are issued serially,\n * not concurrently: pacing the indexer is the point of batching here. A chunk\n * rejecting rejects the whole call — callers treat a partial answer as\n * indeterminate, so there is no partial-result channel to leak into.\n */\nexport async function detectUsedScripts(\n    indexerProvider: IndexerProvider,\n    scriptHexes: string[],\n): Promise<Set<string>> {\n    const used = new Set<string>();\n    // Distinct indices can derive the same script (e.g. an unrotated signer),\n    // and a duplicate would only pad the query string.\n    const unique = [...new Set(scriptHexes)];\n\n    for (let offset = 0; offset < unique.length; offset += SCRIPT_QUERY_CHUNK_SIZE) {\n        const scripts = unique.slice(offset, offset + SCRIPT_QUERY_CHUNK_SIZE);\n        // `scripts` stays the full chunk across pages so the indexer's\n        // pagination is consistent; `remaining` only drives the early stop.\n        const remaining = new Set(scripts);\n        let pageIndex = 0;\n        let hasMore = true;\n        while (hasMore && remaining.size > 0) {\n            const { vtxos, page } = await getNormalizedVtxos(indexerProvider, {\n                scripts,\n                pageIndex,\n                pageSize: DEFAULT_PAGE_SIZE,\n            });\n            for (const vtxo of vtxos) {\n                if (remaining.delete(vtxo.script)) used.add(vtxo.script);\n            }\n            // Same end-of-history heuristic as fetchContractVtxosBulk: a short\n            // page (or absent page metadata) means there is nothing left to\n            // fetch.\n            hasMore = page ? vtxos.length === DEFAULT_PAGE_SIZE : false;\n            pageIndex++;\n        }\n    }\n    return used;\n}\n\n/**\n * Shared body of an indexer-backed handler's `discoverAt` / `discoverRange`.\n *\n * Both verbs are this one function — per-index discovery is just a range of\n * one — so the two paths cannot drift into reporting different contracts for\n * the same wallet state. Every I/O the pass needs is the single\n * {@link detectUsedScripts} call over the union of all indices' candidates,\n * which is what turns a 10-index window's ~20 concurrent 2-script requests\n * into 1-2 sequential batched ones.\n *\n * The returned map covers **every** requested index (empty array when nothing\n * hit), satisfying the `discoverRange` coverage contract the scanner enforces.\n */\nexport async function discoverIndexerCandidates<C extends { script: string }>(\n    indexerProvider: IndexerProvider,\n    entries: readonly { index: number; descriptor: string }[],\n    buildCandidates: (index: number, descriptor: string) => C[],\n    emit: (candidate: C, index: number, descriptor: string) => DiscoveredContract,\n): Promise<Map<number, DiscoveredContract[]>> {\n    const perIndex = entries.map((entry) => ({\n        ...entry,\n        candidates: buildCandidates(entry.index, entry.descriptor),\n    }));\n\n    const used = await detectUsedScripts(\n        indexerProvider,\n        perIndex.flatMap((e) => e.candidates.map((c) => c.script)),\n    );\n\n    const out = new Map<number, DiscoveredContract[]>();\n    for (const { index, descriptor, candidates } of perIndex) {\n        out.set(\n            index,\n            candidates.filter((c) => used.has(c.script)).map((c) => emit(c, index, descriptor)),\n        );\n    }\n    return out;\n}\n\n/**\n * One probe candidate: a built script plus the (signer, timelock) pair that\n * produced it, so the matched signer can be threaded into the emitted\n * contract's params and address.\n */\nexport interface SignerCandidate<S> {\n    pubKey: Uint8Array;\n    serverPubKey: Uint8Array;\n    csvTimelock: RelativeTimelock;\n    script: S;\n    scriptHex: string;\n}\n\n/**\n * Candidate scripts for one wallet index: the current signer first, then any\n * deprecated signers (so a VTXO minted under a now-rotated server key is still\n * discovered), each crossed with the CSV-timelock matrix.\n *\n * Dedup by scriptHex — a deprecated signer that produced no rotation yields\n * the same scripts as the current key, so it must neither be probed nor\n * emitted twice; the current signer wins the attribution by being first.\n *\n * `makeScript` is the only per-contract-type part, which is what lets\n * `default` and `delegate` share one cross-product.\n */\nexport function buildSignerTimelockCandidates<S extends { pkScript: Uint8Array }>(\n    descriptor: string,\n    deps: CandidateDeps,\n    makeScript: (opts: {\n        pubKey: Uint8Array;\n        serverPubKey: Uint8Array;\n        csvTimelock: RelativeTimelock;\n    }) => S,\n): SignerCandidate<S>[] {\n    const pubKey = deriveDescriptorLeafPubKey(descriptor);\n    const signers = [deps.serverPubKey, ...(deps.deprecatedSignerPubKeys ?? [])];\n    const seen = new Set<string>();\n    const candidates: SignerCandidate<S>[] = [];\n    for (const serverPubKey of signers) {\n        for (const csvTimelock of deps.csvTimelocks) {\n            const script = makeScript({ pubKey, serverPubKey, csvTimelock });\n            const scriptHex = hex.encode(script.pkScript);\n            if (seen.has(scriptHex)) continue;\n            seen.add(scriptHex);\n            candidates.push({ pubKey, serverPubKey, csvTimelock, script, scriptHex });\n        }\n    }\n    return candidates;\n}\n\n/**\n * Metadata tagging a discovered contract as one of the wallet's own rotating\n * receive addresses — spread into a {@link DiscoveredContract} literal.\n *\n * Only *rotated* rows (index > 0) are tagged, so boot resolution can find the\n * newest address and descriptor-aware signing can recover the per-index key.\n * The index-0 baseline stays untagged across every handler.\n */\nexport function rotatedReceiveMetadata(\n    index: number,\n    descriptor: string,\n): Pick<DiscoveredContract, \"metadata\"> {\n    return index > 0\n        ? { metadata: { source: WALLET_RECEIVE_SOURCE, signingDescriptor: descriptor } }\n        : {};\n}\n\n/**\n * Metadata for a *speculative* candidate the look-ahead band watches: the\n * signing descriptor, so a promoted row stays spendable, and never\n * {@link WALLET_RECEIVE_SOURCE} — the tag would make the next boot advertise a\n * third party's invoice address as the wallet's own. Unconditional on the\n * index, unlike {@link rotatedReceiveMetadata}: an unpersisted entry has no\n * display-address meaning to protect at index 0.\n */\nexport function speculativeReceiveMetadata(\n    descriptor: string,\n): Pick<DiscoveredContract, \"metadata\"> {\n    return { metadata: { signingDescriptor: descriptor } };\n}\n\n/**\n * Derive a handler's {@link Discoverable.discoverAt} from its\n * {@link Discoverable.discoverRange}: per-index discovery is just a range of\n * one, so the two verbs cannot drift into reporting different contracts for\n * the same wallet state.\n *\n * The `?? []` mirrors `discoverRange`'s coverage contract from the caller's\n * side — a range that omitted the requested index reports a miss here rather\n * than `undefined`.\n */\nexport function discoverAtViaRange(\n    discoverRange: NonNullable<Discoverable[\"discoverRange\"]>,\n): Discoverable[\"discoverAt\"] {\n    return async (index: number, descriptor: string, deps: DiscoveryDeps) =>\n        (await discoverRange([{ index, descriptor }], deps)).get(index) ?? [];\n}\n","import { hex } from \"@scure/base\";\nimport { DefaultVtxo } from \"../../script/default\";\nimport { RelativeTimelock } from \"../../script/tapscript\";\nimport { Contract, ContractHandler, Discoverable, PathContext, PathSelection } from \"../types\";\nimport type { CandidateDeps, DiscoveredContract, DiscoveryDeps } from \"../types\";\nimport {\n    discoverIndexerCandidates,\n    discoverAtViaRange,\n    extractPubKeyBytes,\n    deserializeCsvTimelock,\n    rotatedReceiveMetadata,\n    buildSignerTimelockCandidates,\n    selectForfeitOrExitPath,\n    forfeitExitAllPaths,\n    forfeitExitSpendablePaths,\n} from \"./helpers\";\nimport { timelockToSequence } from \"../../utils/timelock\";\n\n/**\n * Typed parameters for DefaultVtxo contracts.\n */\nexport interface DefaultContractParams {\n    pubKey: Uint8Array;\n    serverPubKey: Uint8Array;\n    csvTimelock: RelativeTimelock;\n}\n\n/**\n * Handler for default wallet VTXOs.\n *\n * Default contracts use the standard forfeit + exit tapscript:\n * - forfeit: (Alice + Server) multisig for collaborative spending\n * - exit: (Alice) + CSV timelock for unilateral exit\n */\nexport const DefaultContractHandler: ContractHandler<DefaultContractParams, DefaultVtxo.Script> &\n    Discoverable = {\n    type: \"default\",\n\n    createScript(params: Record<string, string>): DefaultVtxo.Script {\n        const typed = this.deserializeParams(params);\n        return new DefaultVtxo.Script(typed);\n    },\n\n    serializeParams(params: DefaultContractParams): Record<string, string> {\n        return {\n            pubKey: hex.encode(params.pubKey),\n            serverPubKey: hex.encode(params.serverPubKey),\n            csvTimelock: timelockToSequence(params.csvTimelock).toString(),\n        };\n    },\n\n    deserializeParams(params: Record<string, string>): DefaultContractParams {\n        return {\n            pubKey: extractPubKeyBytes(params.pubKey),\n            serverPubKey: extractPubKeyBytes(params.serverPubKey),\n            csvTimelock: deserializeCsvTimelock(params.csvTimelock),\n        };\n    },\n\n    selectPath(\n        script: DefaultVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection | null {\n        return selectForfeitOrExitPath(script, contract, context);\n    },\n\n    getAllSpendingPaths(\n        script: DefaultVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return forfeitExitAllPaths(script, contract, context);\n    },\n\n    getSpendablePaths(\n        script: DefaultVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return forfeitExitSpendablePaths(script, contract, context);\n    },\n\n    /** The wallet's own money. */\n    isGenericallySpendable: () => true,\n\n    discoverAt: discoverAtViaRange(discoverDefaultRange),\n\n    discoverRange: discoverDefaultRange,\n\n    candidatesAt: defaultCandidatesAt,\n};\n\n/**\n * The signer × CSV-timelock cross-product under the index's leaf key. Each\n * candidate's own signer is threaded through its params and address so\n * signing/forfeit later resolves the right key.\n */\nfunction defaultCandidatesAt(\n    _index: number,\n    descriptor: string,\n    deps: CandidateDeps,\n): DiscoveredContract[] {\n    return buildSignerTimelockCandidates(\n        descriptor,\n        deps,\n        (opts) => new DefaultVtxo.Script(opts),\n    ).map((c) => ({\n        type: \"default\",\n        params: {\n            pubKey: hex.encode(c.pubKey),\n            serverPubKey: hex.encode(c.serverPubKey),\n            csvTimelock: timelockToSequence(c.csvTimelock).toString(),\n        },\n        script: c.scriptHex,\n        address: c.script.address(deps.network.hrp, c.serverPubKey).encode(),\n    }));\n}\n\nfunction discoverDefaultRange(\n    entries: readonly { index: number; descriptor: string }[],\n    deps: DiscoveryDeps,\n): Promise<Map<number, DiscoveredContract[]>> {\n    return discoverIndexerCandidates(\n        deps.indexerProvider,\n        entries,\n        (index, descriptor) => defaultCandidatesAt(index, descriptor, deps),\n        (c, index, descriptor) => ({ ...c, ...rotatedReceiveMetadata(index, descriptor) }),\n    );\n}\n","import { Bytes } from \"@scure/btc-signer/utils.js\";\nimport { DefaultVtxo } from \"./default\";\nimport { MultisigTapscript } from \"./tapscript\";\nimport { TapLeafScript, VtxoScript } from \"./base\";\nimport { hex } from \"@scure/base\";\n\n/**\n * DelegateVtxo extends DefaultVtxo with an extra delegate path\n */\nexport namespace DelegateVtxo {\n    /**\n     * Options extends DefaultVtxo.Options and adds a delegatePubKey\n     */\n    export interface Options extends DefaultVtxo.Options {\n        delegatePubKey: Bytes;\n    }\n\n    /**\n     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.\n     * @example\n     * ```typescript\n     * const vtxoScript = new DelegateVtxo.Script({\n     *     pubKey: new Uint8Array(32),\n     *     serverPubKey: new Uint8Array(32),\n     *     delegatePubKey: new Uint8Array(32),\n     *     csvTimelock: {\n     *         value: 605184n,\n     *         type: \"seconds\"\n     *     }\n     * });\n     *\n     * console.log(\"script pub key:\", vtxoScript.pkScript)\n     * ```\n     */\n    export class Script extends VtxoScript {\n        readonly defaultVtxo: DefaultVtxo.Script;\n        readonly delegateScript: string;\n\n        /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */\n        constructor(readonly options: Options) {\n            const defaultVtxo = new DefaultVtxo.Script(options);\n            const { delegatePubKey, pubKey, serverPubKey } = options;\n            const delegateScript = MultisigTapscript.encode({\n                pubkeys: [pubKey, delegatePubKey, serverPubKey],\n            }).script;\n\n            super([...defaultVtxo.scripts, delegateScript]);\n\n            this.defaultVtxo = defaultVtxo;\n            this.delegateScript = hex.encode(delegateScript);\n        }\n\n        /** Return the forfeit tapleaf script. */\n        forfeit(): TapLeafScript {\n            return this.findLeaf(this.defaultVtxo.forfeitScript);\n        }\n\n        /** Return the unilateral exit tapleaf script. */\n        exit(): TapLeafScript {\n            return this.findLeaf(this.defaultVtxo.exitScript);\n        }\n\n        /** Return the delegate tapleaf script. */\n        delegate(): TapLeafScript {\n            return this.findLeaf(this.delegateScript);\n        }\n    }\n}\n","import { hex } from \"@scure/base\";\nimport { DelegateVtxo } from \"../../script/delegate\";\nimport { RelativeTimelock } from \"../../script/tapscript\";\nimport { Contract, ContractHandler, Discoverable, PathContext, PathSelection } from \"../types\";\nimport type { CandidateDeps, DiscoveredContract, DiscoveryDeps } from \"../types\";\nimport {\n    discoverIndexerCandidates,\n    discoverAtViaRange,\n    extractPubKeyBytes,\n    deserializeCsvTimelock,\n    rotatedReceiveMetadata,\n    buildSignerTimelockCandidates,\n    selectForfeitOrExitPath,\n    forfeitExitAllPaths,\n    forfeitExitSpendablePaths,\n} from \"./helpers\";\nimport { timelockToSequence } from \"../../utils/timelock\";\n\n/**\n * Typed parameters for DelegateVtxo contracts.\n */\nexport interface DelegateContractParams {\n    pubKey: Uint8Array;\n    serverPubKey: Uint8Array;\n    delegatePubKey: Uint8Array;\n    csvTimelock: RelativeTimelock;\n}\n\n/**\n * Handler for delegate wallet virtual outputs.\n *\n * Delegate contracts extend the default tapscript with an additional delegate path:\n * - forfeit: (Alice + Server) multisig for collaborative spending\n * - exit: (Alice) + CSV timelock for unilateral exit\n * - delegate: (Alice + Delegate + Server) multisig for delegated renewal\n */\nexport const DelegateContractHandler: ContractHandler<DelegateContractParams, DelegateVtxo.Script> &\n    Discoverable = {\n    type: \"delegate\",\n\n    createScript(params: Record<string, string>): DelegateVtxo.Script {\n        const typed = this.deserializeParams(params);\n        return new DelegateVtxo.Script(typed);\n    },\n\n    serializeParams(params: DelegateContractParams): Record<string, string> {\n        return {\n            pubKey: hex.encode(params.pubKey),\n            serverPubKey: hex.encode(params.serverPubKey),\n            delegatePubKey: hex.encode(params.delegatePubKey),\n            csvTimelock: timelockToSequence(params.csvTimelock).toString(),\n        };\n    },\n\n    deserializeParams(params: Record<string, string>): DelegateContractParams {\n        return {\n            pubKey: extractPubKeyBytes(params.pubKey),\n            serverPubKey: extractPubKeyBytes(params.serverPubKey),\n            delegatePubKey: extractPubKeyBytes(params.delegatePubKey),\n            csvTimelock: deserializeCsvTimelock(params.csvTimelock),\n        };\n    },\n\n    selectPath(\n        script: DelegateVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection | null {\n        return selectForfeitOrExitPath(script, contract, context);\n    },\n\n    getAllSpendingPaths(\n        script: DelegateVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return [\n            ...forfeitExitAllPaths(script, contract, context),\n            // Delegate path (Alice + Delegate + Server) — collaborative only,\n            // and last so the shared forfeit/exit ordering is unchanged.\n            ...(context.collaborative ? [{ leaf: script.delegate() }] : []),\n        ];\n    },\n\n    getSpendablePaths(\n        script: DelegateVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return forfeitExitSpendablePaths(script, contract, context);\n    },\n\n    /** The wallet's own money, delegated signing. */\n    isGenericallySpendable: () => true,\n\n    discoverAt: discoverAtViaRange(discoverDelegateRange),\n\n    discoverRange: discoverDelegateRange,\n\n    candidatesAt: delegateCandidatesAt,\n};\n\n/**\n * The `default` cross-product (@see DefaultContractHandler.candidatesAt) under\n * the wallet's delegate key. Empty for a non-delegate wallet.\n */\nfunction delegateCandidatesAt(\n    _index: number,\n    descriptor: string,\n    deps: CandidateDeps,\n): DiscoveredContract[] {\n    const delegatePubKey = deps.delegatePubKey;\n    if (!delegatePubKey) return [];\n\n    return buildSignerTimelockCandidates(\n        descriptor,\n        deps,\n        (opts) => new DelegateVtxo.Script({ ...opts, delegatePubKey }),\n    ).map((c) => ({\n        type: \"delegate\",\n        params: {\n            pubKey: hex.encode(c.pubKey),\n            serverPubKey: hex.encode(c.serverPubKey),\n            delegatePubKey: hex.encode(delegatePubKey),\n            csvTimelock: timelockToSequence(c.csvTimelock).toString(),\n        },\n        script: c.scriptHex,\n        address: c.script.address(deps.network.hrp, c.serverPubKey).encode(),\n    }));\n}\n\nfunction discoverDelegateRange(\n    entries: readonly { index: number; descriptor: string }[],\n    deps: DiscoveryDeps,\n): Promise<Map<number, DiscoveredContract[]>> {\n    // Not a delegate wallet: still answer for every requested index, since an\n    // omission would read as indeterminate and truncate the scan.\n    if (!deps.delegatePubKey) {\n        return Promise.resolve(new Map(entries.map((e) => [e.index, []])));\n    }\n\n    return discoverIndexerCandidates(\n        deps.indexerProvider,\n        entries,\n        (index, descriptor) => delegateCandidatesAt(index, descriptor, deps),\n        (c, index, descriptor) => ({ ...c, ...rotatedReceiveMetadata(index, descriptor) }),\n    );\n}\n","/**\n * Arkade Script Opcodes\n *\n * This module defines ONLY Arkade-specific opcodes (0xb3, 0xc3-0xf8).\n * Standard Bitcoin opcodes are imported from @scure/btc-signer.\n *\n * Reference: arkade-os/emulator pkg/arkade/opcode.go.\n * Byte 0xdc is OP_CHECKTIME, matching emulator v0.0.8 and compiler artifacts.\n */\n\nimport { OP } from \"@scure/btc-signer\";\nexport { OP };\n\nexport const ARKADE_OP = {\n    // Merkle Branch Verification (0xb3 — repurposed NOP4 slot)\n    MERKLEBRANCHVERIFY: 0xb3,\n\n    // Digest (0xc3)\n    DIGEST: 0xc3,\n\n    // SHA256 Streaming (0xc4-0xc6)\n    SHA256INITIALIZE: 0xc4,\n    SHA256UPDATE: 0xc5,\n    SHA256FINALIZE: 0xc6,\n\n    // Input Introspection (0xc7-0xcb)\n    INSPECTINPUTOUTPOINT: 0xc7,\n    INSPECTINPUTARKADESCRIPTHASH: 0xc8,\n    INSPECTINPUTVALUE: 0xc9,\n    INSPECTINPUTSCRIPTPUBKEY: 0xca,\n    INSPECTINPUTSEQUENCE: 0xcb,\n\n    // Signatures (0xcc-0xcd)\n    CHECKSIGFROMSTACK: 0xcc,\n    PUSHCURRENTINPUTINDEX: 0xcd,\n\n    // Input Arkade Witness Introspection (0xce)\n    INSPECTINPUTARKADEWITNESSHASH: 0xce,\n\n    // Output Introspection (0xcf, 0xd1)\n    INSPECTOUTPUTVALUE: 0xcf,\n    INSPECTOUTPUTSCRIPTPUBKEY: 0xd1,\n\n    // Transaction Introspection (0xd2-0xd6)\n    INSPECTVERSION: 0xd2,\n    INSPECTLOCKTIME: 0xd3,\n    INSPECTNUMINPUTS: 0xd4,\n    INSPECTNUMOUTPUTS: 0xd5,\n    TXWEIGHT: 0xd6,\n\n    // Byte/Number Conversion & Arithmetic (0xd7-0xda)\n    NUM2BIN: 0xd7,\n    BIN2NUM: 0xd8,\n    REVERSEBYTES: 0xd9,\n    MODEXP: 0xda,\n    // VTXO Expiry & Emulator Clock (0xdb-0xdc)\n    PUSHEXPIRY: 0xdb,\n    CHECKTIME: 0xdc,\n    // 0xdd-0xdf are unassigned (OP_UNKNOWN221-223)\n\n    // EC Operations (0xe0-0xe2)\n    ECADD: 0xe0,\n    ECMUL: 0xe1,\n    ECPAIRING: 0xe2,\n\n    // EC Operations (0xe3-0xe4)\n    ECMULSCALARVERIFY: 0xe3,\n    TWEAKVERIFY: 0xe4,\n\n    // Asset Groups (0xe5-0xf2)\n    INSPECTNUMASSETGROUPS: 0xe5,\n    INSPECTASSETGROUPASSETID: 0xe6,\n    INSPECTASSETGROUPCTRL: 0xe7,\n    FINDASSETGROUPBYASSETID: 0xe8,\n    INSPECTASSETGROUPMETADATAHASH: 0xe9,\n    INSPECTASSETGROUPNUM: 0xea,\n    INSPECTASSETGROUP: 0xeb,\n    INSPECTASSETGROUPSUM: 0xec,\n    INSPECTOUTASSETCOUNT: 0xed,\n    INSPECTOUTASSETAT: 0xee,\n    INSPECTOUTASSETLOOKUP: 0xef,\n    INSPECTINASSETCOUNT: 0xf0,\n    INSPECTINASSETAT: 0xf1,\n    INSPECTINASSETLOOKUP: 0xf2,\n\n    // Transaction ID (0xf3)\n    TXID: 0xf3,\n\n    // Packet Introspection (0xf4-0xf5) — added in emulator v0.0.1\n    INSPECTPACKET: 0xf4,\n    INSPECTINPUTPACKET: 0xf5,\n\n    // Signature Hash (0xf6)\n    SIGHASH: 0xf6,\n\n    // Continuation & Intent Introspection (0xf7-0xf8)\n    TUNNEL: 0xf7,\n    INSPECTINTENTMESSAGE: 0xf8,\n} as const;\n\nexport const ARKADE_OPCODES: number[] = Object.values(ARKADE_OP);\n\nexport const ARKADE_OPCODE_NAMES: Record<number, string> = Object.fromEntries(\n    Object.entries(ARKADE_OP).map(([name, value]) => [value, name]),\n);\n\nexport const ARKADE_OPCODE_VALUES: Record<string, number> = Object.fromEntries(\n    Object.entries(ARKADE_OPCODE_NAMES).map(([value, name]) => [name, Number(value)]),\n);\n\nfunction buildBitcoinOpcodeNames(): Record<number, string> {\n    const names: Record<number, string> = {};\n\n    // Standard opcodes from @scure/btc-signer\n    for (const [key, value] of Object.entries(OP)) {\n        if (typeof value === \"number\") {\n            // @scure uses names without OP_ prefix (e.g., \"DUP\", \"HASH160\")\n            // We need to add OP_ prefix for consistency\n            const name = key.startsWith(\"OP_\") ? key : `OP_${key}`;\n            names[value] = name;\n        }\n    }\n\n    // Special case: OP_0 is stored as \"OP_0\" in @scure\n    names[0x00] = \"OP_0\";\n\n    return names;\n}\n\nfunction buildBitcoinOpcodeValues(): Record<string, number> {\n    const values: Record<string, number> = {};\n\n    for (const [key, value] of Object.entries(OP)) {\n        if (typeof value === \"number\") {\n            const name = key.startsWith(\"OP_\") ? key : `OP_${key}`;\n            values[name] = value;\n            // Also support name without prefix\n            values[key] = value;\n        }\n    }\n\n    return values;\n}\n\nconst BITCOIN_OPCODE_NAMES = buildBitcoinOpcodeNames();\nconst BITCOIN_OPCODE_VALUES = buildBitcoinOpcodeValues();\n\n/**\n * Combined map from opcode value to name (with OP_ prefix)\n * Includes both Bitcoin and Arkade opcodes\n */\nexport const OPCODE_NAMES: Record<number, string> = {\n    ...BITCOIN_OPCODE_NAMES,\n    // Add Arkade opcodes with OP_ prefix\n    ...Object.fromEntries(\n        Object.entries(ARKADE_OPCODE_NAMES).map(([value, name]) => [Number(value), `OP_${name}`]),\n    ),\n};\n\n/**\n * Combined map from opcode name to value\n * Supports both with and without OP_ prefix\n * Includes both Bitcoin and Arkade opcodes\n */\nexport const OPCODE_VALUES: Record<string, number> = {\n    ...BITCOIN_OPCODE_VALUES,\n    // Add Arkade opcodes with and without OP_ prefix\n    ...ARKADE_OPCODE_VALUES,\n    ...Object.fromEntries(\n        Object.entries(ARKADE_OPCODE_VALUES).map(([name, value]) => [`OP_${name}`, value]),\n    ),\n};\n\n/**\n * Get the name of an opcode from its value\n * Returns OP_DATA_N for data push opcodes (0x01-0x4b)\n *\n * @param value Opcode byte value\n * @returns Opcode name with OP_ prefix, or undefined if unknown\n */\nexport function getOpcodeName(value: number): string | undefined {\n    // Handle data push opcodes (0x01-0x4b) as OP_DATA_N\n    if (value >= 0x01 && value <= 0x4b) {\n        return `OP_DATA_${value}`;\n    }\n\n    // Check combined mappings\n    return OPCODE_NAMES[value];\n}\n\n/**\n * Get the value of an opcode from its name\n * Supports OP_DATA_N pattern for data push opcodes\n *\n * @param name Opcode name (with or without OP_ prefix)\n * @returns Opcode byte value, or undefined if unknown\n */\nexport function getOpcodeValue(name: string): number | undefined {\n    // Handle OP_DATA_N pattern\n    const dataMatch = name.match(/^OP_DATA_(\\d+)$/);\n    if (dataMatch) {\n        const n = parseInt(dataMatch[1], 10);\n        if (n >= 1 && n <= 75) {\n            return n;\n        }\n        return undefined;\n    }\n\n    // Check combined mappings\n    return OPCODE_VALUES[name];\n}\n","/**\n * BigNum — arbitrary-precision sign-magnitude little-endian encoding used by\n * the arkade VM in emulator v0.0.1. Up to 520 bytes (= MaxScriptElementSize).\n *\n * Wire format:\n *   - empty bytes   = 0\n *   - last byte's high bit (0x80) is the sign (set = negative)\n *   - remaining bits are magnitude, little-endian\n *   - minimal: no trailing zero magnitude byte; `[0x80]` (negative zero) is rejected\n *\n * Wraps `@scure/btc-signer`'s `ScriptNum` with a 520-byte cap. Use the\n * standalone API when you need to round-trip values outside of script encoding;\n * inside `ArkadeScript.encode([...])`, plain `bigint` literals work directly.\n */\n\nimport { ScriptNum } from \"@scure/btc-signer\";\n\n/** Maximum number of bytes for a BigNum (= MaxScriptElementSize). */\nexport const BIGNUM_MAX_BYTES = 520;\n\nconst codec = ScriptNum(BIGNUM_MAX_BYTES, /* forceMinimal */ true);\n\n/**\n * Encode `value` as a minimal sign-magnitude little-endian byte string.\n * Throws if the encoding would exceed 520 bytes.\n */\nexport function encode(value: bigint): Uint8Array {\n    const result = codec.encode(value);\n    if (result.length > BIGNUM_MAX_BYTES) {\n        throw new Error(`BigNum value exceeds 520 bytes (encoded to ${result.length} bytes)`);\n    }\n    return result;\n}\n\n/**\n * Decode a minimal sign-magnitude little-endian byte string into a bigint.\n * Throws on non-minimal encodings or values longer than 520 bytes.\n */\nexport function decode(value: Uint8Array): bigint {\n    return codec.decode(value);\n}\n","/**\n * Arkade Script Encoding and Decoding\n *\n * This module provides script encoding/decoding and ASM conversion helpers\n * that work with both standard Bitcoin opcodes and Arkade extension opcodes.\n *\n * Note: We use our own decoder for scripts because @scure/btc-signer doesn't\n * recognize Arkade opcodes (0xb3, 0xc4-0xf3) and would treat them as data pushes.\n */\n\nimport * as P from \"micro-packed\";\nimport { Script, type ScriptType, OP } from \"@scure/btc-signer\";\nimport { hex } from \"@scure/base\";\nimport { ARKADE_OP } from \"./opcodes\";\nimport * as BigNum from \"./bignum\";\n\n// Re-export Script and ScriptType from @scure\nexport { Script, type ScriptType };\n\n/**\n * Combined OP map: standard Bitcoin opcodes + Arkade extension opcodes.\n * Keys follow @scure convention (without OP_ prefix for most).\n */\nexport const ARKADE_OPS = { ...OP, ...ARKADE_OP } as const;\n\n/** Reverse lookup: byte value → opcode name */\nconst ArkadeOPNames: Record<number, string> = {};\nfor (const [k, v] of Object.entries(ARKADE_OPS)) {\n    if (typeof v === \"number\") ArkadeOPNames[v] = k;\n}\n\n/** A single script operation: opcode string key, raw bytes, number, or bigint */\nexport type ArkadeScriptOP = keyof typeof ARKADE_OPS | Uint8Array | number | bigint;\n\n/** Array of script operations — the type that ArkadeScript encodes/decodes */\nexport type ArkadeScriptType = ArkadeScriptOP[];\n\n/**\n * Script CoderType with Arkade extension opcodes.\n *\n * Same API as `Script` from @scure/btc-signer, but with Arkade extension opcodes.\n *\n * @example\n * ```typescript\n * const script: ArkadeScriptType = ['DUP', 'HASH160', pubkeyHash, 'EQUALVERIFY', 'NUM2BIN'];\n * const bytes = ArkadeScript.encode(script);\n * const decoded = ArkadeScript.decode(bytes);\n * ```\n */\nexport const ArkadeScript: P.CoderType<ArkadeScriptType> = P.wrap({\n    encodeStream: (w: P.Writer, value: ArkadeScriptType) => {\n        for (let o of value) {\n            if (typeof o === \"string\") {\n                const v = ARKADE_OPS[o as keyof typeof ARKADE_OPS];\n                if (v === undefined) throw new Error(`Unknown opcode=${o}`);\n                w.byte(v);\n                continue;\n            } else if (typeof o === \"number\" || typeof o === \"bigint\") {\n                // Encode numbers via BigNum (520-byte cap).\n                const big = typeof o === \"number\" ? BigInt(o) : o;\n                o = BigNum.encode(big);\n            }\n            if (!(o instanceof Uint8Array)) throw new Error(`Wrong Script OP=${o} (${typeof o})`);\n            // Bytes (data push)\n            const len = o.length;\n            // Arkade VM enforces MINIMALDATA for small script numbers.\n            if (len === 1 && o[0] >= 1 && o[0] <= 16) {\n                w.byte(OP.OP_1 - 1 + o[0]);\n                continue;\n            } else if (len === 1 && o[0] === 0x81) {\n                w.byte(OP[\"1NEGATE\"]);\n                continue;\n            } else if (len < OP.PUSHDATA1) w.byte(len);\n            else if (len <= 0xff) {\n                w.byte(OP.PUSHDATA1);\n                w.byte(len);\n            } else if (len <= 0xffff) {\n                w.byte(OP.PUSHDATA2);\n                w.bytes(P.U16LE.encode(len));\n            } else {\n                w.byte(OP.PUSHDATA4);\n                w.bytes(P.U32LE.encode(len));\n            }\n            w.bytes(o);\n        }\n    },\n    decodeStream: (r: P.Reader): ArkadeScriptType => {\n        const out: ArkadeScriptType = [];\n        while (!r.isEnd()) {\n            const cur = r.byte();\n            // Data push: 0 < cur <= PUSHDATA4\n            if (OP.OP_0 < cur && cur <= OP.PUSHDATA4) {\n                let len;\n                if (cur < OP.PUSHDATA1) len = cur;\n                else if (cur === OP.PUSHDATA1) len = P.U8.decodeStream(r);\n                else if (cur === OP.PUSHDATA2) len = P.U16LE.decodeStream(r);\n                else if (cur === OP.PUSHDATA4) len = P.U32LE.decodeStream(r);\n                else throw new Error(\"Should be not possible\");\n                out.push(r.bytes(len));\n            } else if (cur === 0x00) {\n                out.push(0);\n            } else if (OP.OP_1 <= cur && cur <= OP.OP_16) {\n                out.push(cur - (OP.OP_1 - 1));\n            } else if (cur === OP[\"1NEGATE\"]) {\n                out.push(-1);\n            } else {\n                const op = ArkadeOPNames[cur] as keyof typeof ARKADE_OPS;\n                if (op === undefined) throw new Error(`Unknown opcode=${cur.toString(16)}`);\n                out.push(op);\n            }\n        }\n        return out;\n    },\n});\n\n/**\n * Convert script operations to ASM (assembly) format.\n * Supports both Bitcoin and Arkade opcodes.\n *\n * @example\n * ```typescript\n * toASM(['DUP', 'HASH160', 'INSPECTOUTPUTVALUE']) // \"OP_DUP OP_HASH160 OP_INSPECTOUTPUTVALUE\"\n * toASM(ArkadeScript.decode(bytes))\n * ```\n */\nexport function toASM(script: ArkadeScriptType): string {\n    const parts: string[] = [];\n\n    for (const op of script) {\n        if (typeof op === \"string\") {\n            // Opcode name from ArkadeOPNames — add OP_ prefix for ASM format\n            const name = op.startsWith(\"OP_\") ? op : `OP_${op}`;\n            parts.push(name);\n        } else if (typeof op === \"number\" || typeof op === \"bigint\") {\n            if (op === 0 || op === 0n) {\n                parts.push(\"OP_0\");\n            } else if (op >= 1 && op <= 16) {\n                parts.push(`OP_${op}`);\n            } else if (op === -1 || op === -1n) {\n                parts.push(\"OP_1NEGATE\");\n            } else {\n                // A bare decimal token would not survive fromASM (it parses\n                // hex or opcodes only) — render the minimal script-num bytes,\n                // which re-encode byte-identically to the number itself.\n                parts.push(hex.encode(BigNum.encode(BigInt(op))));\n            }\n        } else {\n            // Uint8Array data\n            parts.push(hex.encode(op));\n        }\n    }\n\n    return parts.join(\" \");\n}\n\n/**\n * Parse ASM (assembly) format to script operations.\n * Supports both Bitcoin and Arkade opcodes.\n *\n * @example\n * ```typescript\n * fromASM(\"OP_DUP OP_HASH160 deadbeef OP_NUM2BIN\")\n * // => ['DUP', 'HASH160', Uint8Array, 'NUM2BIN']\n * ```\n */\nexport function fromASM(asm: string): ArkadeScriptType {\n    const tokens = asm.trim().split(/\\s+/).filter(Boolean);\n    const out: ArkadeScriptType = [];\n\n    for (const token of tokens) {\n        // OP_0 → number 0\n        if (token === \"OP_0\" || token === \"OP_FALSE\") {\n            out.push(0);\n            continue;\n        }\n\n        // OP_TRUE → number 1\n        if (token === \"OP_TRUE\") {\n            out.push(1);\n            continue;\n        }\n\n        // OP_1 through OP_16 → number\n        const numMatch = token.match(/^OP_(\\d+)$/);\n        if (numMatch) {\n            const n = parseInt(numMatch[1], 10);\n            if (n >= 1 && n <= 16) {\n                out.push(n);\n                continue;\n            }\n        }\n\n        // Try opcode lookup: strip OP_ prefix to get the key in ARKADE_OPS\n        let key: string | undefined;\n        if (token.startsWith(\"OP_\")) {\n            key = token.slice(3);\n        } else {\n            key = token;\n        }\n\n        if (key in ARKADE_OPS) {\n            out.push(key as keyof typeof ARKADE_OPS);\n            continue;\n        }\n\n        // Try to parse as hex data\n        if (/^[0-9a-fA-F]+$/.test(token) && token.length % 2 === 0) {\n            try {\n                out.push(hex.decode(token));\n                continue;\n            } catch {\n                // Not valid hex, fall through\n            }\n        }\n\n        throw new Error(`Invalid ASM token: ${token}`);\n    }\n\n    return out;\n}\n\n/**\n * Convert ASM string directly to script bytes\n */\nexport function asmToBytes(asm: string): Uint8Array {\n    return ArkadeScript.encode(fromASM(asm));\n}\n\n/**\n * Convert script bytes directly to ASM string\n */\nexport function bytesToASM(script: Uint8Array): string {\n    return toASM(ArkadeScript.decode(script));\n}\n","/**\n * Normalize a secp256k1 public key to the 32-byte x-only form every tapscript,\n * covenant param and `params.serverPubKey` in this SDK is denominated in.\n *\n * A compressed key drops its parity prefix; an x-only key passes through. Both\n * arrive over the same wires — arkd advertises `signerPubkey` either way,\n * `Identity.xOnlyPublicKey` implementations vary, and solver-supplied fields\n * are whatever the peer sent — so the caller usually cannot know which it\n * holds. Anything else is refused rather than silently truncated: a 65-byte\n * uncompressed key, stripped of one byte, yields a plausible 32-byte value\n * that is not the key, which surfaces as an address nobody funded.\n *\n * The result may alias `key` rather than copy it; callers that mutate either\n * value after normalization should copy first.\n *\n * @param key - 32-byte x-only or 33-byte compressed public key\n * @param label - Name used in the error, e.g. `\"ark signer key\"`\n * @see toXOnlySignerHex for the hex-in, hex-out signer-rotation equivalent\n */\nexport function toXOnly(key: Uint8Array, label = \"public key\"): Uint8Array {\n    if (key.length === 32) return key;\n    if (key.length === 33 && (key[0] === 0x02 || key[0] === 0x03)) return key.subarray(1);\n    throw new Error(`${label} is not a compressed or x-only public key`);\n}\n","/**\n * Arkade Script Tweak\n *\n * Computes the tweaked public key for Arkade scripts.\n * The tweak is: tweakedPubKey = P + taggedHash(\"ArkScriptHash\", script) * G\n *\n * This is NOT taproot tweaking — it's a simple EC point addition used by\n * the emulator service to bind a script to a signing key.\n */\n\nimport { schnorr, secp256k1 } from \"@noble/curves/secp256k1.js\";\nimport { bytesToNumberBE } from \"@noble/curves/utils.js\";\n\nimport { toXOnly } from \"../utils/keys\";\n\nconst TAG_SCRIPT = \"ArkScriptHash\";\nconst TAG_WITNESS = \"ArkWitnessHash\";\n\n/**\n * Compute the tagged hash of an Arkade script.\n * Uses BIP-340 tagged hash: SHA256(SHA256(tag) || SHA256(tag) || script)\n *\n * @param script - The raw Arkade script bytes\n * @returns 32-byte hash\n */\nexport function arkadeScriptHash(script: Uint8Array): Uint8Array {\n    return schnorr.utils.taggedHash(TAG_SCRIPT, script);\n}\n\n/**\n * Compute the tagged hash of an Arkade witness.\n * Uses BIP-340 tagged hash: SHA256(SHA256(tag) || SHA256(tag) || witness)\n *\n * @param witness - The raw Arkade witness bytes\n * @returns 32-byte hash, or 32 zero bytes if witness is empty\n */\nexport function arkadeWitnessHash(witness: Uint8Array): Uint8Array {\n    if (witness.length === 0) {\n        return new Uint8Array(32);\n    }\n    return schnorr.utils.taggedHash(TAG_WITNESS, witness);\n}\n\n/**\n * Compute the Arkade script tweaked public key.\n * result = pubKey + taggedHash(\"ArkScriptHash\", script) * G\n *\n * The input pubKey should be a compressed (33-byte) or x-only (32-byte) public key.\n * Returns a 32-byte x-only public key.\n *\n * @param pubKey - The emulator's base public key (32 or 33 bytes)\n * @param script - The raw Arkade script bytes\n * @returns 32-byte x-only tweaked public key\n */\nexport function computeArkadeScriptPublicKey(pubKey: Uint8Array, script: Uint8Array): Uint8Array {\n    const hash = arkadeScriptHash(script);\n\n    const point = schnorr.utils.lift_x(bytesToNumberBE(toXOnly(pubKey, \"emulator key\")));\n\n    // tweak = (scriptHash mod n) * G\n    const scalar = bytesToNumberBE(hash) % secp256k1.Point.CURVE().n;\n    const tweak = secp256k1.Point.BASE.multiply(scalar);\n\n    return schnorr.utils.pointToBytes(point.add(tweak));\n}\n","import { Script } from \"@scure/btc-signer\";\nimport { Bytes } from \"@scure/btc-signer/utils.js\";\nimport {\n    CLTVMultisigTapscript,\n    ConditionCSVMultisigTapscript,\n    ConditionMultisigTapscript,\n    CSVMultisigTapscript,\n    MultisigTapscript,\n    RelativeTimelock,\n} from \"./tapscript\";\nimport { hex } from \"@scure/base\";\nimport { TapLeafScript, VtxoScript } from \"./base\";\nimport { ArkadeScript, type ArkadeScriptType } from \"../arkade/script\";\nimport { computeArkadeScriptPublicKey } from \"../arkade/tweak\";\n\n/** Virtual Hash Time Lock Contract (VHTLC) namespace. */\nexport namespace VHTLC {\n    export interface Options {\n        sender: Bytes;\n        receiver: Bytes;\n        server: Bytes;\n        preimageHash: Bytes;\n        refundLocktime: bigint;\n        unilateralClaimDelay: RelativeTimelock;\n        unilateralRefundDelay: RelativeTimelock;\n        unilateralRefundWithoutReceiverDelay: RelativeTimelock;\n        /**\n         * The emulator covenant leaves, ALL OR NOTHING. Present, this adds the\n         * three non-interactive leaves the emulator co-signs under a covenant\n         * pinning the payout to a pre-committed destination:\n         *\n         *  - `nonInteractiveClaim`: `server` + a covenant-tweaked emulator\n         *    co-signer, paying `receiverPkScript` — the receiver's claim can\n         *    be pushed without the receiver being online.\n         *  - `nonInteractiveRefund`: `server` + `receiver` + a covenant-tweaked\n         *    emulator co-signer, paying `senderPkScript`, no timelock — lets\n         *    server and receiver release the refund the moment they agree the\n         *    swap has failed, and recoverable even if the sender's own key is\n         *    lost, since no OTHER refund-side leaf survives that.\n         *  - `nonInteractiveRefundWithoutReceiver`: `server` + the SAME\n         *    covenant-tweaked co-signer as `nonInteractiveRefund`, paying\n         *    `senderPkScript` after `refundLocktime` — the only refund tier\n         *    needing no participant signature at all, so a sender who funded\n         *    a lockup and vanished is refundable through it alone.\n         *\n         * WHY ONE FLAG AND NOT A SWITCH PER LEAF. The three are one mechanism\n         * — the same emulator key, the same `enforcePayTo` covenant pointed\n         * at a per-role destination — and they protect opposite directions of\n         * the same swap, so no real configuration wants a subset. A subset\n         * would cost, not buy: every optional leaf multiplies the tree shapes\n         * a counterparty must derive to verify an address (nothing on the\n         * wire says which leaves a quote carries), so per-leaf toggling turns\n         * one address comparison into a combinatorial guess. All-or-nothing\n         * keeps the shape count at two: suite, or no suite.\n         *\n         * Leaf order fixes the taproot merkle root, so the suite is appended\n         * after the six signature leaves in a fixed order (claim, refund,\n         * timelocked refund) and a script built with this option NEVER\n         * collides with one built without it — which is what makes \"did this\n         * quote opt in\" a question an address comparison answers.\n         *\n         * STABLE PER RELEASE: what this option builds does not change within\n         * a published SDK version. A future covenant leaf joins the suite\n         * only behind a NEW option, so re-deriving a lockup with the SDK\n         * that quoted it reproduces its address byte-for-byte.\n         */\n        nonInteractiveParameters?: {\n            /**\n             * The emulator service's public key, 32-byte x-only or 33-byte\n             * compressed. ONE key, tweaked per covenant destination, becomes\n             * the co-signer of every leaf in the suite — the leaves share it\n             * structurally, and BIP-341 tapscript sighashes committing to the\n             * tapleaf hash are what keep a signature for one leaf from\n             * replaying against another.\n             */\n            emulatorPubkey: Bytes;\n            /**\n             * Where the claim covenant pays: the receiver's own P2TR\n             * pkScript, 34 bytes.\n             */\n            receiverPkScript: Bytes;\n            /**\n             * Where BOTH refund covenants pay: the sender's own P2TR\n             * pkScript, 34 bytes. One destination shared by both refund\n             * leaves, so they cannot diverge on where a refund goes.\n             */\n            senderPkScript: Bytes;\n            /**\n             * LEGACY REBUILD ONLY — never for a new lockup.\n             *\n             * `\"preTimelockedRefund\"` builds the suite WITHOUT its timelocked\n             * refund leaf: the shape every emulator-covenant lockup funded\n             * before that leaf shipped carries. Lockups already funded in that\n             * shape keep it permanently — a leaf cannot be retrofitted onto an\n             * address already committed — so re-deriving such a lockup (to\n             * spend it, or to verify an old quote's address) needs this. A new\n             * lockup that omits the leaf gives up the one refund tier needing\n             * nobody, for nothing.\n             */\n            legacy?: \"preTimelockedRefund\";\n        };\n        /**\n         * Optional: denominate this contract in an Arkade ASSET rather than in\n         * sats alone.\n         *\n         * Only the two NON-INTERACTIVE leaves change. Every other leaf is a\n         * signature path that asserts nothing about value, so an asset makes no\n         * difference to them — which is why this option reaches exactly the\n         * leaves whose covenant the emulator enforces.\n         *\n         * When set, those covenants additionally require the output to carry at\n         * least the input's amount of THIS asset, and to carry exactly one\n         * asset. The sat clause is RETAINED, not replaced: an asset-carrying\n         * VTXO carries sats too, so dropping it would let a spend satisfy the\n         * asset covenant while stripping the sats — exactly as the sat-only\n         * covenant lets a spend strip the asset.\n         *\n         * ONE ASSET IS BOUND, AND ONLY THAT ONE IS PROTECTED. If a VTXO funded to\n         * this contract carries ADDITIONAL assets alongside the bound one, those\n         * are not covered: whoever assembles a covenant spend chooses where they\n         * go, and can send them anywhere.\n         *\n         * `INSPECTOUTASSETCOUNT == 1` does not close that. It constrains the\n         * covenant's OUTPUT to exactly one asset — so the extras cannot ride\n         * along with the bound asset — but arkd's conservation rule is satisfied\n         * by routing them to a different output, which the covenant says nothing\n         * about. The bound asset arrives; the rest is the spender's to direct.\n         *\n         * So fund an asset contract with the asset it names and nothing else. A\n         * multi-asset VTXO behind this covenant is a loss waiting for whoever\n         * pushes the spend.\n         *\n         * The id is the pair the introspection opcodes take. A canonical Asset\n         * ID is `(genesis txid, group index)`, never a single blob.\n         */\n        asset?: {\n            /**\n             * The asset's genesis transaction id, 32 bytes, in CANONICAL order\n             * — exactly the leading 32 bytes of a serialized Asset ID, no flip.\n             *\n             * The covenant reverses it internally because the introspection\n             * opcodes match wire order; callers never do that themselves, and a\n             * caller who pre-reverses gets a contract that is unspendable on its\n             * covenant leaves with nothing in the error naming why.\n             */\n            txid: Bytes;\n            /** The asset group index within that genesis transaction. */\n            groupIndex: number;\n        };\n    }\n\n    /**\n     * Shared construction and accessors for every VHTLC script version. The\n     * only thing that varies between versions is which preimage-condition\n     * fragment `claim`/`unilateralClaim`/`nonInteractiveClaim` are built\n     * from — everything else (the multisig/timelock leaves, the\n     * non-interactive covenant leaves, the accessor methods) is identical,\n     * so versions are expressed as thin subclasses over one builder rather\n     * than as separate, independently-maintained copies of this class.\n     */\n    abstract class BaseScript extends VtxoScript {\n        readonly options: Options;\n        readonly claimScript: string;\n        readonly refundScript: string;\n        readonly refundWithoutReceiverScript: string;\n        readonly unilateralClaimScript: string;\n        readonly unilateralRefundScript: string;\n        readonly unilateralRefundWithoutReceiverScript: string;\n        readonly nonInteractiveClaimScript?: string;\n        readonly nonInteractiveClaimArkadeScript?: Bytes;\n        readonly nonInteractiveRefundScript?: string;\n        readonly nonInteractiveRefundArkadeScript?: Bytes;\n        readonly nonInteractiveRefundWithoutReceiverScript?: string;\n        readonly nonInteractiveRefundWithoutReceiverArkadeScript?: Bytes;\n\n        protected constructor(options: Options, preimageCondition: (hash: Bytes) => Bytes) {\n            validateOptions(options);\n\n            const {\n                sender,\n                receiver,\n                server,\n                preimageHash,\n                refundLocktime,\n                unilateralClaimDelay,\n                unilateralRefundDelay,\n                unilateralRefundWithoutReceiverDelay,\n            } = options;\n\n            // The one leaf-condition fragment `claim`, `unilateralClaim`, and\n            // (when present) `nonInteractiveClaim` all reuse below — computed\n            // once so all three can never drift from one another within the\n            // same script version.\n            const conditionScript = preimageCondition(preimageHash);\n\n            const claimScript = ConditionMultisigTapscript.encode({\n                conditionScript,\n                pubkeys: [receiver, server],\n            }).script;\n\n            const refundScript = MultisigTapscript.encode({\n                pubkeys: [sender, receiver, server],\n            }).script;\n\n            const refundWithoutReceiverScript = CLTVMultisigTapscript.encode({\n                absoluteTimelock: refundLocktime,\n                pubkeys: [sender, server],\n            }).script;\n\n            const unilateralClaimScript = ConditionCSVMultisigTapscript.encode({\n                conditionScript,\n                timelock: unilateralClaimDelay,\n                pubkeys: [receiver],\n            }).script;\n\n            const unilateralRefundScript = CSVMultisigTapscript.encode({\n                timelock: unilateralRefundDelay,\n                pubkeys: [sender, receiver],\n            }).script;\n\n            const unilateralRefundWithoutReceiverScript = CSVMultisigTapscript.encode({\n                timelock: unilateralRefundWithoutReceiverDelay,\n                pubkeys: [sender],\n            }).script;\n\n            const scripts = [\n                claimScript,\n                refundScript,\n                refundWithoutReceiverScript,\n                unilateralClaimScript,\n                unilateralRefundScript,\n                unilateralRefundWithoutReceiverScript,\n            ];\n\n            let arkadeScriptNic: Bytes | undefined;\n            let nonInteractiveClaimScript: Bytes | undefined;\n            let arkadeScriptNir: Bytes | undefined;\n            let nonInteractiveRefundScript: Bytes | undefined;\n            let nonInteractiveRefundWithoutReceiverScript: Bytes | undefined;\n            const covenants = options.nonInteractiveParameters;\n            if (covenants) {\n                arkadeScriptNic = enforcePayToMaybeAsset(covenants.receiverPkScript, options.asset);\n                nonInteractiveClaimScript = ConditionMultisigTapscript.encode({\n                    conditionScript,\n                    pubkeys: [\n                        server,\n                        computeArkadeScriptPublicKey(covenants.emulatorPubkey, arkadeScriptNic),\n                    ],\n                }).script;\n                scripts.push(nonInteractiveClaimScript);\n\n                arkadeScriptNir = enforcePayToMaybeAsset(covenants.senderPkScript, options.asset);\n                // Derived ONCE and shared by both refund covenant leaves. They\n                // pin the same destination, so they must commit to the same\n                // key; computing it twice would make that a coincidence rather\n                // than a guarantee.\n                const nirCosigner = computeArkadeScriptPublicKey(\n                    covenants.emulatorPubkey,\n                    arkadeScriptNir,\n                );\n                // No timelock: server + receiver together can release this\n                // immediately, same as `refund` above, just without needing\n                // the sender's own signature — the covenant is what still\n                // guarantees the payout can only reach the sender.\n                nonInteractiveRefundScript = MultisigTapscript.encode({\n                    pubkeys: [server, receiver, nirCosigner],\n                }).script;\n                scripts.push(nonInteractiveRefundScript);\n\n                if (covenants.legacy !== \"preTimelockedRefund\") {\n                    // The same tier `refundWithoutReceiver` reaches, reached\n                    // without the sender: their signature is replaced by the\n                    // covenant, exactly as `nonInteractiveRefund` replaces it\n                    // in `refund`. Last in `scripts`, because leaf order fixes\n                    // the merkle root and every earlier leaf must keep its\n                    // position.\n                    nonInteractiveRefundWithoutReceiverScript = CLTVMultisigTapscript.encode({\n                        absoluteTimelock: refundLocktime,\n                        pubkeys: [server, nirCosigner],\n                    }).script;\n                    scripts.push(nonInteractiveRefundWithoutReceiverScript);\n                }\n            }\n\n            super(scripts);\n\n            this.options = options;\n            this.claimScript = hex.encode(claimScript);\n            this.refundScript = hex.encode(refundScript);\n            this.refundWithoutReceiverScript = hex.encode(refundWithoutReceiverScript);\n            this.unilateralClaimScript = hex.encode(unilateralClaimScript);\n            this.unilateralRefundScript = hex.encode(unilateralRefundScript);\n            this.unilateralRefundWithoutReceiverScript = hex.encode(\n                unilateralRefundWithoutReceiverScript,\n            );\n            if (nonInteractiveClaimScript) {\n                this.nonInteractiveClaimScript = hex.encode(nonInteractiveClaimScript);\n                this.nonInteractiveClaimArkadeScript = arkadeScriptNic;\n            }\n            if (nonInteractiveRefundScript) {\n                this.nonInteractiveRefundScript = hex.encode(nonInteractiveRefundScript);\n                this.nonInteractiveRefundArkadeScript = arkadeScriptNir;\n            }\n            if (nonInteractiveRefundWithoutReceiverScript) {\n                this.nonInteractiveRefundWithoutReceiverScript = hex.encode(\n                    nonInteractiveRefundWithoutReceiverScript,\n                );\n                this.nonInteractiveRefundWithoutReceiverArkadeScript = arkadeScriptNir;\n            }\n        }\n\n        /** Return the collaborative claim tapleaf script. */\n        claim(): TapLeafScript {\n            return this.findLeaf(this.claimScript);\n        }\n\n        /** Return the collaborative refund tapleaf script. */\n        refund(): TapLeafScript {\n            return this.findLeaf(this.refundScript);\n        }\n\n        /** Return the refund-without-receiver tapleaf script. */\n        refundWithoutReceiver(): TapLeafScript {\n            return this.findLeaf(this.refundWithoutReceiverScript);\n        }\n\n        /** Return the unilateral claim tapleaf script. */\n        unilateralClaim(): TapLeafScript {\n            return this.findLeaf(this.unilateralClaimScript);\n        }\n\n        /** Return the unilateral refund tapleaf script. */\n        unilateralRefund(): TapLeafScript {\n            return this.findLeaf(this.unilateralRefundScript);\n        }\n\n        /** Return the unilateral refund-without-receiver tapleaf script. */\n        unilateralRefundWithoutReceiver(): TapLeafScript {\n            return this.findLeaf(this.unilateralRefundWithoutReceiverScript);\n        }\n\n        /** Return the non-interactive claim tapleaf script as well as the ArkadeScript. */\n        nonInteractiveClaim(): [TapLeafScript, Bytes] {\n            if (!this.nonInteractiveClaimScript || !this.nonInteractiveClaimArkadeScript) {\n                throw new Error(\"VHTLC has no non-interactive claim leaf\");\n            }\n            return [\n                this.findLeaf(this.nonInteractiveClaimScript),\n                this.nonInteractiveClaimArkadeScript,\n            ];\n        }\n\n        /** Return the non-interactive refund tapleaf script as well as the ArkadeScript. */\n        nonInteractiveRefund(): [TapLeafScript, Bytes] {\n            if (!this.nonInteractiveRefundScript || !this.nonInteractiveRefundArkadeScript) {\n                throw new Error(\"VHTLC has no non-interactive refund leaf\");\n            }\n            return [\n                this.findLeaf(this.nonInteractiveRefundScript),\n                this.nonInteractiveRefundArkadeScript,\n            ];\n        }\n\n        /**\n         * Return the timelocked non-interactive refund tapleaf and its ArkadeScript.\n         *\n         * SPENDING THIS LEAF, CONCRETELY — confirmed from this SDK's own\n         * emulator client and covenant-spend builder ({@link\n         * EmulatorProvider} in `src/providers/emulator.ts`, and {@link\n         * ArkadeTransactionBuilder} in `src/arkade/contract.ts`), which is\n         * the general machinery every covenant leaf in this file goes\n         * through:\n         *\n         *  1. Build the ark tx spending this leaf (this method's {@link\n         *     TapLeafScript} as `tapLeafScript`, this script's {@link\n         *     VtxoScript.encode} as `tapTree`), plus its checkpoint tx.\n         *  2. Attach the ArkadeScript this method returns to the spent\n         *     input via an `EmulatorPacket` (type 1) — `{ vin, script:\n         *     <this ArkadeScript>, witness: <empty> }`, empty because the\n         *     script pushes its own input/output index with\n         *     `PUSHCURRENTINPUTINDEX` rather than reading one from the\n         *     witness — wrapped in an `Extension` OP_RETURN output on the\n         *     ark tx.\n         *  3. Attach the spent input's OWN creating ark tx as `PrevArkTx` on\n         *     input 0 — required so the emulator can resolve that input's\n         *     prevout pkScript/value; it does not otherwise have them.\n         *  4. POST the (base64-PSBT) ark tx and checkpoint(s) as `{ arkTx,\n         *     checkpointTxs }` to the emulator's `POST /v1/tx`.\n         *\n         * THE COVENANT CHECK the emulator runs against that ArkadeScript —\n         * `enforcePayTo(senderPkScript)`, see that function above — is: the\n         * output at this SAME input's index is a v1 P2TR output paying\n         * `senderPkScript`, with a value at least the input's. Only on that\n         * check passing does the emulator sign for `nirCosigner` (the\n         * `emulatorPubkey` tweaked by this ArkadeScript's hash); the\n         * response carries the fully co-signed `signedArkTx` and\n         * `signedCheckpointTxs` — `ArkadeTransactionBuilder.send()`'s own\n         * comment on this path: \"the emulator executes the arkade script\n         * and finalizes with arkd\" — no separate call to arkd is made by\n         * this SDK for a covenant spend.\n         * Neither `server` nor `receiver` play any part in that check: this\n         * leaf's tapscript still requires `server`'s own signature\n         * alongside `nirCosigner`'s (see the class doc above), but that is\n         * consensus-level multisig, not something the covenant enforces.\n         *\n         * NOT SPENDABLE UNTIL `refundLocktime` MATURES — the tapscript's\n         * `OP_CHECKLOCKTIMEVERIFY` is arkd's concern, not the emulator's;\n         * the emulator will happily co-sign an immature spend and arkd will\n         * then refuse it. A block-height-typed `refundLocktime` (below the\n         * standard height/timestamp boundary this SDK names\n         * `CLTV_HEIGHT_THRESHOLD`, 500,000,000, in\n         * `src/contracts/handlers/helpers.ts`) is refused by arkd for a\n         * forfeit-eligible leaf independent of maturity — use a\n         * seconds-typed (absolute Unix timestamp) value.\n         */\n        nonInteractiveRefundWithoutReceiver(): [TapLeafScript, Bytes] {\n            if (\n                !this.nonInteractiveRefundWithoutReceiverScript ||\n                !this.nonInteractiveRefundWithoutReceiverArkadeScript\n            ) {\n                throw new Error(\"VHTLC has no non-interactive refund-without-receiver leaf\");\n            }\n            return [\n                this.findLeaf(this.nonInteractiveRefundWithoutReceiverScript),\n                this.nonInteractiveRefundWithoutReceiverArkadeScript,\n            ];\n        }\n    }\n\n    /**\n     * Virtual Hash Time Lock Contract (VHTLC) script implementation.\n     *\n     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.\n     * It provides multiple spending paths:\n     *\n     * - **claim**: Receiver can claim funds by revealing the preimage\n     * - **refund**: Sender and receiver can collaboratively refund\n     * - **refundWithoutReceiver**: Sender can refund after locktime expires\n     * - **unilateralClaim**: Receiver can claim unilaterally after delay\n     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay\n     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay\n     * - **nonInteractiveClaim** (with `nonInteractiveParameters`): server + emulator\n     *   can push the receiver's claim, pinned to a pre-committed destination\n     * - **nonInteractiveRefund** (with `nonInteractiveParameters`): server + receiver\n     *   + emulator can push the sender's refund immediately, no timelock,\n     *   pinned to a pre-committed destination — recoverable even if the\n     *   sender's own key is lost\n     * - **nonInteractiveRefundWithoutReceiver** (with `nonInteractiveParameters`):\n     *   server + emulator can push the sender's refund after `refundLocktime`,\n     *   pinned to a pre-committed destination — the only refund tier needing\n     *   no participant signature at all\n     *\n     * See {@link ScriptV2} for the current recommended construction — same\n     * leaf ladder, same options shape, an added length check on the claim\n     * preimage. This class is unchanged and stays available as-is.\n     *\n     * **Pre-existing limitation: the `vhtlc` contract handler registers none\n     * of the covenant leaves.** `nonInteractiveParameters` builds on this class\n     * exactly as it does on {@link ScriptV2} — both extend the same\n     * `BaseScript` where those leaves are constructed. But the `vhtlc`\n     * contract handler (`src/contracts/handlers/vhtlc.ts`) round-trips none\n     * of them: its params type carries no covenant fields, and\n     * `createScript` only ever builds the six signature-only leaves. A V1\n     * script built with the covenant suite therefore compiles and can\n     * be funded, but cannot be registered as a `vhtlc` contract — the\n     * handler would derive a different (six-leaf) script for the same\n     * params and `ContractManager` refuses the mismatch. Register through\n     * the `vhtlc-v2` handler instead, which round-trips the suite.\n     *\n     * @example\n     * ```typescript\n     * const vhtlc = new VHTLC.Script({\n     *   sender: alicePubKey,\n     *   receiver: bobPubKey,\n     *   server: serverPubKey,\n     *   preimageHash: hash160(secret),\n     *   refundLocktime: BigInt(chainTip + 10),\n     *   unilateralClaimDelay: { type: 'blocks', value: 100n },\n     *   unilateralRefundDelay: { type: 'blocks', value: 102n },\n     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }\n     * });\n     * ```\n     */\n    export class Script extends BaseScript {\n        constructor(options: Options) {\n            super(options, preimageConditionScript);\n        }\n    }\n\n    /**\n     * Same leaf ladder as {@link Script}, built with {@link\n     * preimageConditionScriptV2} instead of {@link preimageConditionScript}\n     * for every leaf that gates on the preimage (`claim`, `unilateralClaim`,\n     * and, when present, `nonInteractiveClaim`) — see that function's doc\n     * comment for what differs and why. A distinct class rather than a flag\n     * on {@link Script}: the two produce different script bytes (and so\n     * different addresses) for the same participant keys, and keeping them\n     * as separate types makes that a compile-time-visible choice at every\n     * call site instead of a runtime option that's easy to get wrong.\n     */\n    export class ScriptV2 extends BaseScript {\n        constructor(options: Options) {\n            super(options, preimageConditionScriptV2);\n        }\n    }\n\n    function validateOptions(options: Options): void {\n        const {\n            sender,\n            receiver,\n            server,\n            preimageHash,\n            refundLocktime,\n            unilateralClaimDelay,\n            unilateralRefundDelay,\n            unilateralRefundWithoutReceiverDelay,\n        } = options;\n\n        if (!preimageHash || preimageHash.length !== 20) {\n            throw new Error(\"preimage hash must be 20 bytes\");\n        }\n        // The non-interactive leaves are the ONLY ones carrying a covenant\n        // — the signature leaves assert nothing about value — so they are the\n        // only place an asset can be bound. Accepting `asset` without the\n        // covenant suite would emit a sat-only contract and say nothing about\n        // it: the caller funds it believing the asset is protected, and any\n        // spend that satisfies the sat covenant walks off with the asset. The\n        // one outward difference is a pkScript matching a non-asset address,\n        // which is not something a caller thinks to check. Refuse instead of\n        // dropping it.\n        if (options.asset !== undefined && !options.nonInteractiveParameters) {\n            throw new Error(\"asset has no effect without nonInteractiveParameters\");\n        }\n\n        if (options.nonInteractiveParameters) {\n            const { emulatorPubkey, receiverPkScript, senderPkScript, legacy } =\n                options.nonInteractiveParameters;\n            if (!emulatorPubkey || (emulatorPubkey.length !== 32 && emulatorPubkey.length !== 33)) {\n                throw new Error(\"Invalid public key length (emulator)\");\n            }\n            if (!receiverPkScript || !isP2trPkScript(receiverPkScript)) {\n                throw new Error(\"Invalid P2TR script\");\n            }\n            if (!senderPkScript || !isP2trPkScript(senderPkScript)) {\n                throw new Error(\"Invalid P2TR script\");\n            }\n            // One literal is the whole point of the field (see its doc\n            // comment); anything else is a caller inventing a shape that does\n            // not exist, and TS types are no check at all from JS.\n            if (legacy !== undefined && legacy !== \"preTimelockedRefund\") {\n                throw new Error(\n                    `nonInteractiveParameters.legacy must be \"preTimelockedRefund\" when set, got ${JSON.stringify(legacy)}`,\n                );\n            }\n        }\n        if (!receiver || receiver.length !== 32) {\n            throw new Error(\"Invalid public key length (receiver)\");\n        }\n        if (!sender || sender.length !== 32) {\n            throw new Error(\"Invalid public key length (sender)\");\n        }\n        if (!server || server.length !== 32) {\n            throw new Error(\"Invalid public key length (server)\");\n        }\n        if (typeof refundLocktime !== \"bigint\" || refundLocktime <= 0n) {\n            throw new Error(\"refund locktime must be greater than 0\");\n        }\n        if (\n            !unilateralClaimDelay ||\n            typeof unilateralClaimDelay.value !== \"bigint\" ||\n            unilateralClaimDelay.value <= 0n\n        ) {\n            throw new Error(\"unilateral claim delay must greater than 0\");\n        }\n        if (unilateralClaimDelay.type === \"seconds\" && unilateralClaimDelay.value % 512n !== 0n) {\n            throw new Error(\"seconds timelock must be multiple of 512\");\n        }\n        if (unilateralClaimDelay.type === \"seconds\" && unilateralClaimDelay.value < 512n) {\n            throw new Error(\"seconds timelock must be greater or equal to 512\");\n        }\n        if (\n            !unilateralRefundDelay ||\n            typeof unilateralRefundDelay.value !== \"bigint\" ||\n            unilateralRefundDelay.value <= 0n\n        ) {\n            throw new Error(\"unilateral refund delay must greater than 0\");\n        }\n        if (unilateralRefundDelay.type === \"seconds\" && unilateralRefundDelay.value % 512n !== 0n) {\n            throw new Error(\"seconds timelock must be multiple of 512\");\n        }\n        if (unilateralRefundDelay.type === \"seconds\" && unilateralRefundDelay.value < 512n) {\n            throw new Error(\"seconds timelock must be greater or equal to 512\");\n        }\n        if (\n            !unilateralRefundWithoutReceiverDelay ||\n            typeof unilateralRefundWithoutReceiverDelay.value !== \"bigint\" ||\n            unilateralRefundWithoutReceiverDelay.value <= 0n\n        ) {\n            throw new Error(\"unilateral refund without receiver delay must greater than 0\");\n        }\n        if (\n            unilateralRefundWithoutReceiverDelay.type === \"seconds\" &&\n            unilateralRefundWithoutReceiverDelay.value % 512n !== 0n\n        ) {\n            throw new Error(\"seconds timelock must be multiple of 512\");\n        }\n        if (\n            unilateralRefundWithoutReceiverDelay.type === \"seconds\" &&\n            unilateralRefundWithoutReceiverDelay.value < 512n\n        ) {\n            throw new Error(\"seconds timelock must be greater or equal to 512\");\n        }\n    }\n}\n\nfunction preimageConditionScript(preimageHash: Bytes): Bytes {\n    return Script.encode([\"HASH160\", preimageHash, \"EQUAL\"]);\n}\n\n/**\n * Same as {@link preimageConditionScript}, plus an explicit length check on\n * the witness item before it's hashed: `OP_SIZE 32 OP_EQUALVERIFY` ahead of\n * the `OP_HASH160` check, the same prefix real-world HTLC scripts (e.g.\n * BOLT3's) carry for the same reason — the claim leaf otherwise accepts any\n * witness value whose HASH160 matches, regardless of length, and this\n * contract's preimage is always exactly 32 bytes by construction. Used by\n * {@link VHTLC.ScriptV2} for every leaf gated on the preimage.\n */\nfunction preimageConditionScriptV2(preimageHash: Bytes): Bytes {\n    return Script.encode([\"SIZE\", 32, \"EQUALVERIFY\", \"HASH160\", preimageHash, \"EQUAL\"]);\n}\n\n/**\n * A v1 P2TR pkScript is exactly `OP_1 <32-byte-program>` (0x51 0x20 ...) — 34\n * bytes total. Length alone isn't enough: any other 34-byte value (e.g.\n * {@link ArkAddress.subdustPkScript}'s `OP_RETURN <32 bytes>`, or a P2WSH\n * script) has the same length but a different witness version, and\n * `enforcePayTo` below trusts byte 2 onward as the taproot program\n * unconditionally.\n */\nfunction isP2trPkScript(pkScript: Bytes): boolean {\n    return pkScript.length === 34 && pkScript[0] === 0x51 && pkScript[1] === 0x20;\n}\n\n/**\n * The covenant: \"this input's output pays the given P2TR script, value >=\n * input\". Shared by every leaf {@link VHTLC.Options.nonInteractiveParameters}\n * builds — only the destination and the tier it gates differ.\n *\n * `PUSHCURRENTINPUTINDEX` as the output index is not an assumption about how\n * the Ark round pairs inputs with outputs — the covenant imposes the pairing\n * on the spender. Whatever index a spending tx places this input at, the\n * output at that same index must pay the destination at least the input's\n * value, or the ArkadeScript fails and the server never co-signs. A tx with no\n * output at that index fails the same way: the leaf is unsatisfiable, not\n * fooled. Index alignment is therefore a *liveness* obligation on whoever\n * assembles the spend (the solver, for both leaves — this SDK never builds\n * them; its own aggregate refund uses the interactive leaf precisely because\n * it lacks this per-index constraint, see `refund.ts`), never a safety\n * assumption.\n *\n * WHY `>= input` AND NOT `>= the quoted amount`. This bound is CONSERVATION,\n * not agreement: it says the spend may not skim, and says nothing about what\n * any quote promised. That is deliberate, on both leaves, and it is a question\n * worth answering here because the covenant reads like the natural place to\n * pin a quote and is not.\n *\n *  - A QUOTE IS NOT THE COVENANT'S TO KNOW. Pinning one compiles it into the\n *    leaf, hence into the emulator key, hence into the ADDRESS. Re-quoting\n *    would move the address of a contract that may already be funded.\n *  - MISFUNDING IS THE SENDER'S EXPOSURE. They chose the amount. A lockup that\n *    over- or underpays the quote is theirs to have created, and the\n *    counterparty's protection is to decline it — refuse the swap and let it\n *    refund — which is an application-layer decision, taken where a quote\n *    actually lives, and revisable without moving anyone's address.\n *  - NOTHING IS CLAIMED WITHOUT THE PREIMAGE. Both covenant leaves sit behind\n *    the hash condition, so an underfunded lockup cannot be claimed out from\n *    under the counterparty on the covenant's say-so. The covenant's job is to\n *    stop a spend that satisfies the condition from redirecting the value; it\n *    is not to adjudicate whether the trade was fair.\n *\n * So a funding gate that compares a lockup against its quote belongs in the\n * consumer, not here. `lightning-swap-service`'s `lockupIsFunded` is that gate.\n */\n/**\n * The sat half of both covenants: the output at this input's index is P2TR,\n * pays `destinationPkScript`, and carries at least the input's value.\n *\n * ONE COPY, shared by {@link enforcePayTo} and {@link enforcePayToAsset}. The\n * asset covenant used to restate these tokens inline under a comment promising\n * they matched \"byte-for-byte\" — a promise nothing enforced, and one that an\n * option added to one and forgotten on the other would have broken silently.\n */\nfunction satClause(destinationPkScript: Bytes): ArkadeScriptType {\n    return [\n        \"PUSHCURRENTINPUTINDEX\",\n        \"DUP\",\n        \"INSPECTOUTPUTSCRIPTPUBKEY\",\n        1,\n        \"EQUALVERIFY\",\n        destinationPkScript.subarray(2),\n        \"EQUALVERIFY\",\n        \"INSPECTOUTPUTVALUE\",\n        \"PUSHCURRENTINPUTINDEX\",\n        \"INSPECTINPUTVALUE\",\n        \"GREATERTHANOREQUAL\",\n    ];\n}\n\nfunction enforcePayTo(destinationPkScript: Bytes): Bytes {\n    // validateOptions already checked this for both current call sites — kept\n    // here too, since this covenant is the one place a wrong destination\n    // becomes irreversible (a mis-typed leaf, unlike a rejected constructor\n    // call, only surfaces once someone tries to spend it).\n    if (!isP2trPkScript(destinationPkScript)) {\n        throw new Error(\"invalid P2TR script\");\n    }\n    return ArkadeScript.encode(satClause(destinationPkScript));\n}\n\n/**\n * {@link enforcePayTo} for a contract denominated in an Arkade ASSET: the same\n * covenant, plus \"carries at least the input's amount of exactly this one\n * asset\".\n *\n * The sat covenant is this one's TAIL, restated inline below, so an asset\n * contract enforces everything a sat contract does and never less.  That\n * matters because an asset-carrying VTXO carries sats too: a covenant\n * constraining only the asset would let a spend strip the sats, and the\n * sat-only covenant lets a spend strip the ASSET -- the loss this exists to\n * prevent.\n *\n * Two opcode details decide whether it is safe, and the intuitive reading gets\n * both wrong:\n *\n *  - A canonical Asset ID is TWO stack items, `asset_txid` then `asset_gidx`.\n *    Pushing it as one 32-byte blob encodes cleanly and fails only at spend\n *    time, once the contract is already funded.\n *  - `INSPECTOUTASSETLOOKUP` pushes `amount 1`, or `0 0` when the asset is\n *    ABSENT.  The `VERIFY` after each lookup pops that success flag and is\n *    load-bearing, not defensive: without it an output carrying NONE of the\n *    asset reports amount 0, `0 >= 0` passes, and the stripping spend succeeds\n *    anyway.  Applied to the input lookup too, so an input whose asset is\n *    undeclared cannot compare `0 >= 0` either.\n *\n * `INSPECTOUTASSETCOUNT == 1` bounds the output to the single asset bound, so\n * nothing can be injected alongside it.  Deliberately strict: a covenant that\n * is too permissive cannot be tightened once funds are locked to it, while a\n * strict one can be relaxed in a later contract version.\n */\nfunction enforcePayToAsset(\n    destinationPkScript: Bytes,\n    asset: { txid: Bytes; groupIndex: number },\n): Bytes {\n    if (!isP2trPkScript(destinationPkScript)) {\n        throw new Error(\"invalid P2TR script\");\n    }\n    if (asset.txid.length !== 32) {\n        throw new Error(`asset txid must be 32 bytes, got ${asset.txid.length}`);\n    }\n    if (!Number.isInteger(asset.groupIndex) || asset.groupIndex < 0 || asset.groupIndex > 0xffff) {\n        throw new Error(\n            `asset group index must be an integer in [0, 65535], got ${asset.groupIndex}`,\n        );\n    }\n    // REVERSED, once, here. `asset.txid` is the id in CANONICAL order -- the\n    // leading 32 bytes of the serialized Asset ID, which arkd's `serializeTxHash`\n    // already reversed \"to match the canonical txid format\". The introspection\n    // opcodes match against WIRE order, which is those bytes reversed back. Push\n    // the canonical bytes unflipped and the lookup reports the asset ABSENT\n    // (`0 0`), so the covenant fails and the contract it guards is unspendable. Nothing in the failure says so: the emulator returns only\n    // `OP_VERIFY failed`, and returns it whatever the amount comparison says.\n    // Established on regtest against a real minted asset, by elimination against\n    // a passing BTC-only control.\n    //\n    // A copy rather than an in-place reverse: the caller's id is theirs.\n    const inspectionTxid = Uint8Array.from(asset.txid).reverse();\n    return ArkadeScript.encode([\n        // The output carries at least as much of the asset as the input did.\n        // Output index is the input's -- the same index alignment the sat\n        // covenant relies on, and the same liveness obligation on whoever\n        // assembles the spend.\n        \"PUSHCURRENTINPUTINDEX\",\n        inspectionTxid,\n        asset.groupIndex,\n        \"INSPECTOUTASSETLOOKUP\",\n        \"VERIFY\", // PRESENT on the output, not merely \"zero of it\"\n        \"PUSHCURRENTINPUTINDEX\",\n        inspectionTxid,\n        asset.groupIndex,\n        \"INSPECTINASSETLOOKUP\",\n        \"VERIFY\", // ...and on the input, so the comparison means something\n        \"GREATERTHANOREQUAL\",\n        \"VERIFY\",\n        // Exactly one asset out: nothing injected alongside the one bound.\n        \"PUSHCURRENTINPUTINDEX\",\n        \"INSPECTOUTASSETCOUNT\",\n        1,\n        \"EQUALVERIFY\",\n        // ...then the sat covenant, the same tokens `enforcePayTo` emits.\n        ...satClause(destinationPkScript),\n    ]);\n}\n\n/** Pick the covenant this contract's denomination calls for. */\nfunction enforcePayToMaybeAsset(\n    destinationPkScript: Bytes,\n    asset: { txid: Bytes; groupIndex: number } | undefined,\n): Bytes {\n    return asset === undefined\n        ? enforcePayTo(destinationPkScript)\n        : enforcePayToAsset(destinationPkScript, asset);\n}\n","import { hex } from \"@scure/base\";\nimport { VHTLC } from \"../../script/vhtlc\";\nimport { RelativeTimelock } from \"../../script/tapscript\";\nimport {\n    Contract,\n    ContractHandler,\n    DerivedContractTapscripts,\n    PathContext,\n    PathSelection,\n    TapscriptDeriving,\n} from \"../types\";\nimport { assertVhtlcSpendableNow, isCltvSatisfied, isCsvSpendable, resolveRole } from \"./helpers\";\nimport { sequenceToTimelock, timelockToSequence } from \"../../utils/timelock\";\n\n/**\n * Typed parameters for VHTLC contracts.\n */\nexport interface VHTLCContractParams {\n    sender: Uint8Array;\n    receiver: Uint8Array;\n    server: Uint8Array;\n    preimageHash: Uint8Array;\n    refundLocktime: bigint;\n    unilateralClaimDelay: RelativeTimelock;\n    unilateralRefundDelay: RelativeTimelock;\n    unilateralRefundWithoutReceiverDelay: RelativeTimelock;\n}\n\n/**\n * Handler for Virtual Hash Time Lock Contract (VHTLC).\n *\n * VHTLC supports multiple spending paths:\n *\n * Collaborative paths (with server):\n * - claim: Receiver + Server with preimage\n * - refund: Sender + Receiver + Server\n * - refundWithoutReceiver: Sender + Server after CLTV locktime\n *\n * Unilateral paths (without server):\n * - unilateralClaim: Receiver with preimage after CSV delay\n * - unilateralRefund: Sender + Receiver after CSV delay\n * - unilateralRefundWithoutReceiver: Sender after CSV delay\n */\nexport const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script> &\n    TapscriptDeriving<VHTLC.Script> = {\n    type: \"vhtlc\",\n\n    createScript(params: Record<string, string>): VHTLC.Script {\n        const typed = this.deserializeParams(params);\n        return new VHTLC.Script(typed);\n    },\n\n    serializeParams(params: VHTLCContractParams): Record<string, string> {\n        return {\n            sender: hex.encode(params.sender),\n            receiver: hex.encode(params.receiver),\n            server: hex.encode(params.server),\n            hash: hex.encode(params.preimageHash),\n            refundLocktime: params.refundLocktime.toString(),\n            claimDelay: timelockToSequence(params.unilateralClaimDelay).toString(),\n            refundDelay: timelockToSequence(params.unilateralRefundDelay).toString(),\n            refundNoReceiverDelay: timelockToSequence(\n                params.unilateralRefundWithoutReceiverDelay,\n            ).toString(),\n        };\n    },\n\n    deserializeParams(params: Record<string, string>): VHTLCContractParams {\n        return {\n            sender: hex.decode(params.sender),\n            receiver: hex.decode(params.receiver),\n            server: hex.decode(params.server),\n            preimageHash: hex.decode(params.hash),\n            refundLocktime: BigInt(params.refundLocktime),\n            unilateralClaimDelay: sequenceToTimelock(Number(params.claimDelay)),\n            unilateralRefundDelay: sequenceToTimelock(Number(params.refundDelay)),\n            unilateralRefundWithoutReceiverDelay: sequenceToTimelock(\n                Number(params.refundNoReceiverDelay),\n            ),\n        };\n    },\n\n    /**\n     * Select spending path based on context.\n     *\n     * Role is determined from `context.role` or by matching\n     * `context.walletDescriptor` (preferred) / `context.walletPubKey`\n     * against sender/receiver in contract params.\n     */\n    selectPath(\n        script: VHTLC.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection | null {\n        const role = resolveRole(contract, context);\n        const preimage = contract.params?.preimage;\n        const refundLocktime = BigInt(contract.params.refundLocktime);\n\n        if (!role) {\n            return null;\n        }\n\n        if (context.collaborative) {\n            if (role === \"receiver\" && preimage) {\n                return {\n                    leaf: script.claim(),\n                    extraWitness: [hex.decode(preimage)],\n                };\n            }\n\n            if (role === \"sender\" && isCltvSatisfied(context, refundLocktime)) {\n                return {\n                    leaf: script.refundWithoutReceiver(),\n                };\n            }\n\n            return null;\n        }\n\n        // Unilateral paths\n        if (role === \"receiver\" && preimage) {\n            const sequence = Number(contract.params.claimDelay);\n            if (!isCsvSpendable(context, sequence)) return null;\n            return {\n                leaf: script.unilateralClaim(),\n                extraWitness: [hex.decode(preimage)],\n                sequence,\n            };\n        }\n\n        if (role === \"sender\") {\n            const sequence = Number(contract.params.refundNoReceiverDelay);\n            if (!isCsvSpendable(context, sequence)) return null;\n            return {\n                leaf: script.unilateralRefundWithoutReceiver(),\n                sequence,\n            };\n        }\n\n        return null;\n    },\n\n    /**\n     * Get all possible spending paths (no timelock checks).\n     *\n     * Role is determined from `context.role` or by matching\n     * `context.walletDescriptor` (preferred) / `context.walletPubKey`\n     * against sender/receiver in contract params.\n     */\n    getAllSpendingPaths(\n        script: VHTLC.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        const role = resolveRole(contract, context);\n        const paths: PathSelection[] = [];\n\n        if (!role) {\n            return paths;\n        }\n\n        const preimage = contract.params?.preimage;\n\n        if (context.collaborative) {\n            // Collaborative paths (no timelock checks)\n            if (role === \"receiver\" && preimage) {\n                paths.push({\n                    leaf: script.claim(),\n                    extraWitness: [hex.decode(preimage)],\n                });\n            }\n            if (role === \"sender\") {\n                paths.push({\n                    leaf: script.refundWithoutReceiver(),\n                });\n            }\n        } else {\n            // Unilateral paths (no timelock checks)\n            if (role === \"receiver\" && preimage) {\n                const sequence = Number(contract.params.claimDelay);\n                paths.push({\n                    leaf: script.unilateralClaim(),\n                    extraWitness: [hex.decode(preimage)],\n                    sequence,\n                });\n            }\n            if (role === \"sender\") {\n                const sequence = Number(contract.params.refundNoReceiverDelay);\n                paths.push({\n                    leaf: script.unilateralRefundWithoutReceiver(),\n                    sequence,\n                });\n            }\n        }\n\n        return paths;\n    },\n\n    getSpendablePaths(\n        script: VHTLC.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        const role = resolveRole(contract, context);\n        const paths: PathSelection[] = [];\n\n        if (!role) {\n            return paths;\n        }\n\n        const preimage = contract.params?.preimage;\n        const refundLocktime = BigInt(contract.params.refundLocktime);\n\n        if (context.collaborative) {\n            if (role === \"receiver\" && preimage) {\n                paths.push({\n                    leaf: script.claim(),\n                    extraWitness: [hex.decode(preimage)],\n                });\n            }\n            if (role === \"sender\" && isCltvSatisfied(context, refundLocktime)) {\n                paths.push({\n                    leaf: script.refundWithoutReceiver(),\n                });\n            }\n            return paths;\n        }\n\n        if (role === \"receiver\" && preimage) {\n            const sequence = Number(contract.params.claimDelay);\n            if (isCsvSpendable(context, sequence)) {\n                paths.push({\n                    leaf: script.unilateralClaim(),\n                    extraWitness: [hex.decode(preimage)],\n                    sequence,\n                });\n            }\n        }\n        if (role === \"sender\") {\n            const sequence = Number(contract.params.refundNoReceiverDelay);\n            if (isCsvSpendable(context, sequence)) {\n                paths.push({\n                    leaf: script.unilateralRefundWithoutReceiver(),\n                    sequence,\n                });\n            }\n        }\n\n        return paths;\n    },\n\n    /**\n     * Refuse an explicit spend of a lockup whose refund path has not opened.\n     * Shared with the v2 handler so the two cannot drift.\n     * @see assertVhtlcSpendableNow for why this is the one certain case.\n     */\n    assertSpendableNow(_script: VHTLC.Script, contract: Contract, context: PathContext): void {\n        assertVhtlcSpendableNow(contract, context);\n    },\n\n    /**\n     * Never. A live VHTLC is escrow: the counterparty's claim leaf is armed,\n     * and generic selection — send, settle, renewal, offboard — would move the\n     * lockup out from under a swap the counterparty is still entitled to\n     * complete, or race a claim already in flight.\n     *\n     * Two narrow reasons, and neither is \"spending this would destroy the\n     * VTXO\". It would not: the leaf {@link deriveTapscripts} stamps is\n     * `refundWithoutReceiver` — `CLTV[sender, server]`, the sender's OWN\n     * refund, which the server rejects until `refundLocktime` matures. The\n     * reasons are that an escrowed lockup must not count toward the\n     * `available` balance bucket, and that generic RENEWAL must not silently\n     * execute a refund the caller never asked for — `runPeriodicSettle` selects\n     * through `getSpendableVtxos`, which this gate filters, and it runs\n     * unprompted whenever a wallet is built without an explicit\n     * `settlementConfig`.\n     *\n     * **Inseparable from {@link deriveTapscripts}.** Deriving the leaf without\n     * closing the gate hands generic renewal an escrow it had never been\n     * offered before; before that method existed the answer here was\n     * unobservable, so the two only ever made sense together.\n     *\n     * Recovery is filtered on {@link assertSpendableNow}, not on this: the gate\n     * is permanent, and applying it there would strand a matured lockup.\n     */\n    isGenericallySpendable: () => false,\n\n    /**\n     * The annotation leaf stamped onto every VTXO locked to this contract.\n     *\n     * **Without this the contract is unusable, not merely unoptimized.**\n     * `deriveContractTapscripts` falls back to `script.forfeit()` for any\n     * handler that does not implement {@link TapscriptDeriving}, and no VHTLC\n     * script version has a `forfeit()` — `VtxoScript` does not define one and\n     * `VHTLC.BaseScript` does not add one. The fallback therefore threw\n     * `legacy.forfeit is not a function`, `annotatableIn` caught it, and\n     * `fetchContractVtxosBulk` dropped this contract's VTXOs before they were\n     * persisted. The row existed and was watched while its balance stayed\n     * permanently invisible, and `getSyncState()` reported `degraded` forever.\n     *\n     * `refundWithoutReceiver` is the leaf, for both roles the annotation\n     * serves, because it is the only collaborative path this wallet can\n     * actually satisfy as the sender — the same conclusion `selectPath`\n     * reaches, kept in step with it deliberately. The claim leaves belong to\n     * the receiver and need a preimage the sender does not have; `refund` and\n     * `unilateralRefund` both need the counterparty's signature, which this\n     * protocol has no message to ask for. V1 has no covenant leaves at all.\n     *\n     * **It carries a CLTV, and callers must respect it.** A settlement built\n     * on this leaf is only valid once `refundLocktime` has matured, so a\n     * recovery round that sweeps this VTXO early is rejected by the server.\n     * Nothing in this handler can enforce that, because the annotation is\n     * derived per contract and knows no clock; `recoverVtxos` filters on\n     * {@link assertSpendableNow} for it.\n     *\n     * **Role-blind.** A receiver's row gets the same leaf, which names keys that\n     * wallet does not hold, so it is satisfiable only by the wallet holding the\n     * lockup's `sender` key and fails at intent registration for anyone else.\n     */\n    deriveTapscripts(script: VHTLC.Script): DerivedContractTapscripts {\n        const leaf = script.refundWithoutReceiver();\n        return {\n            forfeitTapLeafScript: leaf,\n            intentTapLeafScript: leaf,\n            tapTree: script.encode(),\n        };\n    },\n};\n","import { hex } from \"@scure/base\";\nimport { VHTLC } from \"../../script/vhtlc\";\nimport { RelativeTimelock } from \"../../script/tapscript\";\nimport {\n    Contract,\n    ContractHandler,\n    DerivedContractTapscripts,\n    PathContext,\n    PathSelection,\n    TapscriptDeriving,\n} from \"../types\";\nimport { assertVhtlcSpendableNow, isCltvSatisfied, isCsvSpendable, resolveRole } from \"./helpers\";\nimport { sequenceToTimelock, timelockToSequence } from \"../../utils/timelock\";\n\n/**\n * The stored `assetGroupIndex`, as a number, or a throw naming the row.\n *\n * `Number()` alone is not enough here, and it fails in exactly one direction\n * that matters. `VHTLC.ScriptV2` already refuses a non-integer, a negative or\n * anything past `0xffff`, so `\"abc\"`, `\"1.5\"` and `\"-1\"` die one frame down with\n * a clear message. What survives is `Number(\"\")`, `Number(\" \")` and\n * `Number(\"\\t\")` — all of which are **0**, a perfectly valid group index.\n *\n * A blank field therefore does not fail: it silently names group 0 of the same\n * genesis transaction, which is a DIFFERENT asset. The contract then derives a\n * different script from the one the row was written against, and registration\n * dies at `upsertContractRow` with an opaque `Script mismatch` — the same\n * silent-drop class the both-halves-or-neither check above exists to close, one\n * value further in.\n *\n * Anchored and canonical: no sign, no point, no exponent, no leading zero, so a\n * row that round-tripped through this handler's own `serializeParams` is the\n * only shape accepted back.\n */\nconst parseGroupIndex = (raw: string): number => {\n    if (!/^(0|[1-9][0-9]*)$/.test(raw)) {\n        throw new Error(\n            `assetGroupIndex must be a canonical decimal integer, got ${JSON.stringify(raw)}`,\n        );\n    }\n    return Number(raw);\n};\n\n/**\n * Typed parameters for {@link VHTLC.ScriptV2} contracts.\n *\n * The eight mandatory fields are `VHTLCContractParams` verbatim — the two\n * script versions take the same {@link VHTLC.Options}, so a divergent shape\n * here would be a difference with no cause. What V1's handler has no field for\n * is the emulator covenant suite, and that is exactly what the swap corridor's\n * lockup carries, so leaving it out would make this handler unable to\n * round-trip the contract it exists to serve.\n */\nexport interface VHTLCV2ContractParams {\n    sender: Uint8Array;\n    receiver: Uint8Array;\n    server: Uint8Array;\n    preimageHash: Uint8Array;\n    refundLocktime: bigint;\n    unilateralClaimDelay: RelativeTimelock;\n    unilateralRefundDelay: RelativeTimelock;\n    unilateralRefundWithoutReceiverDelay: RelativeTimelock;\n    /**\n     * The Arkade asset the covenant leaves bind, if any.\n     *\n     * @see VHTLC.Options.asset\n     */\n    asset?: {\n        /** The asset's genesis txid, 32 bytes, canonical order — as the serialized Asset ID carries it. */\n        txid: Uint8Array;\n        /** The asset group index within that genesis transaction. */\n        groupIndex: number;\n    };\n    /**\n     * The emulator covenant suite, all or nothing — mirrors {@link\n     * VHTLC.Options.nonInteractiveParameters} exactly, including the legacy selector:\n     * a row funded before the timelocked refund leaf shipped round-trips with\n     * `legacy: \"preTimelockedRefund\"` and re-derives its eight-leaf shape.\n     */\n    nonInteractiveParameters?: {\n        receiverPkScript: Uint8Array;\n        emulatorPubkey: Uint8Array;\n        senderPkScript: Uint8Array;\n        /** @see VHTLC.Options.nonInteractiveParameters.legacy */\n        legacy?: \"preTimelockedRefund\";\n    };\n}\n\n/**\n * Both halves of an optional covenant leaf, or neither.\n *\n * A row carrying one half of the pair would derive a script with that leaf\n * DROPPED — a different taproot tree, a different pkScript, and so a\n * `Script mismatch` from `upsertContractRow` naming two hex strings and no\n * cause. Rejecting the half-specified pair here names it instead. It is a\n * diagnostic, not a safety boundary: the mismatch check is what actually stops\n * a wrong script from being persisted, and it stops this case too.\n */\nfunction decodeCovenantLeaf<K extends string>(\n    params: Record<string, string>,\n    destinationKey: K,\n    emulatorKey: string,\n    label: string,\n): { destination: Uint8Array; emulatorPubkey: Uint8Array } | undefined {\n    const destination = params[destinationKey];\n    const emulator = params[emulatorKey];\n    if (!destination && !emulator) return undefined;\n    if (!destination || !emulator) {\n        throw new Error(`${label} needs both '${destinationKey}' and '${emulatorKey}', or neither`);\n    }\n    return { destination: hex.decode(destination), emulatorPubkey: hex.decode(emulator) };\n}\n\n/**\n * Handler for {@link VHTLC.ScriptV2} — the VHTLC whose preimage leaves carry an\n * explicit `OP_SIZE 32 OP_EQUALVERIFY` before the hash check, and which the RFQ\n * swap corridor builds (`@arkade-os/swap`'s `lightningSendVtxoScript`).\n *\n * **Why a separate type string rather than a flag on `vhtlc`.** A handler's\n * `type` names the script class it derives, the way every other registered type\n * does (`default` → `DefaultVtxo.Script`, `vhtlc` → `VHTLC.Script`, `boarding`,\n * `arkade`). V1 and V2 produce different script bytes — and so different\n * pkScripts — for identical participant keys, and `upsertContractRow` derives\n * the script from `params` and refuses any row whose supplied `script` does not\n * match. One type cannot serve both. `vhtlc-v2` also cannot COLLIDE with\n * `vhtlc`: a colliding row needs one pkScript claimed by two types, and the two\n * versions' preimage conditions differ in every tree, so no parameters make\n * them equal. A use-named type (`swap-lockup`) was the alternative and is\n * worse: contracts are keyed by script, so the moment a second use registered\n * the same ScriptV2 the two uses would fight over one row.\n *\n * **Which leaves this offers, and why the set is smaller than the ladder.**\n * ScriptV2 has nine leaves; a wallet holding ONE of the two participant keys\n * can satisfy four of them, and offering a leaf whose signature the caller\n * cannot produce is worse than offering fewer — it turns a refusal into a\n * transaction that gets built and then rejected.\n *\n * | leaf                                  | needs                          | offered |\n * |---------------------------------------|--------------------------------|---------|\n * | `claim`                               | receiver + server, preimage    | yes, to the receiver |\n * | `refund`                              | sender + receiver + server     | no — needs the counterparty live |\n * | `refundWithoutReceiver`               | sender + server, CLTV          | yes, to the sender |\n * | `unilateralClaim`                     | receiver, CSV                  | yes, to the receiver |\n * | `unilateralRefund`                    | sender + receiver, CSV         | no — needs the counterparty live |\n * | `unilateralRefundWithoutReceiver`     | sender, CSV                    | yes, to the sender |\n * | `nonInteractiveClaim`                 | server + emulator              | no — the wallet holds neither key |\n * | `nonInteractiveRefund`                | server + receiver + emulator   | no — the wallet holds neither key |\n * | `nonInteractiveRefundWithoutReceiver` | server + emulator, CLTV        | no — the wallet holds neither key |\n *\n * The two omitted interactive leaves are the same two the `vhtlc` handler\n * omits, for the same reason: `refund` and `unilateralRefund` both need the\n * OTHER party's signature, and this protocol has no message that asks for one\n * (see `@arkade-os/swap`'s `refund.ts` module doc). The two covenant leaves are\n * pushed by the emulator on the counterparty's behalf and are not this wallet's\n * to build at all.\n *\n * So `refundWithoutReceiver` is the sender's only collaborative way out, gated\n * on the CLTV the quote committed to — which is exactly the leaf\n * `pushRefundWithoutReceiver` builds. The CSV leaves are offered only in the\n * non-collaborative context, where the caller has already accepted that\n * spending them means a real unilateral exit first.\n *\n * The selection discipline is deliberately identical to the `vhtlc` handler's,\n * and `test/contracts/vhtlcV2-handler.test.ts` pins the two against each other\n * rung-for-rung across every role and timelock context so they cannot drift.\n */\nexport const VHTLCV2ContractHandler: ContractHandler<VHTLCV2ContractParams, VHTLC.ScriptV2> &\n    TapscriptDeriving<VHTLC.ScriptV2> = {\n    type: \"vhtlc-v2\",\n\n    createScript(params: Record<string, string>): VHTLC.ScriptV2 {\n        const typed = this.deserializeParams(params);\n        return new VHTLC.ScriptV2(typed);\n    },\n\n    serializeParams(params: VHTLCV2ContractParams): Record<string, string> {\n        const covenants = params.nonInteractiveParameters;\n        return {\n            sender: hex.encode(params.sender),\n            receiver: hex.encode(params.receiver),\n            server: hex.encode(params.server),\n            hash: hex.encode(params.preimageHash),\n            refundLocktime: params.refundLocktime.toString(),\n            claimDelay: timelockToSequence(params.unilateralClaimDelay).toString(),\n            refundDelay: timelockToSequence(params.unilateralRefundDelay).toString(),\n            refundNoReceiverDelay: timelockToSequence(\n                params.unilateralRefundWithoutReceiverDelay,\n            ).toString(),\n            // The on-disk keys keep their per-leaf names even though the typed\n            // param is ONE group: rows written by older SDKs carry exactly\n            // these keys, and changing the storage encoding would orphan them.\n            // The group maps onto them without loss — one emulator key serves\n            // both covenant destinations by construction (see the option's doc\n            // on VHTLC.Options), so the two emulator-key columns always hold\n            // the same value on a row written from here.\n            //\n            // Spread rather than written as `undefined`: a `Record<string,\n            // string>` round-tripped through a repository must not gain keys\n            // whose value is the string \"undefined\".\n            ...(covenants && {\n                nonInteractiveClaimReceiverPkScript: hex.encode(covenants.receiverPkScript),\n                nonInteractiveClaimEmulatorPubkey: hex.encode(covenants.emulatorPubkey),\n                nonInteractiveRefundSenderPkScript: hex.encode(covenants.senderPkScript),\n                nonInteractiveRefundEmulatorPubkey: hex.encode(covenants.emulatorPubkey),\n                // The legacy marker is precisely the ABSENCE of this key: a\n                // row carrying it re-derives the full suite (nine leaves), a\n                // row lacking it the pre-timelocked-refund eight — the same\n                // encoding older SDKs wrote for eight-leaf rows, so those rows\n                // read back unchanged. Spread rather than a \"false\"/\"undefined\"\n                // string: a dropped flag re-derives the EIGHT-leaf script, a\n                // different pkScript, and registration dies at\n                // `upsertContractRow` with an opaque `Script mismatch`.\n                ...(covenants.legacy === undefined && {\n                    nonInteractiveRefundWithoutReceiver: \"1\",\n                }),\n            }),\n            // The asset must round-trip, and its absence here used to be silent\n            // in the worst way. `ContractManager` re-derives a contract from\n            // these params; dropping the asset derives the SAT-ONLY script, so\n            // registration died at `upsertContractRow` with a `Script mismatch`\n            // naming two hex strings and no cause. Same silent-drop class\n            // `validateOptions` refuses one layer up.\n            //\n            // Two keys rather than one blob, mirroring the script's own view of\n            // an Asset ID as a (txid, groupIndex) pair.\n            ...(params.asset && {\n                assetTxid: hex.encode(params.asset.txid),\n                assetGroupIndex: params.asset.groupIndex.toString(),\n            }),\n        };\n    },\n\n    deserializeParams(params: Record<string, string>): VHTLCV2ContractParams {\n        const claim = decodeCovenantLeaf(\n            params,\n            \"nonInteractiveClaimReceiverPkScript\",\n            \"nonInteractiveClaimEmulatorPubkey\",\n            \"nonInteractiveClaim\",\n        );\n        const refund = decodeCovenantLeaf(\n            params,\n            \"nonInteractiveRefundSenderPkScript\",\n            \"nonInteractiveRefundEmulatorPubkey\",\n            \"nonInteractiveRefund\",\n        );\n        // The covenant suite is all-or-nothing in the typed params, but the\n        // on-disk keys predate that: a row written by an older SDK could name\n        // one leaf's pair without the other's. Such a row has no group\n        // representation — building one would mean inventing the missing\n        // half — so refuse it by name rather than drop a leaf silently.\n        if ((claim === undefined) !== (refund === undefined)) {\n            throw new Error(\n                \"emulator covenant params are all-or-nothing: the claim keys \" +\n                    \"(nonInteractiveClaim*) and the refund keys (nonInteractiveRefund*) must \" +\n                    \"both be present or both absent — a row carrying one side was written \" +\n                    \"for a leaf subset this handler no longer derives\",\n            );\n        }\n        // Both pairs decoded. One emulator key serves both destinations in the\n        // group; a row naming two DIFFERENT keys was legal for an older SDK\n        // and is unrepresentable now. Rebuilding with either one would move\n        // the pkScript, so name it instead.\n        if (\n            claim &&\n            refund &&\n            hex.encode(claim.emulatorPubkey) !== hex.encode(refund.emulatorPubkey)\n        ) {\n            throw new Error(\n                \"emulator covenant params name two different emulator pubkeys: the suite \" +\n                    \"derives both covenant cosigners from ONE key, so this row cannot be \" +\n                    \"rebuilt as a group\",\n            );\n        }\n        // Both halves or neither: a txid without its group index names no asset,\n        // and an index without a txid names nothing at all. Either alone is a\n        // corrupt row rather than a contract that happens to lack an asset, and\n        // reading it as the latter re-derives the sat-only script — the exact\n        // silent drop this round-trip exists to close.\n        if ((params.assetTxid === undefined) !== (params.assetGroupIndex === undefined)) {\n            throw new Error(\n                \"asset params are incomplete: assetTxid and assetGroupIndex must both be present or both absent\",\n            );\n        }\n        // A row written by a strict-capable release (0.4.67 and earlier) carries\n        // a quoted bound compiled into its claim leaf. The option is gone, so\n        // that bound cannot be re-derived here — and reading the row as \"not\n        // strict\" would rebuild the DEFAULT covenant, a different pkScript, and\n        // die at `upsertContractRow` with an opaque `Script mismatch`. Name it.\n        if (params.strictClaimAmount !== undefined || params.strictClaimAssetAmount !== undefined) {\n            throw new Error(\n                \"strict claim params on a stored row: the strict claim bound was removed \" +\n                    \"and this row's lockup cannot be re-derived without it — restore it with \" +\n                    \"the SDK version that wrote it\",\n            );\n        }\n        // Same silent-drop shape as the two checks above, one flag further in:\n        // a row naming this flag without the suite it extends, or read as \"not\n        // set\", would re-derive a script missing the timelocked refund leaf.\n        if (params.nonInteractiveRefundWithoutReceiver !== undefined && !refund) {\n            throw new Error(\n                \"nonInteractiveRefundWithoutReceiver without the emulator covenant keys it \" +\n                    \"extends: reading this as 'not set' would re-derive a script without the leaf\",\n            );\n        }\n        if (\n            params.nonInteractiveRefundWithoutReceiver !== undefined &&\n            params.nonInteractiveRefundWithoutReceiver !== \"1\"\n        ) {\n            throw new Error(\n                `nonInteractiveRefundWithoutReceiver must be \"1\" when present, got ` +\n                    JSON.stringify(params.nonInteractiveRefundWithoutReceiver),\n            );\n        }\n        const asset =\n            params.assetTxid !== undefined && params.assetGroupIndex !== undefined\n                ? {\n                      txid: hex.decode(params.assetTxid),\n                      groupIndex: parseGroupIndex(params.assetGroupIndex),\n                  }\n                : undefined;\n        return {\n            sender: hex.decode(params.sender),\n            receiver: hex.decode(params.receiver),\n            server: hex.decode(params.server),\n            preimageHash: hex.decode(params.hash),\n            refundLocktime: BigInt(params.refundLocktime),\n            ...(asset && { asset }),\n            unilateralClaimDelay: sequenceToTimelock(Number(params.claimDelay)),\n            unilateralRefundDelay: sequenceToTimelock(Number(params.refundDelay)),\n            unilateralRefundWithoutReceiverDelay: sequenceToTimelock(\n                Number(params.refundNoReceiverDelay),\n            ),\n            ...(claim &&\n                refund && {\n                    nonInteractiveParameters: {\n                        receiverPkScript: claim.destination,\n                        senderPkScript: refund.destination,\n                        emulatorPubkey: claim.emulatorPubkey,\n                        // Absence of the flag IS the legacy marker — the same\n                        // encoding older SDKs wrote for eight-leaf rows.\n                        ...(params.nonInteractiveRefundWithoutReceiver !== \"1\" && {\n                            legacy: \"preTimelockedRefund\" as const,\n                        }),\n                    },\n                }),\n        };\n    },\n\n    /**\n     * Select spending path based on context.\n     *\n     * Role is determined from `context.role` or by matching\n     * `context.walletDescriptor` (preferred) / `context.walletPubKey`\n     * against sender/receiver in contract params.\n     */\n    selectPath(\n        script: VHTLC.ScriptV2,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection | null {\n        const role = resolveRole(contract, context);\n        const preimage = contract.params?.preimage;\n        const refundLocktime = BigInt(contract.params.refundLocktime);\n\n        if (!role) {\n            return null;\n        }\n\n        if (context.collaborative) {\n            if (role === \"receiver\" && preimage) {\n                return {\n                    leaf: script.claim(),\n                    extraWitness: [hex.decode(preimage)],\n                };\n            }\n\n            if (role === \"sender\" && isCltvSatisfied(context, refundLocktime)) {\n                return {\n                    leaf: script.refundWithoutReceiver(),\n                };\n            }\n\n            return null;\n        }\n\n        // Unilateral paths\n        if (role === \"receiver\" && preimage) {\n            const sequence = Number(contract.params.claimDelay);\n            if (!isCsvSpendable(context, sequence)) return null;\n            return {\n                leaf: script.unilateralClaim(),\n                extraWitness: [hex.decode(preimage)],\n                sequence,\n            };\n        }\n\n        if (role === \"sender\") {\n            const sequence = Number(contract.params.refundNoReceiverDelay);\n            if (!isCsvSpendable(context, sequence)) return null;\n            return {\n                leaf: script.unilateralRefundWithoutReceiver(),\n                sequence,\n            };\n        }\n\n        return null;\n    },\n\n    /**\n     * Get all possible spending paths (no timelock checks).\n     *\n     * Role is determined from `context.role` or by matching\n     * `context.walletDescriptor` (preferred) / `context.walletPubKey`\n     * against sender/receiver in contract params.\n     */\n    getAllSpendingPaths(\n        script: VHTLC.ScriptV2,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        const role = resolveRole(contract, context);\n        const paths: PathSelection[] = [];\n\n        if (!role) {\n            return paths;\n        }\n\n        const preimage = contract.params?.preimage;\n\n        if (context.collaborative) {\n            // Collaborative paths (no timelock checks)\n            if (role === \"receiver\" && preimage) {\n                paths.push({\n                    leaf: script.claim(),\n                    extraWitness: [hex.decode(preimage)],\n                });\n            }\n            if (role === \"sender\") {\n                paths.push({\n                    leaf: script.refundWithoutReceiver(),\n                });\n            }\n        } else {\n            // Unilateral paths (no timelock checks)\n            if (role === \"receiver\" && preimage) {\n                const sequence = Number(contract.params.claimDelay);\n                paths.push({\n                    leaf: script.unilateralClaim(),\n                    extraWitness: [hex.decode(preimage)],\n                    sequence,\n                });\n            }\n            if (role === \"sender\") {\n                const sequence = Number(contract.params.refundNoReceiverDelay);\n                paths.push({\n                    leaf: script.unilateralRefundWithoutReceiver(),\n                    sequence,\n                });\n            }\n        }\n\n        return paths;\n    },\n\n    getSpendablePaths(\n        script: VHTLC.ScriptV2,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        const role = resolveRole(contract, context);\n        const paths: PathSelection[] = [];\n\n        if (!role) {\n            return paths;\n        }\n\n        const preimage = contract.params?.preimage;\n        const refundLocktime = BigInt(contract.params.refundLocktime);\n\n        if (context.collaborative) {\n            if (role === \"receiver\" && preimage) {\n                paths.push({\n                    leaf: script.claim(),\n                    extraWitness: [hex.decode(preimage)],\n                });\n            }\n            if (role === \"sender\" && isCltvSatisfied(context, refundLocktime)) {\n                paths.push({\n                    leaf: script.refundWithoutReceiver(),\n                });\n            }\n            return paths;\n        }\n\n        if (role === \"receiver\" && preimage) {\n            const sequence = Number(contract.params.claimDelay);\n            if (isCsvSpendable(context, sequence)) {\n                paths.push({\n                    leaf: script.unilateralClaim(),\n                    extraWitness: [hex.decode(preimage)],\n                    sequence,\n                });\n            }\n        }\n        if (role === \"sender\") {\n            const sequence = Number(contract.params.refundNoReceiverDelay);\n            if (isCsvSpendable(context, sequence)) {\n                paths.push({\n                    leaf: script.unilateralRefundWithoutReceiver(),\n                    sequence,\n                });\n            }\n        }\n\n        return paths;\n    },\n\n    /**\n     * Refuse an explicit spend of a lockup whose refund path has not opened.\n     * @see assertVhtlcSpendableNow for why this is the one certain case.\n     */\n    assertSpendableNow(_script: VHTLC.ScriptV2, contract: Contract, context: PathContext): void {\n        assertVhtlcSpendableNow(contract, context);\n    },\n\n    /**\n     * Never. A live VHTLC is escrow: the counterparty's claim leaf is armed,\n     * and generic selection — send, settle, RENEWAL, offboard — would move the\n     * lockup out from under a swap the counterparty is still entitled to\n     * complete, or race a claim already in flight. The `vhtlc` handler now\n     * answers the same, for the same reason.\n     *\n     * The gate covers `available` and renewal. Recovery is generic and names\n     * nothing, so it is not covered here: `recoverVtxos` filters on\n     * {@link assertSpendableNow} instead, which drops a lockup only while its\n     * refund path is shut rather than forever. The explicit routes out —\n     * `settle({ inputs })`, or `@arkade-os/swap`'s `pushRefundWithoutReceiver`\n     * over `findLockupVtxos`' outpoints — are unaffected either way.\n     */\n    isGenericallySpendable: () => false,\n\n    /**\n     * The annotation leaf stamped onto every VTXO locked to this contract.\n     *\n     * **Without this the contract is unusable, not merely unoptimized.**\n     * `deriveContractTapscripts` falls back to `script.forfeit()` for any\n     * handler that does not implement {@link TapscriptDeriving}, and no VHTLC\n     * script version has a `forfeit()` — `VtxoScript` does not define one and\n     * `VHTLC.BaseScript` does not add one. The fallback therefore throws\n     * `legacy.forfeit is not a function`, `annotatableIn` catches it, and\n     * `fetchContractVtxosBulk` drops this contract's VTXOs before they are\n     * persisted. The row would exist and be watched while its balance stayed\n     * permanently invisible, and `getSyncState()` would report `degraded`\n     * forever. (The `vhtlc` handler had the same gap and now closes it the same\n     * way; nothing registers V1 rows through `ContractManager` in this repo, so\n     * it was never hit here.)\n     *\n     * `refundWithoutReceiver` is the leaf, for both roles the annotation\n     * serves, because it is the only collaborative path this wallet can\n     * actually satisfy as the sender — the same conclusion `selectPath`\n     * reaches, kept in step with it deliberately. The claim leaves belong to\n     * the receiver and need a preimage the sender does not have; `refund` and\n     * `unilateralRefund` need the counterparty; the covenant leaves are the\n     * emulator's.\n     *\n     * **It carries a CLTV, and callers must respect it.** A settlement built on\n     * this leaf is only valid once `refundLocktime` has matured, so a recovery\n     * round that sweeps this VTXO early is rejected by the server. That is the\n     * same constraint `packages/boltz-swap` encodes as \"pre-CLTV recoverable →\n     * skipped\"; nothing in this handler can enforce it, because the annotation\n     * is derived per contract and knows no clock. `recoverVtxos` filters on\n     * {@link assertSpendableNow} for it.\n     *\n     * **Role-blind.** A receiver's row gets the same leaf, which names keys that\n     * wallet does not hold, so it is satisfiable only by the wallet holding the\n     * lockup's `sender` key and fails at intent registration for anyone else.\n     */\n    deriveTapscripts(script: VHTLC.ScriptV2): DerivedContractTapscripts {\n        const leaf = script.refundWithoutReceiver();\n        return {\n            forfeitTapLeafScript: leaf,\n            intentTapLeafScript: leaf,\n            tapTree: script.encode(),\n        };\n    },\n};\n","import { hex } from \"@scure/base\";\nimport { DefaultVtxo } from \"../../script/default\";\nimport { Contract, ContractHandler, Discoverable, PathContext, PathSelection } from \"../types\";\nimport type { DiscoveredContract, DiscoveryDeps } from \"../types\";\nimport { DefaultContractHandler, DefaultContractParams } from \"./default\";\nimport { deriveDescriptorLeafPubKey } from \"../../identity/descriptor\";\nimport { timelockToSequence } from \"../../utils/timelock\";\nimport { rotatedReceiveMetadata } from \"./helpers\";\n\n/**\n * Typed parameters for boarding contracts.\n *\n * Boarding reuses the exact `default` contract parameter shape\n * (`pubKey` / `serverPubKey` / `csvTimelock`) rather than inventing\n * boarding-specific names — the boarding semantics come from the\n * contract type and from populating `csvTimelock` with the server's\n * boarding-exit delay (`ArkInfo.boardingExitDelay`) instead of the\n * offchain unilateral-exit delay.\n */\nexport type BoardingContractParams = DefaultContractParams;\n\n/**\n * Handler for the boarding contract (registered type `boarding`).\n *\n * The boarding contract derives the on-chain Bitcoin address used to\n * board funds onto Arkade. It shares the exact `DefaultVtxo.Script`\n * shape with the `default` contract — a Taproot output co-owned by the\n * wallet and the Ark server, with a CSV exit path back to the wallet —\n * and therefore reuses the `default` handler's path logic (forfeit via\n * server cooperation, exit after the boarding CSV).\n *\n * Boarding semantics come entirely from the contract type and from\n * sourcing the CSV timelock from the server's boarding-exit delay\n * (`ArkInfo.boardingExitDelay`), not from renamed parameters. The\n * offchain `default` contract is built from `ArkInfo.unilateralExitDelay`\n * instead, so the two share a script shape but differ in their CSV\n * timelock value. Parameters round-trip through the same\n * `timelockToSequence` / `sequenceToTimelock` helpers and BIP68 sequence\n * encoding as `default` / `delegate`.\n *\n * Like `default` / `delegate`, the boarding handler implements\n * {@link Discoverable.discoverAt} so `wallet.restore()` can rediscover\n * used boarding indices from authoritative on-chain data. It differs from\n * the L2 handlers in its source of truth: boarding probes the **on-chain**\n * UTXO set at its P2TR address (`OnchainProvider.getCoins`) rather than the\n * Ark indexer, and builds its candidate from the boarding-exit CSV\n * (`deps.boardingTimelock`). When boarding discovery is not plumbed (no\n * `deps.boardingTimelock` / `deps.onchainNetwork`) `discoverAt` no-ops.\n *\n * Identity & the default/boarding collision: a contract's `script` (pkScript)\n * is its unique identity — a script owns exactly one repository row. `boarding`\n * is a first-class type with its own row **when its script is distinct** from\n * the wallet's `default` baseline — the real-world case, since a sound Ark\n * server keeps boardingExitDelay strictly longer than unilateralExitDelay (equal\n * delays would expose the provider to a double-spend). Should those delays ever\n * coincide (a misconfigured/malicious server), the boarding script is\n * byte-identical to the default script. `discoverAt` does NOT pre-coalesce that\n * collision: it always emits `type: \"boarding\"`, and the single shared row is\n * resolved FIRST-WINS at the persistence layer\n * ({@link ContractManager.upsertContract}) — whichever purpose is persisted\n * first keeps the row, and the scan deliberately probes boarding first\n * (see docs/hd-wallets_onchain_rotation_collision_fix.md §5.1–5.2). Either way\n * the funds are equally spendable through the shared `DefaultVtxo.Script` paths.\n * Consumers must NOT rely on `contract.type === \"boarding\"` to identify the\n * boarding purpose — resolve the boarding script via\n * `wallet.getBoardingAddress()` / `wallet.boardingTapscript` (which never depend\n * on the persisted contract's type) and match by script when needed.\n */\nexport const BoardingContractHandler: ContractHandler<BoardingContractParams, DefaultVtxo.Script> &\n    Discoverable = {\n    type: \"boarding\",\n\n    createScript(params: Record<string, string>): DefaultVtxo.Script {\n        return DefaultContractHandler.createScript(params);\n    },\n\n    serializeParams(params: BoardingContractParams): Record<string, string> {\n        return DefaultContractHandler.serializeParams(params);\n    },\n\n    deserializeParams(params: Record<string, string>): BoardingContractParams {\n        return DefaultContractHandler.deserializeParams(params);\n    },\n\n    selectPath(\n        script: DefaultVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection | null {\n        return DefaultContractHandler.selectPath(script, contract, context);\n    },\n\n    getAllSpendingPaths(\n        script: DefaultVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return DefaultContractHandler.getAllSpendingPaths(script, contract, context);\n    },\n\n    getSpendablePaths(\n        script: DefaultVtxo.Script,\n        contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return DefaultContractHandler.getSpendablePaths(script, contract, context);\n    },\n\n    /** Preserves today's settle/board behaviour. */\n    isGenericallySpendable: () => true,\n\n    /**\n     * Probe the on-chain UTXO set for a boarding output at this HD index.\n     *\n     * Boarding's source of truth is the **current** on-chain coin set\n     * (`OnchainProvider.getCoins`), not the Ark indexer: a boarded (spent)\n     * boarding output becomes an L2 VTXO at the receive index, so the\n     * indexer probe already keeps the gap window open for it; only an\n     * *unspent* boarding output needs the on-chain probe (see plan §2).\n     *\n     * No-ops (returns `[]`) when boarding discovery is not plumbed — i.e.\n     * `deps.boardingTimelock` or `deps.onchainNetwork` is absent — so the\n     * scanner unit harness (which sets neither) is unaffected.\n     *\n     * Always emits `type: \"boarding\"`, even in the degenerate equal-delay case\n     * where the boarding script is byte-identical to a `default` script at this\n     * index (`boardingExitDelay === unilateralExitDelay`). The collision is no\n     * longer pre-judged in discovery; it is tolerated FIRST-WINS at the\n     * persistence layer ({@link ContractManager.upsertContract}). `deps.csvTimelocks`\n     * is intentionally not read here.\n     */\n    async discoverAt(\n        index: number,\n        descriptor: string,\n        deps: DiscoveryDeps,\n    ): Promise<DiscoveredContract[]> {\n        if (!deps.boardingTimelock || !deps.onchainNetwork) return [];\n\n        const pubKey = deriveDescriptorLeafPubKey(descriptor);\n        const script = new DefaultVtxo.Script({\n            pubKey,\n            serverPubKey: deps.serverPubKey,\n            csvTimelock: deps.boardingTimelock,\n        });\n        const onchainAddress = script.onchainAddress(deps.onchainNetwork);\n\n        const coins = await deps.onchainProvider.getCoins(onchainAddress);\n        if (coins.length === 0) return [];\n\n        const scriptHex = hex.encode(script.pkScript);\n        const boardingSeq = timelockToSequence(deps.boardingTimelock);\n\n        // Always `type: \"boarding\"` (see method doc). The equal-delay\n        // same-script collision is resolved first-wins at persistence, and the\n        // scan probes boarding before default so a both-purpose rotated index\n        // resolves to a `boarding` row — keeping both the on-chain UTXO and any\n        // L2 VTXO recoverable (docs/hd-wallets_onchain_rotation_collision_fix.md\n        // §5.2, §5.4).\n        return [\n            {\n                type: \"boarding\",\n                params: {\n                    pubKey: hex.encode(pubKey),\n                    serverPubKey: hex.encode(deps.serverPubKey),\n                    csvTimelock: boardingSeq.toString(),\n                },\n                script: scriptHex,\n                // The persisted row's `address` is the *Ark* address (not the\n                // on-chain P2TR), matching the row registered at init so the\n                // ContractWatcher keeps monitoring the same L2 script and the\n                // VTXO repository bucket lines up (plan §6-I.4). The P2TR is\n                // recomputed from params only for the `getCoins` probe.\n                address: script.address(deps.network.hrp, deps.serverPubKey).encode(),\n                // Tag rotated rows (index > 0) so boot resolution can find the\n                // newest boarding address and descriptor-aware signing can\n                // recover the per-index key (plan §6-II/§6-III.3). The index-0\n                // baseline stays untagged, matching `default`/`delegate`.\n                ...rotatedReceiveMetadata(index, descriptor),\n            },\n        ];\n    },\n};\n","/**\n * Arkade Program model & compiler.\n *\n * A {@link Program} is the artifact shape shared with the ArkadeScript\n * compiler: named functions, each split into a `tapscript` segment enforced\n * on-chain and an optional `arkadeScript` segment emulated by the co-signing\n * service. This module owns everything that is *pure data → script*:\n *\n * - the Program/segment/token types,\n * - `$param` resolution ({@link resolveAsm}), witness and timelock resolution,\n * - program validation ({@link validateProgram}) — typed constructor params\n *   are authoritative when present,\n * - {@link ArkadeProgramScript} — a {@link VtxoScript} compiled from a\n *   program, its constructor args and the signer keys,\n * - artifact JSON (de)serialization ({@link parseArtifact} /\n *   {@link stringifyArtifact}) and the string-keyed contract params used to\n *   persist a program contract through the `src/contracts` pipeline.\n *\n * Keeping this free of provider/transaction imports lets the generic\n * `arkade` contract handler (src/contracts/handlers/arkade.ts) and the\n * high-level `ArkadeContract` client share one compilation path.\n *\n * @module arkade/program\n */\n\nimport { hex } from \"@scure/base\";\nimport { ScriptNum } from \"@scure/btc-signer\";\n\nimport {\n    MultisigTapscript,\n    CSVMultisigTapscript,\n    CLTVMultisigTapscript,\n    ConditionMultisigTapscript,\n    ConditionCSVMultisigTapscript,\n    type ArkTapscript,\n    type TapscriptType,\n} from \"../script/tapscript\";\nimport { VtxoScript, type TapLeafScript } from \"../script/base\";\nimport { ArkadeScript } from \"./script\";\nimport { ARKADE_OP } from \"./opcodes\";\nimport { computeArkadeScriptPublicKey } from \"./tweak\";\n\nconst MinimalScriptNum = ScriptNum(undefined, true);\n\n// --- Program model (mirrors the compiler artifact) -------------------------\n\n/** A token in an `asm` array: an opcode name, a number/bigint push, raw bytes, or a `$param` placeholder. */\nexport type AsmToken = string | number | bigint | Uint8Array;\n\n/** A constructor argument or resolved value. */\nexport type ArkadeParamValue = Uint8Array | bigint | number;\n\n/** A function call argument (function input). */\nexport type ArkadeArgValue = Uint8Array | bigint | number;\n\n/**\n * The declared type of a function input, used to derive the static TS type of\n * the corresponding `functions.<name>(...)` argument. Byte-like types map to\n * `Uint8Array`; `int` maps to `bigint | number`.\n */\nexport type ArkadeArgType = \"bytes\" | \"pubkey\" | \"sig\" | \"hash\" | \"int\";\n\n/**\n * Maps an {@link ArkadeArgType} to its TypeScript argument type.\n * @internal\n */\nexport interface ArkadeValueType {\n    bytes: Uint8Array;\n    pubkey: Uint8Array;\n    sig: Uint8Array;\n    hash: Uint8Array;\n    int: bigint | number;\n}\n\n/** A typed function input or constructor param: a name plus its {@link ArkadeArgType}. */\nexport interface InputDef {\n    name: string;\n    type: ArkadeArgType;\n}\n\n/**\n * A function input or constructor param declaration: either a typed descriptor\n * `{ name, type }` (the argument is statically typed and its bound value is\n * validated) or a bare name string (the argument falls back to the loose\n * {@link ArkadeArgValue}).\n */\nexport type InputRef = string | InputDef;\n\n/** Constructor pubkey `$param` tweaked by `fn`'s covenant. */\nexport interface TweakedSigner {\n    tweak: string;\n    fn: string;\n}\n\n/** A `\"$param\"` reference, literal x-only bytes, or a {@link TweakedSigner}. */\nexport type SignerRef = string | Uint8Array | TweakedSigner;\n\n/** A witness-stack item: a function-input name, a `\"$param\"`, a literal number/bigint (minimal script-num), or raw bytes. */\nexport type WitnessRef = string | number | bigint | Uint8Array;\n\n/** Bitcoin Script segment of a spending path — enforced on-chain. */\nexport interface TapscriptSegment {\n    /**\n     * Required signers. A path with `arkadeScript` also appends the emulator\n     * co-signer, unless `emulator` is `null`.\n     */\n    signers: SignerRef[];\n    /**\n     * Covenant named by `<EMULATOR_KEY:fn>`. `null` when this leaf belongs to a\n     * covenant but signs with a constructor-key tweak instead. Omitted on\n     * hand-written programs, which still append the co-signer.\n     */\n    emulator?: string | null;\n    /**\n     * Optional standard-opcode condition (e.g. a hashlock), encoded into a\n     * ConditionMultisig leaf — or ConditionCSVMultisig when combined with `csv`.\n     */\n    asm?: AsmToken[];\n    /**\n     * Relative timelock (CSV). The value is a literal or a `\"$param\"` reference\n     * resolved against the constructor args (same convention as {@link SignerRef}).\n     * Combinable with `asm` (condition + CSV); mutually exclusive with `cltv`.\n     */\n    csv?: { type: \"blocks\" | \"seconds\"; value: bigint | string };\n    /**\n     * Absolute timelock (CLTV): a literal or a `\"$param\"` reference.\n     * Mutually exclusive with `csv`/`asm`.\n     */\n    cltv?: bigint | string;\n    /** Items satisfying the condition (e.g. an HTLC preimage); set via the ConditionWitness PSBT field. */\n    witness?: WitnessRef[];\n}\n\n/** Arkade Script segment of a spending path — emulated, bound via the key tweak. */\nexport interface ArkadeSegment {\n    /** Raw Arkade opcodes with `$param` placeholders. */\n    asm: AsmToken[];\n    /** The arkade-script witness stack (e.g. an output index). */\n    witness?: WitnessRef[];\n}\n\n/** One named spending path. */\nexport interface ArkadeFunction {\n    /**\n     * The function ABI: an ordered list of call arguments. Each entry is a typed\n     * descriptor `{ name, type }` (which gives the matching `functions.<name>`\n     * argument a precise static type) or a bare name string (loose\n     * {@link ArkadeArgValue}). Absent for nullary paths (e.g. exit/cancel).\n     */\n    inputs?: readonly InputRef[];\n    tapscript: TapscriptSegment;\n    /** Present for covenant paths; absent for pure-tapscript paths (cancel/exit). */\n    arkadeScript?: ArkadeSegment;\n}\n\nexport const SUPPORTED_PROGRAM_VERSION = 0;\n\n/** An Arkade contract program (hand-written or compiler-emitted). */\nexport interface Program {\n    version: number;\n    /**\n     * Optional program name — metadata only: round-tripped through the\n     * artifact JSON, never used in compilation or the taproot tree.\n     */\n    name?: string;\n    /**\n     * Ordered constructor parameters. Bare name strings are documentation only\n     * (the legacy hand-written form); typed descriptors `{ name, type }` make\n     * the list authoritative — see {@link validateProgram}.\n     */\n    params?: readonly InputRef[];\n    functions: Record<string, ArkadeFunction>;\n}\n\n// --- helpers ---------------------------------------------------------------\n\n/** The declared name of a function input or constructor param, whether typed descriptor or bare string. */\nexport function inputName(ref: InputRef): string {\n    return typeof ref === \"string\" ? ref : ref.name;\n}\n\n/** Look up a `$param` / function-input value in a bind map; throws when unbound. */\nexport function bindValue(bind: Record<string, ArkadeParamValue>, name: string): ArkadeParamValue {\n    const v = bind[name];\n    if (v === undefined) throw new Error(`unbound parameter '${name}'`);\n    return v;\n}\n\n/**\n * Resolve a timelock value to a bigint: bigints pass through; a `\"$param\"`\n * string resolves against the program's constructor args and must be bound to\n * a bigint/number. Any other string is an error.\n */\nexport function resolveTimelockValue(\n    value: bigint | string,\n    args: Record<string, ArkadeParamValue>,\n): bigint {\n    if (typeof value === \"bigint\") return value;\n    if (value.startsWith(\"$\")) {\n        const v = bindValue(args, value.slice(1));\n        if (typeof v === \"bigint\" || typeof v === \"number\") return BigInt(v);\n        throw new Error(`timelock value '${value}' must resolve to a number`);\n    }\n    throw new Error(\n        `invalid timelock value '${value}' — expected a bigint or a '$param' reference`,\n    );\n}\n\n/**\n * Resolve an `asm` array to bytes: substitute `$param` placeholders from `bind`,\n * pass everything else (opcode names, numbers, raw byte pushes) through to the\n * Arkade script encoder. The SDK does not interpret opcodes — this is pure\n * substitution + encoding. To embed a signer key (server, user, or any\n * other), pass it as a `$param` in the constructor args; there is no\n * `<SERVER_KEY>`/`<COSIGNER_KEY>` token.\n */\nexport function resolveAsm(asm: AsmToken[], bind: Record<string, ArkadeParamValue>): Uint8Array {\n    const tokens = asm.map((t) => {\n        if (typeof t === \"string\" && t.startsWith(\"$\")) {\n            return bindValue(bind, t.slice(1));\n        }\n        if (t === \"<SELF>\") {\n            // Continuation covenants don't hard-code their own address (that would\n            // be a non-converging fixpoint); express them with input introspection\n            // (PUSHCURRENTINPUTINDEX + INSPECTINPUTSCRIPTPUBKEY) instead.\n            throw new Error(\n                \"<SELF> is not a placeholder; use INSPECTINPUTSCRIPTPUBKEY for continuation covenants\",\n            );\n        }\n        return t;\n    });\n    return ArkadeScript.encode(tokens as never);\n}\n\n/**\n * Resolve one witness-stack item to bytes.\n *\n * - raw bytes pass through;\n * - numbers/bigints encode as minimal script-nums;\n * - `\"$param\"` strings resolve against the program's constructor args;\n * - any other string is a function-input name and resolves against `callArgs`\n *   (throws when the input is unbound — e.g. outside a function call).\n */\nexport function witnessRefToBytes(\n    ref: WitnessRef,\n    callArgs: Record<string, ArkadeArgValue>,\n    programArgs: Record<string, ArkadeParamValue>,\n): Uint8Array {\n    if (ref instanceof Uint8Array) return ref;\n    if (typeof ref === \"number\" || typeof ref === \"bigint\") {\n        return MinimalScriptNum.encode(BigInt(ref));\n    }\n    const v = ref.startsWith(\"$\") ? bindValue(programArgs, ref.slice(1)) : bindValue(callArgs, ref);\n    if (v instanceof Uint8Array) return v;\n    return MinimalScriptNum.encode(BigInt(v));\n}\n\n/**\n * Validate a tapscript segment: it must have signers; `asm` may combine with\n * `csv` (the condition + CSV closure) but `cltv` conflicts with both (arkd\n * recognizes no condition+CLTV or dual-timelock closure); the `asm` may not\n * contain Arkade opcodes (those are `OP_SUCCESS` on-chain and belong in the\n * `arkadeScript` segment).\n */\nexport function validateTapscript(seg: TapscriptSegment): void {\n    if (!seg.signers || seg.signers.length === 0) {\n        throw new Error(\"tapscript: at least one signer is required\");\n    }\n    if (seg.asm !== undefined && seg.cltv !== undefined) {\n        throw new Error(\n            \"tapscript: `asm` and `cltv` conflict — arkd has no condition+CLTV closure\",\n        );\n    }\n    if (seg.csv !== undefined && seg.cltv !== undefined) {\n        throw new Error(\"tapscript: `csv` and `cltv` conflict — use at most one timelock\");\n    }\n    for (const t of seg.asm ?? []) {\n        if (typeof t === \"string\" && t in ARKADE_OP) {\n            throw new Error(\n                `tapscript: arkade opcode '${t}' is not enforceable on-chain — move it to arkadeScript`,\n            );\n        }\n    }\n}\n\n/** Collect every `\"$name\"` reference in a program's signers, asm, witness and timelock values. */\nfunction collectParamRefs(program: Program): Set<string> {\n    const refs = new Set<string>();\n    const collect = (items: readonly (AsmToken | WitnessRef | SignerRef)[] | undefined) => {\n        for (const t of items ?? []) {\n            if (typeof t === \"string\" && t.startsWith(\"$\")) refs.add(t.slice(1));\n            else if (isTweakedSigner(t) && t.tweak.startsWith(\"$\")) refs.add(t.tweak.slice(1));\n        }\n    };\n    for (const fn of Object.values(program.functions)) {\n        const tap = fn.tapscript;\n        collect(tap.signers);\n        collect(tap.asm);\n        collect(tap.witness);\n        collect(tap.csv ? [tap.csv.value] : undefined);\n        collect(tap.cltv !== undefined ? [tap.cltv] : undefined);\n        collect(fn.arkadeScript?.asm);\n        collect(fn.arkadeScript?.witness);\n    }\n    return refs;\n}\n\n/** Byte lengths enforced for typed values (x-only pubkey, BIP340 signature). */\nconst TYPED_BYTE_LENGTHS: Partial<Record<ArkadeArgType, number>> = { pubkey: 32, sig: 64 };\n\n/** Validate a bound value against its typed declaration; errors name the parameter. */\nfunction validateParamValue(def: InputDef, value: ArkadeParamValue): void {\n    if (def.type === \"int\") {\n        if (typeof value !== \"bigint\" && typeof value !== \"number\") {\n            throw new Error(`program parameter '${def.name}' expects an int, got bytes`);\n        }\n        return;\n    }\n    if (!(value instanceof Uint8Array)) {\n        throw new Error(\n            `program parameter '${def.name}' expects ${def.type} bytes, got ${typeof value}`,\n        );\n    }\n    const length = TYPED_BYTE_LENGTHS[def.type];\n    if (length !== undefined && value.length !== length) {\n        throw new Error(\n            `program parameter '${def.name}' expects a ${length}-byte ${def.type}, got ${value.length} bytes`,\n        );\n    }\n}\n\n/**\n * Validate a program's constructor-parameter declarations against the bound\n * args. A `params` list of bare name strings is documentation only (the\n * legacy hand-written form — no checks). When at least one entry is a typed\n * descriptor (the compiler-emitted form), the list is authoritative: every\n * declared param must be bound in `args`, every `\"$name\"` reference in the\n * program must be declared, and typed entries validate their bound value\n * (bytes-like types require a Uint8Array — 32 bytes for `pubkey`, 64 for\n * `sig`; `int` requires a bigint/number).\n */\nexport function validateProgram(program: Program, args: Record<string, ArkadeParamValue>): void {\n    const params = program.params;\n    if (!params || !params.some((p) => typeof p !== \"string\")) return;\n\n    const declared = new Set(params.map(inputName));\n    for (const name of declared) {\n        if (args[name] === undefined) {\n            throw new Error(`program parameter '${name}' is declared but not bound in args`);\n        }\n    }\n    for (const ref of collectParamRefs(program)) {\n        if (!declared.has(ref)) {\n            throw new Error(`'$${ref}' is referenced but not declared in program params`);\n        }\n    }\n    for (const p of params) {\n        if (typeof p !== \"string\") validateParamValue(p, args[p.name]);\n    }\n}\n\n// --- Compilation -----------------------------------------------------------\n\n/** The signer keys a program is compiled against. */\nexport interface ProgramKeys {\n    /** The Arkade Service signer key (x-only) — used for address derivation and collaborative-path detection, not for `$param` resolution. */\n    serverKey: Uint8Array;\n    /** The wallet's x-only key — identifies which inputs the wallet signs. */\n    userKey?: Uint8Array;\n    /** The co-signer (emulator) key — required only for covenant (`arkadeScript`) functions. */\n    emulatorKey?: Uint8Array;\n}\n\n/**\n * A single spending path, fully resolved at compilation: its definition, the\n * committed leaf body, the per-path arkade-script bytes (covenant paths only),\n * and the {@link TapLeafScript} (control block) for spending it.\n */\nexport interface CompiledProgramFunction {\n    name: string;\n    def: ArkadeFunction;\n    /** The committed leaf script (body). */\n    leafScript: Uint8Array;\n    /** Resolved arkade-script bytes; undefined for pure-tapscript paths. */\n    arkadeScript?: Uint8Array;\n    /** Resolved signer keys (x-only), in the declared `signers` order. */\n    signerKeys: Uint8Array[];\n    /** Resolved once — the taproot leaf + control block for this path. */\n    tapLeafScript: TapLeafScript;\n}\n\nfunction isTweakedSigner(ref: unknown): ref is TweakedSigner {\n    if (typeof ref !== \"object\" || ref === null || ref instanceof Uint8Array) return false;\n    const { tweak, fn } = ref as TweakedSigner;\n    return typeof tweak === \"string\" && typeof fn === \"string\";\n}\n\n/** Resolve a pubkey signer to x-only key bytes against the program's constructor args. */\nfunction resolveSigner(\n    ref: string | Uint8Array,\n    args: Record<string, ArkadeParamValue>,\n): Uint8Array {\n    if (ref instanceof Uint8Array) return ref;\n    if (typeof ref !== \"string\" || !ref.startsWith(\"$\")) {\n        throw new Error(`unknown signer reference '${ref}' — use a '$param' or key bytes`);\n    }\n    const v = bindValue(args, ref.slice(1));\n    if (!(v instanceof Uint8Array)) {\n        throw new Error(`signer ${ref} must be a pubkey (bytes)`);\n    }\n    return v;\n}\n\nfunction encodeTapscriptSegment(\n    seg: TapscriptSegment,\n    pubkeys: Uint8Array[],\n    args: Record<string, ArkadeParamValue>,\n): ArkTapscript<TapscriptType, any> {\n    if (seg.csv) {\n        const timelock = { type: seg.csv.type, value: resolveTimelockValue(seg.csv.value, args) };\n        if (seg.asm) {\n            // The fifth arkd closure: condition + CSV.\n            return ConditionCSVMultisigTapscript.encode({\n                conditionScript: resolveAsm(seg.asm, args),\n                timelock,\n                pubkeys,\n            });\n        }\n        return CSVMultisigTapscript.encode({ timelock, pubkeys });\n    }\n    if (seg.cltv !== undefined) {\n        return CLTVMultisigTapscript.encode({\n            absoluteTimelock: resolveTimelockValue(seg.cltv, args),\n            pubkeys,\n        });\n    }\n    if (seg.asm) {\n        return ConditionMultisigTapscript.encode({\n            conditionScript: resolveAsm(seg.asm, args),\n            pubkeys,\n        });\n    }\n    return MultisigTapscript.encode({ pubkeys });\n}\n\nfunction compileFunctions(\n    program: Program,\n    args: Record<string, ArkadeParamValue>,\n    keys: ProgramKeys,\n): Omit<CompiledProgramFunction, \"tapLeafScript\">[] {\n    if (program.version !== SUPPORTED_PROGRAM_VERSION) {\n        throw new Error(\n            `ArkadeContract: unsupported program version ${program.version} — this SDK supports version ${SUPPORTED_PROGRAM_VERSION}`,\n        );\n    }\n    const functions: Record<string, ArkadeFunction> = program.functions;\n    const names = Object.keys(functions);\n    if (names.length === 0) {\n        throw new Error(\"ArkadeContract: program has no functions\");\n    }\n    validateProgram(program, args);\n    const defs = names.map((n) => functions[n]);\n\n    // Covenant functions need the emulator's co-signer key for the tweak.\n    const covenant = names.find((_, i) => defs[i].arkadeScript);\n    if (covenant && !keys.emulatorKey) {\n        throw new Error(\n            `ArkadeContract: function '${covenant}' has an arkadeScript but no emulator is configured — pass an \\`emulator\\` to Arkade.connect`,\n        );\n    }\n\n    return defs.map((def, i) => {\n        validateTapscript(def.tapscript);\n        const pubkeys = def.tapscript.signers.map((signer) => {\n            if (!isTweakedSigner(signer)) return resolveSigner(signer, args);\n            const asm = functions[signer.fn]?.arkadeScript?.asm;\n            if (!asm) {\n                throw new Error(\n                    `ArkadeContract: function '${names[i]}' tweaks '${signer.fn}', which has no arkade script`,\n                );\n            }\n            return computeArkadeScriptPublicKey(\n                resolveSigner(signer.tweak, args),\n                resolveAsm(asm, args),\n            );\n        });\n\n        // A covenant leaf appends the emulator co-signer. A constructor-key\n        // tweak of that covenant sets `emulator` to null and does not.\n        const arkadeScript = def.arkadeScript ? resolveAsm(def.arkadeScript.asm, args) : undefined;\n        const leafPubkeys =\n            arkadeScript && def.tapscript.emulator !== null\n                ? [...pubkeys, computeArkadeScriptPublicKey(keys.emulatorKey!, arkadeScript)]\n                : pubkeys;\n        const leafScript = encodeTapscriptSegment(def.tapscript, leafPubkeys, args).script;\n        return { name: names[i], def, leafScript, arkadeScript, signerKeys: pubkeys };\n    });\n}\n\n/**\n * A {@link VtxoScript} compiled from an Arkade {@link Program}, its\n * constructor args and the signer keys.\n *\n * This is the single compilation path shared by the high-level\n * `ArkadeContract` client and the `\"arkade\"` contract handler: both produce\n * byte-identical taproot trees for the same (program, args, keys), so a\n * contract registered through the `src/contracts` pipeline re-derives the\n * exact script it was created with.\n */\nexport class ArkadeProgramScript extends VtxoScript {\n    /** Spending paths in declaration order. */\n    readonly compiled: CompiledProgramFunction[];\n\n    constructor(\n        readonly program: Program,\n        readonly args: Record<string, ArkadeParamValue>,\n        readonly keys: ProgramKeys,\n    ) {\n        const partial = compileFunctions(program, args, keys);\n        super(partial.map((p) => p.leafScript));\n        this.compiled = partial.map((p) => ({\n            ...p,\n            tapLeafScript: this.findLeaf(hex.encode(p.leafScript)),\n        }));\n    }\n\n    /** The compiled spending path with the given function name, if any. */\n    functionByName(name: string): CompiledProgramFunction | undefined {\n        return this.compiled.find((f) => f.name === name);\n    }\n}\n\n// --- Artifact JSON ----------------------------------------------------------\n\n/**\n * Convert a Program JSON artifact into a {@link Program}. Byte values are\n * encoded as `0x`-prefixed hex strings in `asm`/`witness`/`signers`; opcode names,\n * `$param` placeholders and numbers pass through unchanged.\n *\n * This is *not* the JSON `arkadec` writes. That artifact lists spend groups in\n * an array and uses `<param>` placeholders and raw leaf assembly; pass it to\n * {@link programFromArtifact} instead.\n */\nexport function parseArtifact(artifact: {\n    version?: number;\n    name?: string;\n    params?: readonly InputRef[];\n    functions: unknown;\n}): Program {\n    // An arkadec ContractJson would otherwise become functions named \"0\", \"1\", \"2\".\n    if (Array.isArray(artifact.functions)) {\n        throw new Error(\n            \"parseArtifact: `functions` is an array, which is the arkadec artifact shape, not an SDK program — read it with programFromArtifact instead\",\n        );\n    }\n    if (typeof artifact.functions !== \"object\" || artifact.functions === null) {\n        throw new Error(\"parseArtifact: `functions` must be an object keyed by function name\");\n    }\n    const hexToken = (t: unknown): any =>\n        typeof t === \"string\" && t.startsWith(\"0x\") ? hex.decode(t.slice(2)) : t;\n    const signerRef = (s: unknown): SignerRef => {\n        if (s instanceof Uint8Array || typeof s === \"string\") return hexToken(s);\n        if (isTweakedSigner(s)) return { tweak: s.tweak, fn: s.fn };\n        throw new Error(\"parseArtifact: a tweaked signer needs string `tweak` and `fn`\");\n    };\n    // A \"$param\" timelock stays a reference (resolved at compile time); anything\n    // else is a literal.\n    const timelockValue = (v: unknown): bigint | string =>\n        typeof v === \"string\" && v.startsWith(\"$\") ? v : BigInt(v as string | number);\n\n    const functions: Record<string, ArkadeFunction> = {};\n    for (const [name, fn] of Object.entries(artifact.functions as Record<string, any>)) {\n        const tap = fn.tapscript ?? {};\n        const tapscript: TapscriptSegment = {\n            signers: (tap.signers ?? []).map(signerRef),\n            ...(tap.asm ? { asm: tap.asm.map(hexToken) } : {}),\n            ...(tap.witness ? { witness: tap.witness.map(hexToken) } : {}),\n            ...(tap.csv\n                ? { csv: { type: tap.csv.type, value: timelockValue(tap.csv.value) } }\n                : {}),\n            ...(tap.cltv !== undefined ? { cltv: timelockValue(tap.cltv) } : {}),\n            ...(\"emulator\" in tap ? { emulator: tap.emulator as string | null } : {}),\n        };\n        const arkadeScript = fn.arkadeScript\n            ? {\n                  asm: fn.arkadeScript.asm.map(hexToken),\n                  ...(fn.arkadeScript.witness\n                      ? { witness: fn.arkadeScript.witness.map(hexToken) }\n                      : {}),\n              }\n            : undefined;\n        functions[name] = {\n            ...(fn.inputs ? { inputs: fn.inputs } : {}),\n            tapscript,\n            ...(arkadeScript ? { arkadeScript } : {}),\n        };\n    }\n    return {\n        version: artifact.version ?? SUPPORTED_PROGRAM_VERSION,\n        ...(artifact.name !== undefined ? { name: artifact.name } : {}),\n        ...(artifact.params ? { params: artifact.params } : {}),\n        functions,\n    };\n}\n\n/**\n * Serialize a {@link Program} to compiler-artifact JSON — the inverse of\n * {@link parseArtifact}: bytes become `0x`-hex strings; bigint tokens become\n * plain numbers (or, above `Number.MAX_SAFE_INTEGER`, `0x`-hex of their\n * minimal script-num bytes, which the script encoder pushes identically);\n * literal timelock values serialize as decimal strings while `\"$param\"`\n * timelock references are emitted as-is.\n */\nexport function stringifyArtifact(program: Program): string {\n    const token = (t: AsmToken | WitnessRef | SignerRef): unknown => {\n        if (t instanceof Uint8Array) return \"0x\" + hex.encode(t);\n        if (typeof t === \"bigint\") {\n            if (t >= BigInt(Number.MIN_SAFE_INTEGER) && t <= BigInt(Number.MAX_SAFE_INTEGER)) {\n                return Number(t);\n            }\n            // Out of JSON-safe integer range: a plain decimal string would be\n            // misread as an opcode name, so emit the equivalent byte push.\n            return \"0x\" + hex.encode(MinimalScriptNum.encode(t));\n        }\n        return t;\n    };\n\n    const functions: Record<string, unknown> = {};\n    for (const [name, fn] of Object.entries(program.functions)) {\n        const tap = fn.tapscript;\n        functions[name] = {\n            ...(fn.inputs ? { inputs: fn.inputs } : {}),\n            tapscript: {\n                signers: tap.signers.map(token),\n                ...(tap.asm ? { asm: tap.asm.map(token) } : {}),\n                ...(tap.witness ? { witness: tap.witness.map(token) } : {}),\n                ...(tap.csv\n                    ? { csv: { type: tap.csv.type, value: tap.csv.value.toString() } }\n                    : {}),\n                ...(tap.cltv !== undefined ? { cltv: tap.cltv.toString() } : {}),\n                ...(tap.emulator !== undefined ? { emulator: tap.emulator } : {}),\n            },\n            ...(fn.arkadeScript\n                ? {\n                      arkadeScript: {\n                          asm: fn.arkadeScript.asm.map(token),\n                          ...(fn.arkadeScript.witness\n                              ? { witness: fn.arkadeScript.witness.map(token) }\n                              : {}),\n                      },\n                  }\n                : {}),\n        };\n    }\n\n    return JSON.stringify({\n        version: program.version,\n        ...(program.name !== undefined ? { name: program.name } : {}),\n        ...(program.params ? { params: program.params } : {}),\n        functions,\n    });\n}\n\n// --- Persisted contract params ----------------------------------------------\n\n/**\n * Typed parameters of an `\"arkade\"` contract as persisted through the\n * `src/contracts` pipeline. The program serializes as artifact JSON, args as\n * a JSON map (`0x`-hex bytes, decimal-string bigints), keys as hex — so a\n * stored contract row re-derives its script fully offline.\n */\nexport interface ArkadeContractParams {\n    program: Program;\n    args: Record<string, ArkadeParamValue>;\n    serverKey: Uint8Array;\n    userKey?: Uint8Array;\n    emulatorKey?: Uint8Array;\n}\n\nfunction serializeArgValue(v: ArkadeParamValue): string | number {\n    if (v instanceof Uint8Array) return \"0x\" + hex.encode(v);\n    if (typeof v === \"bigint\") return v.toString();\n    return v;\n}\n\nfunction parseArgValue(v: unknown): ArkadeParamValue {\n    if (typeof v === \"number\") return v;\n    if (typeof v === \"string\") {\n        if (v.startsWith(\"0x\")) return hex.decode(v.slice(2));\n        return BigInt(v);\n    }\n    throw new Error(`invalid arkade arg value: ${JSON.stringify(v)}`);\n}\n\n/**\n * Decode a persisted arg by its declared type — no `0x`/BigInt guessing. A\n * bytes-like param whose serialized value lacks the `0x` prefix is an error\n * (the untyped heuristic would silently decode such a value as a bigint).\n */\nfunction parseTypedArgValue(name: string, type: ArkadeArgType, v: unknown): ArkadeParamValue {\n    if (type === \"int\") {\n        if (typeof v === \"number\") return v;\n        if (typeof v === \"string\") return BigInt(v);\n        throw new Error(\n            `arkade contract params: '${name}' expects an int, got ${JSON.stringify(v)}`,\n        );\n    }\n    if (typeof v === \"string\" && v.startsWith(\"0x\")) return hex.decode(v.slice(2));\n    throw new Error(\n        `arkade contract params: '${name}' expects ${type} as 0x-prefixed hex, got ${JSON.stringify(v)}`,\n    );\n}\n\n/** Serialize {@link ArkadeContractParams} to the string map `Contract.params` requires. */\nexport function serializeArkadeContractParams(typed: ArkadeContractParams): Record<string, string> {\n    const args: Record<string, string | number> = {};\n    for (const [k, v] of Object.entries(typed.args)) {\n        args[k] = serializeArgValue(v);\n    }\n    return {\n        program: stringifyArtifact(typed.program),\n        args: JSON.stringify(args),\n        serverKey: hex.encode(typed.serverKey),\n        ...(typed.userKey ? { userKey: hex.encode(typed.userKey) } : {}),\n        ...(typed.emulatorKey ? { emulatorKey: hex.encode(typed.emulatorKey) } : {}),\n    };\n}\n\n/** Parse the string map persisted in `Contract.params` back into typed params. */\nexport function deserializeArkadeContractParams(\n    params: Record<string, string>,\n): ArkadeContractParams {\n    if (!params.program) {\n        throw new Error(\"arkade contract params: missing 'program'\");\n    }\n    if (!params.serverKey) {\n        throw new Error(\"arkade contract params: missing 'serverKey'\");\n    }\n    const program = parseArtifact(JSON.parse(params.program));\n    // Typed param declarations direct how their persisted args decode;\n    // untyped params keep the legacy 0x/BigInt heuristic.\n    const paramTypes = new Map<string, ArkadeArgType>();\n    for (const p of program.params ?? []) {\n        if (typeof p !== \"string\") paramTypes.set(p.name, p.type);\n    }\n    const args: Record<string, ArkadeParamValue> = {};\n    if (params.args) {\n        for (const [k, v] of Object.entries(JSON.parse(params.args))) {\n            const type = paramTypes.get(k);\n            args[k] = type ? parseTypedArgValue(k, type, v) : parseArgValue(v);\n        }\n    }\n    return {\n        program,\n        args,\n        serverKey: hex.decode(params.serverKey),\n        ...(params.userKey ? { userKey: hex.decode(params.userKey) } : {}),\n        ...(params.emulatorKey ? { emulatorKey: hex.decode(params.emulatorKey) } : {}),\n    };\n}\n","import { hex } from \"@scure/base\";\nimport {\n    Contract,\n    ContractHandler,\n    DerivedContractTapscripts,\n    PathContext,\n    PathSelection,\n    TapscriptDeriving,\n} from \"../types\";\nimport { isCltvSatisfied, isCsvSpendable } from \"./helpers\";\nimport { timelockToSequence } from \"../../utils/timelock\";\nimport { extractPubKey, isDescriptor } from \"../../identity/descriptor\";\nimport {\n    ArkadeProgramScript,\n    deserializeArkadeContractParams,\n    resolveTimelockValue,\n    serializeArkadeContractParams,\n    witnessRefToBytes,\n    type ArkadeContractParams,\n    type CompiledProgramFunction,\n} from \"../../arkade/program\";\n\n/**\n * Extract the raw x-only pubkey hex the wallet signs with from the path\n * context, best-effort (mirrors the VHTLC handler's role resolution).\n */\nfunction walletKeyFrom(context: PathContext): string | undefined {\n    const extract = (value: string): string | undefined => {\n        if (!isDescriptor(value)) return value.toLowerCase();\n        try {\n            return extractPubKey(value).toLowerCase();\n        } catch {\n            return undefined;\n        }\n    };\n    if (context.walletDescriptor) {\n        const key = extract(context.walletDescriptor);\n        if (key) return key;\n    }\n    if (context.walletPubKey) {\n        return extract(context.walletPubKey);\n    }\n    return undefined;\n}\n\n/**\n * Resolve a pure-tapscript function's condition witness without call\n * arguments: literals and `$param` references resolve, function-input\n * references cannot (they only exist at call time) — those paths are not\n * generically spendable.\n */\nfunction staticWitness(\n    fn: CompiledProgramFunction,\n    script: ArkadeProgramScript,\n): Uint8Array[] | null {\n    const refs = fn.def.tapscript.witness ?? [];\n    try {\n        return refs.map((w) => witnessRefToBytes(w, {}, script.args));\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Enumerate the spending paths of a compiled program for the given context.\n *\n * Covenant (`arkadeScript`) functions are excluded: they require the\n * co-signing service round-trip and call arguments, so they are spent through\n * `ArkadeContract.functions.<name>(...)`, never through generic wallet path\n * selection. Pure-tapscript functions follow the same conventions as the\n * built-in handlers:\n *\n * - collaborative context → non-timelocked paths (CLTV paths once satisfied);\n * - unilateral context → only paths that do not require the Arkade Service\n *   signer, with CSV/CLTV gates applied (`checkTimelocks: false` skips the\n *   gates, for `getAllSpendingPaths`).\n * - when the context identifies the wallet key and a path has non-server\n *   signers, the wallet must be one of them.\n */\nfunction pathsFor(\n    script: ArkadeProgramScript,\n    context: PathContext,\n    opts: { checkTimelocks: boolean },\n): PathSelection[] {\n    const walletKey = walletKeyFrom(context);\n    const serverHex = hex.encode(script.keys.serverKey);\n    const paths: PathSelection[] = [];\n\n    for (const fn of script.compiled) {\n        if (fn.arkadeScript) continue;\n\n        const witness = staticWitness(fn, script);\n        if (witness === null) continue;\n\n        const signerHexes = fn.signerKeys.map((s) => hex.encode(s));\n        const requiresServer = signerHexes.includes(serverHex);\n        const nonServer = signerHexes.filter((s) => s !== serverHex);\n\n        // If we know who the wallet is and the path needs non-server\n        // signatures, the wallet must be one of those signers.\n        if (walletKey && nonServer.length > 0 && !nonServer.includes(walletKey)) {\n            continue;\n        }\n\n        // `$param` timelock values resolved against the constructor args.\n        const csvDef = fn.def.tapscript.csv;\n        const csv = csvDef\n            ? { type: csvDef.type, value: resolveTimelockValue(csvDef.value, script.args) }\n            : undefined;\n        const cltv =\n            fn.def.tapscript.cltv !== undefined\n                ? resolveTimelockValue(fn.def.tapscript.cltv, script.args)\n                : undefined;\n\n        if (context.collaborative) {\n            // CSV leaves are unilateral-exit paths by convention.\n            if (csv) continue;\n            if (opts.checkTimelocks && cltv !== undefined && !isCltvSatisfied(context, cltv)) {\n                continue;\n            }\n            paths.push({\n                leaf: fn.tapLeafScript,\n                ...(witness.length > 0 ? { extraWitness: witness } : {}),\n            });\n            continue;\n        }\n\n        // Unilateral: the Arkade Service will not co-sign.\n        if (requiresServer) continue;\n        const sequence = csv ? Number(timelockToSequence(csv)) : undefined;\n        if (opts.checkTimelocks && csv && !isCsvSpendable(context, sequence)) continue;\n        if (opts.checkTimelocks && cltv !== undefined && !isCltvSatisfied(context, cltv)) {\n            continue;\n        }\n        paths.push({\n            leaf: fn.tapLeafScript,\n            ...(sequence !== undefined ? { sequence } : {}),\n            ...(witness.length > 0 ? { extraWitness: witness } : {}),\n        });\n    }\n\n    return paths;\n}\n\n/**\n * Generic handler for artifact/program-based Arkade contracts.\n *\n * Persists the full {@link ArkadeContractParams} (program artifact JSON, args,\n * signer keys) as string params, so any contract created via\n * `arkade.contract(program, args)` participates in the standard contract\n * pipeline: ContractManager persistence and validation, watcher events,\n * repository-backed balances, and offline script re-derivation. Rebuild a\n * callable contract from a stored row with `ArkadeContract.fromContract`.\n */\nexport const ArkadeContractHandler: ContractHandler<ArkadeContractParams, ArkadeProgramScript> &\n    TapscriptDeriving<ArkadeProgramScript> = {\n    type: \"arkade\",\n\n    createScript(params: Record<string, string>): ArkadeProgramScript {\n        const typed = this.deserializeParams(params);\n        return new ArkadeProgramScript(typed.program, typed.args, {\n            serverKey: typed.serverKey,\n            userKey: typed.userKey,\n            emulatorKey: typed.emulatorKey,\n        });\n    },\n\n    serializeParams(params: ArkadeContractParams): Record<string, string> {\n        return serializeArkadeContractParams(params);\n    },\n\n    deserializeParams(params: Record<string, string>): ArkadeContractParams {\n        return deserializeArkadeContractParams(params);\n    },\n\n    selectPath(\n        script: ArkadeProgramScript,\n        _contract: Contract,\n        context: PathContext,\n    ): PathSelection | null {\n        const paths = pathsFor(script, context, { checkTimelocks: true });\n        return paths.length > 0 ? paths[0] : null;\n    },\n\n    getAllSpendingPaths(\n        script: ArkadeProgramScript,\n        _contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return pathsFor(script, context, { checkTimelocks: false });\n    },\n\n    getSpendablePaths(\n        script: ArkadeProgramScript,\n        _contract: Contract,\n        context: PathContext,\n    ): PathSelection[] {\n        return pathsFor(script, context, { checkTimelocks: true });\n    },\n\n    /**\n     * Opt-in, never opt-out. A program artifact cannot say whether its funds are\n     * escrowed — an escrow's collaborative cancel leaf is indistinguishable from\n     * an ordinary spend — so the answer is read from the row the registering code\n     * wrote. Anything but an explicit `true` (absent, malformed, or a row written\n     * before this gate existed) is not generically spendable: `createContract` is\n     * first-writer-wins, so a fail-open marker would let one unmarked\n     * registration permanently open the gate for every contract sharing the script.\n     */\n    isGenericallySpendable(contract: Contract): boolean {\n        return contract.metadata?.genericallySpendable === true;\n    },\n\n    /**\n     * Annotation tapscripts for VTXOs locked to this contract: prefer the\n     * collaborative tapscript path (the multisig the Arkade Service co-signs,\n     * mirroring `forfeit()` on the built-in script shapes); covenant-only\n     * programs fall back to their first covenant leaf (its forfeit is\n     * co-signed by the emulator during batch settlement); otherwise the first\n     * declared leaf.\n     */\n    deriveTapscripts(script: ArkadeProgramScript, _contract: Contract): DerivedContractTapscripts {\n        const collaborative = pathsFor(\n            script,\n            { collaborative: true, currentTime: 0 },\n            { checkTimelocks: false },\n        );\n        const leaf =\n            collaborative[0]?.leaf ??\n            script.compiled.find((f) => f.arkadeScript)?.tapLeafScript ??\n            script.compiled[0].tapLeafScript;\n        return {\n            forfeitTapLeafScript: leaf,\n            intentTapLeafScript: leaf,\n            tapTree: script.encode(),\n        };\n    },\n};\n","export { contractHandlers } from \"./registry\";\nexport { DefaultContractHandler } from \"./default\";\nexport type { DefaultContractParams } from \"./default\";\nexport { DelegateContractHandler } from \"./delegate\";\nexport type { DelegateContractParams } from \"./delegate\";\nexport { VHTLCContractHandler } from \"./vhtlc\";\nexport type { VHTLCContractParams } from \"./vhtlc\";\nexport { VHTLCV2ContractHandler } from \"./vhtlcV2\";\nexport type { VHTLCV2ContractParams } from \"./vhtlcV2\";\nexport { BoardingContractHandler } from \"./boarding\";\nexport type { BoardingContractParams } from \"./boarding\";\nexport { ArkadeContractHandler } from \"./arkade\";\n\n// Register built-in handlers\nimport { contractHandlers } from \"./registry\";\nimport { DefaultContractHandler } from \"./default\";\nimport { DelegateContractHandler } from \"./delegate\";\nimport { VHTLCContractHandler } from \"./vhtlc\";\nimport { VHTLCV2ContractHandler } from \"./vhtlcV2\";\nimport { BoardingContractHandler } from \"./boarding\";\nimport { ArkadeContractHandler } from \"./arkade\";\n\ncontractHandlers.register(DefaultContractHandler);\ncontractHandlers.register(DelegateContractHandler);\ncontractHandlers.register(VHTLCContractHandler);\ncontractHandlers.register(VHTLCV2ContractHandler);\ncontractHandlers.register(BoardingContractHandler);\ncontractHandlers.register(ArkadeContractHandler);\n"]}