@arkade-os/sdk 0.4.46 → 0.4.47

package/dist/chunk-RQSA7ADZ.cjs

@@ -0,0 +1,2286 @@
+'use strict';
+
+var chunkL5ND2FJJ_cjs = require('./chunk-L5ND2FJJ.cjs');
+var chunk5BLDMQED_cjs = require('./chunk-5BLDMQED.cjs');
+var base = require('@scure/base');
+var descriptorsScure = require('@bitcoinerlab/descriptors-scure');
+var btcSigner = require('@scure/btc-signer');
+var secp256k1_js = require('@noble/curves/secp256k1.js');
+var utils_js = require('@noble/curves/utils.js');
+
+// src/contracts/handlers/registry.ts
+var ContractHandlerRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Register a contract handler.
+   *
+   * @param handler - The handler to register
+   * @throws If a handler for this type is already registered
+   */
+  register(handler) {
+    if (this.handlers.has(handler.type)) {
+      throw new Error(`Contract handler for type '${handler.type}' is already registered`);
+    }
+    this.handlers.set(handler.type, handler);
+  }
+  /**
+   * Get a handler by type.
+   *
+   * @param type - The contract type
+   * @returns The handler, or undefined if not found
+   */
+  get(type) {
+    return this.handlers.get(type);
+  }
+  /**
+   * Get a handler by type, throwing if not found.
+   *
+   * @param type - The contract type
+   * @returns The handler
+   * @throws If no handler is registered for this type
+   */
+  getOrThrow(type) {
+    const handler = this.get(type);
+    if (!handler) {
+      throw new Error(`No contract handler registered for type '${type}'`);
+    }
+    return handler;
+  }
+  /**
+   * Check if a handler is registered.
+   *
+   * @param type - The contract type
+   */
+  has(type) {
+    return this.handlers.has(type);
+  }
+  /**
+   * Get all registered types.
+   */
+  getRegisteredTypes() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Unregister a handler (mainly for testing).
+   */
+  unregister(type) {
+    return this.handlers.delete(type);
+  }
+  /**
+   * Clear all handlers (mainly for testing).
+   */
+  clear() {
+    this.handlers.clear();
+  }
+};
+var contractHandlers = new ContractHandlerRegistry();
+exports.DefaultVtxo = void 0;
+((DefaultVtxo2) => {
+  class Script3 extends chunkL5ND2FJJ_cjs.VtxoScript {
+    /** Create the default virtual output script with one forfeit path and one exit path. */
+    constructor(options) {
+      const { pubKey, serverPubKey, csvTimelock } = options;
+      const forfeitScript = chunkL5ND2FJJ_cjs.MultisigTapscript.encode({
+        pubkeys: [pubKey, serverPubKey]
+      }).script;
+      const exitScript = chunkL5ND2FJJ_cjs.CSVMultisigTapscript.encode({
+        timelock: csvTimelock,
+        pubkeys: [pubKey]
+      }).script;
+      super([forfeitScript, exitScript]);
+      this.options = options;
+      this.forfeitScript = base.hex.encode(forfeitScript);
+      this.exitScript = base.hex.encode(exitScript);
+    }
+    options;
+    static DEFAULT_TIMELOCK = {
+      value: 144n,
+      type: "blocks"
+    };
+    // 1 day in blocks
+    forfeitScript;
+    exitScript;
+    /** Return the forfeit tapleaf script. */
+    forfeit() {
+      return this.findLeaf(this.forfeitScript);
+    }
+    /** Return the unilateral exit tapleaf script. */
+    exit() {
+      return this.findLeaf(this.exitScript);
+    }
+  }
+  DefaultVtxo2.Script = Script3;
+})(exports.DefaultVtxo || (exports.DefaultVtxo = {}));
+function isMainnetDescriptor(descriptor) {
+  return !descriptor.includes("tpub");
+}
+function descriptorIsOurs(candidate, ourDescriptor, ourXOnlyPubkey) {
+  if (!isDescriptor(candidate)) return false;
+  try {
+    const candidateInfo = descriptorsScure.expand({
+      descriptor: candidate,
+      network: isMainnetDescriptor(candidate) ? descriptorsScure.networks.bitcoin : descriptorsScure.networks.testnet
+    }).expansionMap?.["@0"];
+    if (!candidateInfo) return false;
+    if (candidateInfo.bip32) {
+      const ourBip32 = descriptorsScure.expand({
+        descriptor: ourDescriptor,
+        network: isMainnetDescriptor(ourDescriptor) ? descriptorsScure.networks.bitcoin : descriptorsScure.networks.testnet
+      }).expansionMap?.["@0"]?.bip32;
+      if (!ourBip32) return false;
+      return ourBip32.toBase58() === candidateInfo.bip32.toBase58();
+    }
+    if (candidateInfo.pubkey) {
+      const candidatePub = candidateInfo.pubkey.length === 33 ? candidateInfo.pubkey.subarray(1) : candidateInfo.pubkey;
+      if (candidatePub.length !== ourXOnlyPubkey.length) return false;
+      return base.hex.encode(candidatePub) === base.hex.encode(ourXOnlyPubkey);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function isDescriptor(value) {
+  if (typeof value !== "string") return false;
+  if (!value.startsWith("tr(") || !value.endsWith(")")) return false;
+  return value.length > "tr()".length;
+}
+function normalizeToDescriptor(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error("normalizeToDescriptor: expected a non-empty string value");
+  }
+  if (isDescriptor(value)) {
+    return value;
+  }
+  return `tr(${value})`;
+}
+function extractPubKey(descriptor) {
+  if (!isDescriptor(descriptor)) {
+    return descriptor;
+  }
+  const network = isMainnetDescriptor(descriptor) ? descriptorsScure.networks.bitcoin : descriptorsScure.networks.testnet;
+  const expansion = descriptorsScure.expand({ descriptor, network });
+  if (!expansion.expansionMap) {
+    throw new Error("Cannot extract pubkey from descriptor: expansion failed.");
+  }
+  const key = expansion.expansionMap["@0"];
+  if (key?.bip32) {
+    throw new Error(
+      "Cannot extract pubkey from HD descriptor without derivation. Use DescriptorProvider to derive the key from the xpub."
+    );
+  }
+  if (!key?.pubkey) {
+    throw new Error("Cannot extract pubkey from descriptor: no key found.");
+  }
+  return base.hex.encode(key.pubkey);
+}
+function deriveDescriptorLeafPubKey(descriptor) {
+  const network = isMainnetDescriptor(descriptor) ? descriptorsScure.networks.bitcoin : descriptorsScure.networks.testnet;
+  let expansion;
+  try {
+    expansion = descriptorsScure.expand({ descriptor, network });
+  } catch (e) {
+    throw new Error(
+      `Cannot derive leaf pubkey from descriptor (length=${descriptor.length}): ensure it is materialized (no wildcard) and parsable.`,
+      { cause: e }
+    );
+  }
+  const key = expansion.expansionMap?.["@0"];
+  if (!key?.pubkey) {
+    throw new Error(
+      `Cannot derive leaf pubkey from descriptor (length=${descriptor.length}): parsed but no '@0' pubkey in the expansion map.`
+    );
+  }
+  return key.pubkey;
+}
+
+// src/contracts/constants.ts
+var DEFAULT_PAGE_SIZE = 500;
+
+// src/contracts/handlers/helpers.ts
+function extractRawPubKey(value) {
+  if (!isDescriptor(value)) {
+    return value.toLowerCase();
+  }
+  try {
+    return extractPubKey(value).toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function resolveRole(contract, context) {
+  if (context.role === "sender" || context.role === "receiver") {
+    return context.role;
+  }
+  const senderKey = contract.params.sender ? extractRawPubKey(contract.params.sender) : void 0;
+  const receiverKey = contract.params.receiver ? extractRawPubKey(contract.params.receiver) : void 0;
+  const matchRole = (rawWalletKey) => {
+    if (!rawWalletKey) return void 0;
+    if (senderKey && rawWalletKey === senderKey) {
+      return "sender";
+    }
+    if (receiverKey && rawWalletKey === receiverKey) {
+      return "receiver";
+    }
+    return void 0;
+  };
+  if (context.walletDescriptor) {
+    const walletDescriptorKey = extractRawPubKey(context.walletDescriptor);
+    const matchedRole = matchRole(walletDescriptorKey);
+    if (matchedRole) {
+      return matchedRole;
+    }
+    if (!walletDescriptorKey && context.walletPubKey) {
+      return matchRole(extractRawPubKey(context.walletPubKey));
+    }
+    return void 0;
+  }
+  if (context.walletPubKey) {
+    return matchRole(extractRawPubKey(context.walletPubKey));
+  }
+  return void 0;
+}
+var CLTV_HEIGHT_THRESHOLD = 500000000n;
+function isCltvSatisfied(context, locktime) {
+  if (locktime < CLTV_HEIGHT_THRESHOLD) {
+    if (context.blockHeight === void 0) return false;
+    return BigInt(context.blockHeight) >= locktime;
+  }
+  const currentTimeSec = BigInt(Math.floor(context.currentTime / 1e3));
+  return currentTimeSec >= locktime;
+}
+function isCsvSpendable(context, sequence) {
+  if (sequence === void 0) return true;
+  if (!context.vtxo) return false;
+  const timelock = chunkL5ND2FJJ_cjs.sequenceToTimelock(sequence);
+  if (timelock.type === "blocks") {
+    if (context.blockHeight === void 0 || context.vtxo.status.block_height === void 0) {
+      return false;
+    }
+    return context.blockHeight - context.vtxo.status.block_height >= Number(timelock.value);
+  }
+  if (timelock.type === "seconds") {
+    const blockTime = context.vtxo.status.block_time;
+    if (blockTime === void 0) return false;
+    return context.currentTime / 1e3 - blockTime >= Number(timelock.value);
+  }
+  return false;
+}
+async function detectUsedScripts(indexerProvider, scriptHexes) {
+  const used = /* @__PURE__ */ new Set();
+  if (scriptHexes.length === 0) return used;
+  const remaining = new Set(scriptHexes);
+  let pageIndex = 0;
+  let hasMore = true;
+  while (hasMore && remaining.size > 0) {
+    const { vtxos, page } = await indexerProvider.getVtxos({
+      scripts: scriptHexes,
+      pageIndex,
+      pageSize: DEFAULT_PAGE_SIZE
+    });
+    for (const vtxo of vtxos) {
+      if (remaining.delete(vtxo.script)) used.add(vtxo.script);
+    }
+    hasMore = page ? vtxos.length === DEFAULT_PAGE_SIZE : false;
+    pageIndex++;
+  }
+  return used;
+}
+
+// src/contracts/metadata.ts
+var WALLET_RECEIVE_SOURCE = "wallet-receive";
+
+// src/contracts/handlers/default.ts
+function extractPubKeyBytes(value) {
+  return base.hex.decode(extractPubKey(normalizeToDescriptor(value)));
+}
+var DefaultContractHandler = {
+  type: "default",
+  createScript(params) {
+    const typed = this.deserializeParams(params);
+    return new exports.DefaultVtxo.Script(typed);
+  },
+  serializeParams(params) {
+    return {
+      pubKey: base.hex.encode(params.pubKey),
+      serverPubKey: base.hex.encode(params.serverPubKey),
+      csvTimelock: chunkL5ND2FJJ_cjs.timelockToSequence(params.csvTimelock).toString()
+    };
+  },
+  deserializeParams(params) {
+    const csvTimelock = params.csvTimelock !== void 0 && params.csvTimelock !== "" ? chunkL5ND2FJJ_cjs.sequenceToTimelock(Number(params.csvTimelock)) : exports.DefaultVtxo.Script.DEFAULT_TIMELOCK;
+    return {
+      pubKey: extractPubKeyBytes(params.pubKey),
+      serverPubKey: extractPubKeyBytes(params.serverPubKey),
+      csvTimelock
+    };
+  },
+  selectPath(script, contract, context) {
+    if (context.collaborative) {
+      return { leaf: script.forfeit() };
+    }
+    const sequence = contract.params.csvTimelock ? Number(contract.params.csvTimelock) : void 0;
+    if (!isCsvSpendable(context, sequence)) {
+      return null;
+    }
+    return {
+      leaf: script.exit(),
+      sequence
+    };
+  },
+  getAllSpendingPaths(script, contract, context) {
+    const paths = [];
+    if (context.collaborative) {
+      paths.push({ leaf: script.forfeit() });
+    }
+    const exitPath = { leaf: script.exit() };
+    if (contract.params.csvTimelock) {
+      exitPath.sequence = Number(contract.params.csvTimelock);
+    }
+    paths.push(exitPath);
+    return paths;
+  },
+  getSpendablePaths(script, contract, context) {
+    const paths = [];
+    if (context.collaborative) {
+      paths.push({ leaf: script.forfeit() });
+    }
+    const exitSequence = contract.params.csvTimelock ? Number(contract.params.csvTimelock) : void 0;
+    if (isCsvSpendable(context, exitSequence)) {
+      const exitPath = { leaf: script.exit() };
+      if (exitSequence !== void 0) {
+        exitPath.sequence = exitSequence;
+      }
+      paths.push(exitPath);
+    }
+    return paths;
+  },
+  async discoverAt(index, descriptor, deps) {
+    const pubKey = deriveDescriptorLeafPubKey(descriptor);
+    const signers = [deps.serverPubKey, ...deps.deprecatedSignerPubKeys ?? []];
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    for (const serverPubKey of signers) {
+      for (const csvTimelock of deps.csvTimelocks) {
+        const script = new exports.DefaultVtxo.Script({
+          pubKey,
+          serverPubKey,
+          csvTimelock
+        });
+        const scriptHex = base.hex.encode(script.pkScript);
+        if (seen.has(scriptHex)) continue;
+        seen.add(scriptHex);
+        candidates.push({ serverPubKey, csvTimelock, script, scriptHex });
+      }
+    }
+    const used = await detectUsedScripts(
+      deps.indexerProvider,
+      candidates.map((c) => c.scriptHex)
+    );
+    const out = [];
+    for (const c of candidates) {
+      if (!used.has(c.scriptHex)) continue;
+      out.push({
+        type: "default",
+        params: {
+          pubKey: base.hex.encode(pubKey),
+          serverPubKey: base.hex.encode(c.serverPubKey),
+          csvTimelock: chunkL5ND2FJJ_cjs.timelockToSequence(c.csvTimelock).toString()
+        },
+        script: c.scriptHex,
+        address: c.script.address(deps.network.hrp, c.serverPubKey).encode(),
+        ...index > 0 ? {
+          metadata: {
+            source: WALLET_RECEIVE_SOURCE,
+            signingDescriptor: descriptor
+          }
+        } : {}
+      });
+    }
+    return out;
+  }
+};
+exports.DelegateVtxo = void 0;
+((DelegateVtxo2) => {
+  class Script3 extends chunkL5ND2FJJ_cjs.VtxoScript {
+    /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */
+    constructor(options) {
+      const defaultVtxo = new exports.DefaultVtxo.Script(options);
+      const { delegatePubKey, pubKey, serverPubKey } = options;
+      const delegateScript = chunkL5ND2FJJ_cjs.MultisigTapscript.encode({
+        pubkeys: [pubKey, delegatePubKey, serverPubKey]
+      }).script;
+      super([...defaultVtxo.scripts, delegateScript]);
+      this.options = options;
+      this.defaultVtxo = defaultVtxo;
+      this.delegateScript = base.hex.encode(delegateScript);
+    }
+    options;
+    defaultVtxo;
+    delegateScript;
+    /** Return the forfeit tapleaf script. */
+    forfeit() {
+      return this.findLeaf(this.defaultVtxo.forfeitScript);
+    }
+    /** Return the unilateral exit tapleaf script. */
+    exit() {
+      return this.findLeaf(this.defaultVtxo.exitScript);
+    }
+    /** Return the delegate tapleaf script. */
+    delegate() {
+      return this.findLeaf(this.delegateScript);
+    }
+  }
+  DelegateVtxo2.Script = Script3;
+})(exports.DelegateVtxo || (exports.DelegateVtxo = {}));
+
+// src/contracts/handlers/delegate.ts
+var DelegateContractHandler = {
+  type: "delegate",
+  createScript(params) {
+    const typed = this.deserializeParams(params);
+    return new exports.DelegateVtxo.Script(typed);
+  },
+  serializeParams(params) {
+    return {
+      pubKey: base.hex.encode(params.pubKey),
+      serverPubKey: base.hex.encode(params.serverPubKey),
+      delegatePubKey: base.hex.encode(params.delegatePubKey),
+      csvTimelock: chunkL5ND2FJJ_cjs.timelockToSequence(params.csvTimelock).toString()
+    };
+  },
+  deserializeParams(params) {
+    const csvTimelock = chunkL5ND2FJJ_cjs.sequenceToTimelock(Number(params.csvTimelock));
+    return {
+      pubKey: base.hex.decode(params.pubKey),
+      serverPubKey: base.hex.decode(params.serverPubKey),
+      delegatePubKey: base.hex.decode(params.delegatePubKey),
+      csvTimelock
+    };
+  },
+  selectPath(script, contract, context) {
+    if (context.collaborative) {
+      return { leaf: script.forfeit() };
+    }
+    const sequence = contract.params.csvTimelock ? Number(contract.params.csvTimelock) : void 0;
+    if (!isCsvSpendable(context, sequence)) {
+      return null;
+    }
+    return {
+      leaf: script.exit(),
+      sequence
+    };
+  },
+  getAllSpendingPaths(script, contract, context) {
+    const paths = [];
+    if (context.collaborative) {
+      paths.push({ leaf: script.forfeit() });
+    }
+    const exitPath = { leaf: script.exit() };
+    if (contract.params.csvTimelock) {
+      exitPath.sequence = Number(contract.params.csvTimelock);
+    }
+    paths.push(exitPath);
+    if (context.collaborative) {
+      paths.push({ leaf: script.delegate() });
+    }
+    return paths;
+  },
+  getSpendablePaths(script, contract, context) {
+    const paths = [];
+    if (context.collaborative) {
+      paths.push({ leaf: script.forfeit() });
+    }
+    const exitSequence = contract.params.csvTimelock ? Number(contract.params.csvTimelock) : void 0;
+    if (isCsvSpendable(context, exitSequence)) {
+      const exitPath = { leaf: script.exit() };
+      if (exitSequence !== void 0) {
+        exitPath.sequence = exitSequence;
+      }
+      paths.push(exitPath);
+    }
+    return paths;
+  },
+  async discoverAt(index, descriptor, deps) {
+    if (!deps.delegatePubKey) return [];
+    const pubKey = deriveDescriptorLeafPubKey(descriptor);
+    const signers = [deps.serverPubKey, ...deps.deprecatedSignerPubKeys ?? []];
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    for (const serverPubKey of signers) {
+      for (const csvTimelock of deps.csvTimelocks) {
+        const script = new exports.DelegateVtxo.Script({
+          pubKey,
+          serverPubKey,
+          delegatePubKey: deps.delegatePubKey,
+          csvTimelock
+        });
+        const scriptHex = base.hex.encode(script.pkScript);
+        if (seen.has(scriptHex)) continue;
+        seen.add(scriptHex);
+        candidates.push({ serverPubKey, csvTimelock, script, scriptHex });
+      }
+    }
+    const used = await detectUsedScripts(
+      deps.indexerProvider,
+      candidates.map((c) => c.scriptHex)
+    );
+    const out = [];
+    for (const c of candidates) {
+      if (!used.has(c.scriptHex)) continue;
+      out.push({
+        type: "delegate",
+        params: {
+          pubKey: base.hex.encode(pubKey),
+          serverPubKey: base.hex.encode(c.serverPubKey),
+          delegatePubKey: base.hex.encode(deps.delegatePubKey),
+          csvTimelock: chunkL5ND2FJJ_cjs.timelockToSequence(c.csvTimelock).toString()
+        },
+        script: c.scriptHex,
+        address: c.script.address(deps.network.hrp, c.serverPubKey).encode(),
+        ...index > 0 ? {
+          metadata: {
+            source: WALLET_RECEIVE_SOURCE,
+            signingDescriptor: descriptor
+          }
+        } : {}
+      });
+    }
+    return out;
+  }
+};
+exports.VHTLC = void 0;
+((VHTLC2) => {
+  class Script3 extends chunkL5ND2FJJ_cjs.VtxoScript {
+    /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
+    constructor(options) {
+      validateOptions(options);
+      const {
+        sender,
+        receiver,
+        server,
+        preimageHash,
+        refundLocktime,
+        unilateralClaimDelay,
+        unilateralRefundDelay,
+        unilateralRefundWithoutReceiverDelay
+      } = options;
+      const conditionScript = preimageConditionScript(preimageHash);
+      const claimScript = chunkL5ND2FJJ_cjs.ConditionMultisigTapscript.encode({
+        conditionScript,
+        pubkeys: [receiver, server]
+      }).script;
+      const refundScript = chunkL5ND2FJJ_cjs.MultisigTapscript.encode({
+        pubkeys: [sender, receiver, server]
+      }).script;
+      const refundWithoutReceiverScript = chunkL5ND2FJJ_cjs.CLTVMultisigTapscript.encode({
+        absoluteTimelock: refundLocktime,
+        pubkeys: [sender, server]
+      }).script;
+      const unilateralClaimScript = chunkL5ND2FJJ_cjs.ConditionCSVMultisigTapscript.encode({
+        conditionScript,
+        timelock: unilateralClaimDelay,
+        pubkeys: [receiver]
+      }).script;
+      const unilateralRefundScript = chunkL5ND2FJJ_cjs.CSVMultisigTapscript.encode({
+        timelock: unilateralRefundDelay,
+        pubkeys: [sender, receiver]
+      }).script;
+      const unilateralRefundWithoutReceiverScript = chunkL5ND2FJJ_cjs.CSVMultisigTapscript.encode({
+        timelock: unilateralRefundWithoutReceiverDelay,
+        pubkeys: [sender]
+      }).script;
+      super([
+        claimScript,
+        refundScript,
+        refundWithoutReceiverScript,
+        unilateralClaimScript,
+        unilateralRefundScript,
+        unilateralRefundWithoutReceiverScript
+      ]);
+      this.options = options;
+      this.claimScript = base.hex.encode(claimScript);
+      this.refundScript = base.hex.encode(refundScript);
+      this.refundWithoutReceiverScript = base.hex.encode(refundWithoutReceiverScript);
+      this.unilateralClaimScript = base.hex.encode(unilateralClaimScript);
+      this.unilateralRefundScript = base.hex.encode(unilateralRefundScript);
+      this.unilateralRefundWithoutReceiverScript = base.hex.encode(
+        unilateralRefundWithoutReceiverScript
+      );
+    }
+    options;
+    claimScript;
+    refundScript;
+    refundWithoutReceiverScript;
+    unilateralClaimScript;
+    unilateralRefundScript;
+    unilateralRefundWithoutReceiverScript;
+    /** Return the collaborative claim tapleaf script. */
+    claim() {
+      return this.findLeaf(this.claimScript);
+    }
+    /** Return the collaborative refund tapleaf script. */
+    refund() {
+      return this.findLeaf(this.refundScript);
+    }
+    /** Return the refund-without-receiver tapleaf script. */
+    refundWithoutReceiver() {
+      return this.findLeaf(this.refundWithoutReceiverScript);
+    }
+    /** Return the unilateral claim tapleaf script. */
+    unilateralClaim() {
+      return this.findLeaf(this.unilateralClaimScript);
+    }
+    /** Return the unilateral refund tapleaf script. */
+    unilateralRefund() {
+      return this.findLeaf(this.unilateralRefundScript);
+    }
+    /** Return the unilateral refund-without-receiver tapleaf script. */
+    unilateralRefundWithoutReceiver() {
+      return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
+    }
+  }
+  VHTLC2.Script = Script3;
+  function validateOptions(options) {
+    const {
+      sender,
+      receiver,
+      server,
+      preimageHash,
+      refundLocktime,
+      unilateralClaimDelay,
+      unilateralRefundDelay,
+      unilateralRefundWithoutReceiverDelay
+    } = options;
+    if (!preimageHash || preimageHash.length !== 20) {
+      throw new Error("preimage hash must be 20 bytes");
+    }
+    if (!receiver || receiver.length !== 32) {
+      throw new Error("Invalid public key length (receiver)");
+    }
+    if (!sender || sender.length !== 32) {
+      throw new Error("Invalid public key length (sender)");
+    }
+    if (!server || server.length !== 32) {
+      throw new Error("Invalid public key length (server)");
+    }
+    if (typeof refundLocktime !== "bigint" || refundLocktime <= 0n) {
+      throw new Error("refund locktime must be greater than 0");
+    }
+    if (!unilateralClaimDelay || typeof unilateralClaimDelay.value !== "bigint" || unilateralClaimDelay.value <= 0n) {
+      throw new Error("unilateral claim delay must greater than 0");
+    }
+    if (unilateralClaimDelay.type === "seconds" && unilateralClaimDelay.value % 512n !== 0n) {
+      throw new Error("seconds timelock must be multiple of 512");
+    }
+    if (unilateralClaimDelay.type === "seconds" && unilateralClaimDelay.value < 512n) {
+      throw new Error("seconds timelock must be greater or equal to 512");
+    }
+    if (!unilateralRefundDelay || typeof unilateralRefundDelay.value !== "bigint" || unilateralRefundDelay.value <= 0n) {
+      throw new Error("unilateral refund delay must greater than 0");
+    }
+    if (unilateralRefundDelay.type === "seconds" && unilateralRefundDelay.value % 512n !== 0n) {
+      throw new Error("seconds timelock must be multiple of 512");
+    }
+    if (unilateralRefundDelay.type === "seconds" && unilateralRefundDelay.value < 512n) {
+      throw new Error("seconds timelock must be greater or equal to 512");
+    }
+    if (!unilateralRefundWithoutReceiverDelay || typeof unilateralRefundWithoutReceiverDelay.value !== "bigint" || unilateralRefundWithoutReceiverDelay.value <= 0n) {
+      throw new Error("unilateral refund without receiver delay must greater than 0");
+    }
+    if (unilateralRefundWithoutReceiverDelay.type === "seconds" && unilateralRefundWithoutReceiverDelay.value % 512n !== 0n) {
+      throw new Error("seconds timelock must be multiple of 512");
+    }
+    if (unilateralRefundWithoutReceiverDelay.type === "seconds" && unilateralRefundWithoutReceiverDelay.value < 512n) {
+      throw new Error("seconds timelock must be greater or equal to 512");
+    }
+  }
+})(exports.VHTLC || (exports.VHTLC = {}));
+function preimageConditionScript(preimageHash) {
+  return btcSigner.Script.encode(["HASH160", preimageHash, "EQUAL"]);
+}
+
+// src/contracts/handlers/vhtlc.ts
+var VHTLCContractHandler = {
+  type: "vhtlc",
+  createScript(params) {
+    const typed = this.deserializeParams(params);
+    return new exports.VHTLC.Script(typed);
+  },
+  serializeParams(params) {
+    return {
+      sender: base.hex.encode(params.sender),
+      receiver: base.hex.encode(params.receiver),
+      server: base.hex.encode(params.server),
+      hash: base.hex.encode(params.preimageHash),
+      refundLocktime: params.refundLocktime.toString(),
+      claimDelay: chunkL5ND2FJJ_cjs.timelockToSequence(params.unilateralClaimDelay).toString(),
+      refundDelay: chunkL5ND2FJJ_cjs.timelockToSequence(params.unilateralRefundDelay).toString(),
+      refundNoReceiverDelay: chunkL5ND2FJJ_cjs.timelockToSequence(
+        params.unilateralRefundWithoutReceiverDelay
+      ).toString()
+    };
+  },
+  deserializeParams(params) {
+    return {
+      sender: base.hex.decode(params.sender),
+      receiver: base.hex.decode(params.receiver),
+      server: base.hex.decode(params.server),
+      preimageHash: base.hex.decode(params.hash),
+      refundLocktime: BigInt(params.refundLocktime),
+      unilateralClaimDelay: chunkL5ND2FJJ_cjs.sequenceToTimelock(Number(params.claimDelay)),
+      unilateralRefundDelay: chunkL5ND2FJJ_cjs.sequenceToTimelock(Number(params.refundDelay)),
+      unilateralRefundWithoutReceiverDelay: chunkL5ND2FJJ_cjs.sequenceToTimelock(
+        Number(params.refundNoReceiverDelay)
+      )
+    };
+  },
+  /**
+   * Select spending path based on context.
+   *
+   * Role is determined from `context.role` or by matching
+   * `context.walletDescriptor` (preferred) / `context.walletPubKey`
+   * against sender/receiver in contract params.
+   */
+  selectPath(script, contract, context) {
+    const role = resolveRole(contract, context);
+    const preimage = contract.params?.preimage;
+    const refundLocktime = BigInt(contract.params.refundLocktime);
+    if (!role) {
+      return null;
+    }
+    if (context.collaborative) {
+      if (role === "receiver" && preimage) {
+        return {
+          leaf: script.claim(),
+          extraWitness: [base.hex.decode(preimage)]
+        };
+      }
+      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
+        return {
+          leaf: script.refundWithoutReceiver()
+        };
+      }
+      return null;
+    }
+    if (role === "receiver" && preimage) {
+      const sequence = Number(contract.params.claimDelay);
+      if (!isCsvSpendable(context, sequence)) return null;
+      return {
+        leaf: script.unilateralClaim(),
+        extraWitness: [base.hex.decode(preimage)],
+        sequence
+      };
+    }
+    if (role === "sender") {
+      const sequence = Number(contract.params.refundNoReceiverDelay);
+      if (!isCsvSpendable(context, sequence)) return null;
+      return {
+        leaf: script.unilateralRefundWithoutReceiver(),
+        sequence
+      };
+    }
+    return null;
+  },
+  /**
+   * Get all possible spending paths (no timelock checks).
+   *
+   * Role is determined from `context.role` or by matching
+   * `context.walletDescriptor` (preferred) / `context.walletPubKey`
+   * against sender/receiver in contract params.
+   */
+  getAllSpendingPaths(script, contract, context) {
+    const role = resolveRole(contract, context);
+    const paths = [];
+    if (!role) {
+      return paths;
+    }
+    const preimage = contract.params?.preimage;
+    if (context.collaborative) {
+      if (role === "receiver" && preimage) {
+        paths.push({
+          leaf: script.claim(),
+          extraWitness: [base.hex.decode(preimage)]
+        });
+      }
+      if (role === "sender") {
+        paths.push({
+          leaf: script.refundWithoutReceiver()
+        });
+      }
+    } else {
+      if (role === "receiver" && preimage) {
+        const sequence = Number(contract.params.claimDelay);
+        paths.push({
+          leaf: script.unilateralClaim(),
+          extraWitness: [base.hex.decode(preimage)],
+          sequence
+        });
+      }
+      if (role === "sender") {
+        const sequence = Number(contract.params.refundNoReceiverDelay);
+        paths.push({
+          leaf: script.unilateralRefundWithoutReceiver(),
+          sequence
+        });
+      }
+    }
+    return paths;
+  },
+  getSpendablePaths(script, contract, context) {
+    const role = resolveRole(contract, context);
+    const paths = [];
+    if (!role) {
+      return paths;
+    }
+    const preimage = contract.params?.preimage;
+    const refundLocktime = BigInt(contract.params.refundLocktime);
+    if (context.collaborative) {
+      if (role === "receiver" && preimage) {
+        paths.push({
+          leaf: script.claim(),
+          extraWitness: [base.hex.decode(preimage)]
+        });
+      }
+      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
+        paths.push({
+          leaf: script.refundWithoutReceiver()
+        });
+      }
+      return paths;
+    }
+    if (role === "receiver" && preimage) {
+      const sequence = Number(contract.params.claimDelay);
+      if (isCsvSpendable(context, sequence)) {
+        paths.push({
+          leaf: script.unilateralClaim(),
+          extraWitness: [base.hex.decode(preimage)],
+          sequence
+        });
+      }
+    }
+    if (role === "sender") {
+      const sequence = Number(contract.params.refundNoReceiverDelay);
+      if (isCsvSpendable(context, sequence)) {
+        paths.push({
+          leaf: script.unilateralRefundWithoutReceiver(),
+          sequence
+        });
+      }
+    }
+    return paths;
+  }
+};
+var BoardingContractHandler = {
+  type: "boarding",
+  createScript(params) {
+    return DefaultContractHandler.createScript(params);
+  },
+  serializeParams(params) {
+    return DefaultContractHandler.serializeParams(params);
+  },
+  deserializeParams(params) {
+    return DefaultContractHandler.deserializeParams(params);
+  },
+  selectPath(script, contract, context) {
+    return DefaultContractHandler.selectPath(script, contract, context);
+  },
+  getAllSpendingPaths(script, contract, context) {
+    return DefaultContractHandler.getAllSpendingPaths(script, contract, context);
+  },
+  getSpendablePaths(script, contract, context) {
+    return DefaultContractHandler.getSpendablePaths(script, contract, context);
+  },
+  /**
+   * Probe the on-chain UTXO set for a boarding output at this HD index.
+   *
+   * Boarding's source of truth is the **current** on-chain coin set
+   * (`OnchainProvider.getCoins`), not the Ark indexer: a boarded (spent)
+   * boarding output becomes an L2 VTXO at the receive index, so the
+   * indexer probe already keeps the gap window open for it; only an
+   * *unspent* boarding output needs the on-chain probe (see plan §2).
+   *
+   * No-ops (returns `[]`) when boarding discovery is not plumbed — i.e.
+   * `deps.boardingTimelock` or `deps.onchainNetwork` is absent — so the
+   * scanner unit harness (which sets neither) is unaffected.
+   *
+   * Always emits `type: "boarding"`, even in the degenerate equal-delay case
+   * where the boarding script is byte-identical to a `default` script at this
+   * index (`boardingExitDelay === unilateralExitDelay`). The collision is no
+   * longer pre-judged in discovery; it is tolerated FIRST-WINS at the
+   * persistence layer ({@link ContractManager.upsertContract}). `deps.csvTimelocks`
+   * is intentionally not read here.
+   */
+  async discoverAt(index, descriptor, deps) {
+    if (!deps.boardingTimelock || !deps.onchainNetwork) return [];
+    const pubKey = deriveDescriptorLeafPubKey(descriptor);
+    const script = new exports.DefaultVtxo.Script({
+      pubKey,
+      serverPubKey: deps.serverPubKey,
+      csvTimelock: deps.boardingTimelock
+    });
+    const onchainAddress = script.onchainAddress(deps.onchainNetwork);
+    const coins = await deps.onchainProvider.getCoins(onchainAddress);
+    if (coins.length === 0) return [];
+    const scriptHex = base.hex.encode(script.pkScript);
+    const boardingSeq = chunkL5ND2FJJ_cjs.timelockToSequence(deps.boardingTimelock);
+    return [
+      {
+        type: "boarding",
+        params: {
+          pubKey: base.hex.encode(pubKey),
+          serverPubKey: base.hex.encode(deps.serverPubKey),
+          csvTimelock: boardingSeq.toString()
+        },
+        script: scriptHex,
+        // The persisted row's `address` is the *Ark* address (not the
+        // on-chain P2TR), matching the row registered at init so the
+        // ContractWatcher keeps monitoring the same L2 script and the
+        // VTXO repository bucket lines up (plan §6-I.4). The P2TR is
+        // recomputed from params only for the `getCoins` probe.
+        address: script.address(deps.network.hrp, deps.serverPubKey).encode(),
+        // Tag rotated rows (index > 0) so boot resolution can find the
+        // newest boarding address and descriptor-aware signing can
+        // recover the per-index key (plan §6-II/§6-III.3). The index-0
+        // baseline stays untagged, matching `default`/`delegate`.
+        ...index > 0 ? {
+          metadata: {
+            source: WALLET_RECEIVE_SOURCE,
+            signingDescriptor: descriptor
+          }
+        } : {}
+      }
+    ];
+  }
+};
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++)
+    if (a[i] !== b[i])
+      return false;
+  return true;
+}
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isNum(num) {
+  return Number.isSafeInteger(num);
+}
+var Bitset = {
+  BITS: 32,
+  FULL_MASK: -1 >>> 0,
+  // 1<<32 will overflow
+  len: (len) => Math.ceil(len / 32),
+  create: (len) => new Uint32Array(Bitset.len(len)),
+  clean: (bs) => bs.fill(0),
+  debug: (bs) => Array.from(bs).map((i) => (i >>> 0).toString(2).padStart(32, "0")),
+  checkLen: (bs, len) => {
+    if (Bitset.len(len) === bs.length)
+      return;
+    throw new Error(`wrong length=${bs.length}. Expected: ${Bitset.len(len)}`);
+  },
+  chunkLen: (bsLen, pos, len) => {
+    if (pos < 0)
+      throw new Error(`wrong pos=${pos}`);
+    if (pos + len > bsLen)
+      throw new Error(`wrong range=${pos}/${len} of ${bsLen}`);
+  },
+  set: (bs, chunk, value, allowRewrite = true) => {
+    if (!allowRewrite && (bs[chunk] & value) !== 0)
+      return false;
+    bs[chunk] |= value;
+    return true;
+  },
+  pos: (pos, i) => ({
+    chunk: Math.floor((pos + i) / 32),
+    mask: 1 << 32 - (pos + i) % 32 - 1
+  }),
+  indices: (bs, len, invert = false) => {
+    Bitset.checkLen(bs, len);
+    const { FULL_MASK, BITS } = Bitset;
+    const left = BITS - len % BITS;
+    const lastMask = left ? FULL_MASK >>> left << left : FULL_MASK;
+    const res = [];
+    for (let i = 0; i < bs.length; i++) {
+      let c = bs[i];
+      if (invert)
+        c = ~c;
+      if (i === bs.length - 1)
+        c &= lastMask;
+      if (c === 0)
+        continue;
+      for (let j = 0; j < BITS; j++) {
+        const m = 1 << BITS - j - 1;
+        if (c & m)
+          res.push(i * BITS + j);
+      }
+    }
+    return res;
+  },
+  range: (arr) => {
+    const res = [];
+    let cur;
+    for (const i of arr) {
+      if (cur === void 0 || i !== cur.pos + cur.length)
+        res.push(cur = { pos: i, length: 1 });
+      else
+        cur.length += 1;
+    }
+    return res;
+  },
+  rangeDebug: (bs, len, invert = false) => `[${Bitset.range(Bitset.indices(bs, len, invert)).map((i) => `(${i.pos}/${i.length})`).join(", ")}]`,
+  setRange: (bs, bsLen, pos, len, allowRewrite = true) => {
+    Bitset.chunkLen(bsLen, pos, len);
+    const { FULL_MASK, BITS } = Bitset;
+    const first = pos % BITS ? Math.floor(pos / BITS) : void 0;
+    const lastPos = pos + len;
+    const last = lastPos % BITS ? Math.floor(lastPos / BITS) : void 0;
+    if (first !== void 0 && first === last)
+      return Bitset.set(bs, first, FULL_MASK >>> BITS - len << BITS - len - pos, allowRewrite);
+    if (first !== void 0) {
+      if (!Bitset.set(bs, first, FULL_MASK >>> pos % BITS, allowRewrite))
+        return false;
+    }
+    const start = first !== void 0 ? first + 1 : pos / BITS;
+    const end = last !== void 0 ? last : lastPos / BITS;
+    for (let i = start; i < end; i++)
+      if (!Bitset.set(bs, i, FULL_MASK, allowRewrite))
+        return false;
+    if (last !== void 0 && first !== last) {
+      if (!Bitset.set(bs, last, FULL_MASK << BITS - lastPos % BITS, allowRewrite))
+        return false;
+    }
+    return true;
+  }
+};
+var Path = {
+  /**
+   * Internal method for handling stack of paths (debug, errors, dynamic fields via path)
+   * This is looks ugly (callback), but allows us to force stack cleaning by construction (.pop always after function).
+   * Also, this makes impossible:
+   * - pushing field when stack is empty
+   * - pushing field inside of field (real bug)
+   * NOTE: we don't want to do '.pop' on error!
+   */
+  pushObj: (stack, obj, objFn) => {
+    const last = { obj };
+    stack.push(last);
+    objFn((field, fieldFn) => {
+      last.field = field;
+      fieldFn();
+      last.field = void 0;
+    });
+    stack.pop();
+  },
+  path: (stack) => {
+    const res = [];
+    for (const i of stack)
+      if (i.field !== void 0)
+        res.push(i.field);
+    return res.join("/");
+  },
+  err: (name, stack, msg) => {
+    const err = new Error(`${name}(${Path.path(stack)}): ${typeof msg === "string" ? msg : msg.message}`);
+    if (msg instanceof Error && msg.stack)
+      err.stack = msg.stack;
+    return err;
+  },
+  resolve: (stack, path) => {
+    const parts = path.split("/");
+    const objPath = stack.map((i2) => i2.obj);
+    let i = 0;
+    for (; i < parts.length; i++) {
+      if (parts[i] === "..")
+        objPath.pop();
+      else
+        break;
+    }
+    let cur = objPath.pop();
+    for (; i < parts.length; i++) {
+      if (!cur || cur[parts[i]] === void 0)
+        return void 0;
+      cur = cur[parts[i]];
+    }
+    return cur;
+  }
+};
+var _Reader = class __Reader {
+  pos = 0;
+  data;
+  opts;
+  stack;
+  parent;
+  parentOffset;
+  bitBuf = 0;
+  bitPos = 0;
+  bs;
+  // bitset
+  view;
+  constructor(data, opts = {}, stack = [], parent = void 0, parentOffset = 0) {
+    this.data = data;
+    this.opts = opts;
+    this.stack = stack;
+    this.parent = parent;
+    this.parentOffset = parentOffset;
+    this.view = createView(data);
+  }
+  /** Internal method for pointers. */
+  _enablePointers() {
+    if (this.parent)
+      return this.parent._enablePointers();
+    if (this.bs)
+      return;
+    this.bs = Bitset.create(this.data.length);
+    Bitset.setRange(this.bs, this.data.length, 0, this.pos, this.opts.allowMultipleReads);
+  }
+  markBytesBS(pos, len) {
+    if (this.parent)
+      return this.parent.markBytesBS(this.parentOffset + pos, len);
+    if (!len)
+      return true;
+    if (!this.bs)
+      return true;
+    return Bitset.setRange(this.bs, this.data.length, pos, len, false);
+  }
+  markBytes(len) {
+    const pos = this.pos;
+    this.pos += len;
+    const res = this.markBytesBS(pos, len);
+    if (!this.opts.allowMultipleReads && !res)
+      throw this.err(`multiple read pos=${this.pos} len=${len}`);
+    return res;
+  }
+  pushObj(obj, objFn) {
+    return Path.pushObj(this.stack, obj, objFn);
+  }
+  readView(n, fn) {
+    if (!Number.isFinite(n))
+      throw this.err(`readView: wrong length=${n}`);
+    if (this.pos + n > this.data.length)
+      throw this.err("readView: Unexpected end of buffer");
+    const res = fn(this.view, this.pos);
+    this.markBytes(n);
+    return res;
+  }
+  // read bytes by absolute offset
+  absBytes(n) {
+    if (n > this.data.length)
+      throw new Error("Unexpected end of buffer");
+    return this.data.subarray(n);
+  }
+  finish() {
+    if (this.opts.allowUnreadBytes)
+      return;
+    if (this.bitPos) {
+      throw this.err(`${this.bitPos} bits left after unpack: ${base.hex.encode(this.data.slice(this.pos))}`);
+    }
+    if (this.bs && !this.parent) {
+      const notRead = Bitset.indices(this.bs, this.data.length, true);
+      if (notRead.length) {
+        const formatted = Bitset.range(notRead).map(({ pos, length }) => `(${pos}/${length})[${base.hex.encode(this.data.subarray(pos, pos + length))}]`).join(", ");
+        throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);
+      } else
+        return;
+    }
+    if (!this.isEnd()) {
+      throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${base.hex.encode(this.data.slice(this.pos))}`);
+    }
+  }
+  // User methods
+  err(msg) {
+    return Path.err("Reader", this.stack, msg);
+  }
+  offsetReader(n) {
+    if (n > this.data.length)
+      throw this.err("offsetReader: Unexpected end of buffer");
+    return new __Reader(this.absBytes(n), this.opts, this.stack, this, n);
+  }
+  bytes(n, peek = false) {
+    if (this.bitPos)
+      throw this.err("readBytes: bitPos not empty");
+    if (!Number.isFinite(n))
+      throw this.err(`readBytes: wrong length=${n}`);
+    if (this.pos + n > this.data.length)
+      throw this.err("readBytes: Unexpected end of buffer");
+    const slice = this.data.subarray(this.pos, this.pos + n);
+    if (!peek)
+      this.markBytes(n);
+    return slice;
+  }
+  byte(peek = false) {
+    if (this.bitPos)
+      throw this.err("readByte: bitPos not empty");
+    if (this.pos + 1 > this.data.length)
+      throw this.err("readBytes: Unexpected end of buffer");
+    const data = this.data[this.pos];
+    if (!peek)
+      this.markBytes(1);
+    return data;
+  }
+  get leftBytes() {
+    return this.data.length - this.pos;
+  }
+  get totalBytes() {
+    return this.data.length;
+  }
+  isEnd() {
+    return this.pos >= this.data.length && !this.bitPos;
+  }
+  // bits are read in BE mode (left to right): (0b1000_0000).readBits(1) == 1
+  bits(bits) {
+    if (bits > 32)
+      throw this.err("BitReader: cannot read more than 32 bits in single call");
+    let out = 0;
+    while (bits) {
+      if (!this.bitPos) {
+        this.bitBuf = this.byte();
+        this.bitPos = 8;
+      }
+      const take = Math.min(bits, this.bitPos);
+      this.bitPos -= take;
+      out = out << take | this.bitBuf >> this.bitPos & 2 ** take - 1;
+      this.bitBuf &= 2 ** this.bitPos - 1;
+      bits -= take;
+    }
+    return out >>> 0;
+  }
+  find(needle, pos = this.pos) {
+    if (!isBytes(needle))
+      throw this.err(`find: needle is not bytes! ${needle}`);
+    if (this.bitPos)
+      throw this.err("findByte: bitPos not empty");
+    if (!needle.length)
+      throw this.err(`find: needle is empty`);
+    for (let idx = pos; (idx = this.data.indexOf(needle[0], idx)) !== -1; idx++) {
+      if (idx === -1)
+        return;
+      const leftBytes = this.data.length - idx;
+      if (leftBytes < needle.length)
+        return;
+      if (equalBytes(needle, this.data.subarray(idx, idx + needle.length)))
+        return idx;
+    }
+    return;
+  }
+};
+var _Writer = class {
+  pos = 0;
+  stack;
+  // We could have a single buffer here and re-alloc it with
+  // x1.5-2 size each time it full, but it will be slower:
+  // basic/encode bench: 395ns -> 560ns
+  buffers = [];
+  ptrs = [];
+  bitBuf = 0;
+  bitPos = 0;
+  viewBuf = new Uint8Array(8);
+  view;
+  finished = false;
+  constructor(stack = []) {
+    this.stack = stack;
+    this.view = createView(this.viewBuf);
+  }
+  pushObj(obj, objFn) {
+    return Path.pushObj(this.stack, obj, objFn);
+  }
+  writeView(len, fn) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (!isNum(len) || len > 8)
+      throw new Error(`wrong writeView length=${len}`);
+    fn(this.view);
+    this.bytes(this.viewBuf.slice(0, len));
+    this.viewBuf.fill(0);
+  }
+  // User methods
+  err(msg) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    return Path.err("Reader", this.stack, msg);
+  }
+  bytes(b) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("writeBytes: ends with non-empty bit buffer");
+    this.buffers.push(b);
+    this.pos += b.length;
+  }
+  byte(b) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("writeByte: ends with non-empty bit buffer");
+    this.buffers.push(new Uint8Array([b]));
+    this.pos++;
+  }
+  finish(clean = true) {
+    if (this.finished)
+      throw this.err("buffer: finished");
+    if (this.bitPos)
+      throw this.err("buffer: ends with non-empty bit buffer");
+    const buffers = this.buffers.concat(this.ptrs.map((i) => i.buffer));
+    const sum = buffers.map((b) => b.length).reduce((a, b) => a + b, 0);
+    const buf = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < buffers.length; i++) {
+      const a = buffers[i];
+      buf.set(a, pad);
+      pad += a.length;
+    }
+    for (let pos = this.pos, i = 0; i < this.ptrs.length; i++) {
+      const ptr = this.ptrs[i];
+      buf.set(ptr.ptr.encode(pos), ptr.pos);
+      pos += ptr.buffer.length;
+    }
+    if (clean) {
+      this.buffers = [];
+      for (const p of this.ptrs)
+        p.buffer.fill(0);
+      this.ptrs = [];
+      this.finished = true;
+      this.bitBuf = 0;
+    }
+    return buf;
+  }
+  bits(value, bits) {
+    if (bits > 32)
+      throw this.err("writeBits: cannot write more than 32 bits in single call");
+    if (value >= 2 ** bits)
+      throw this.err(`writeBits: value (${value}) >= 2**bits (${bits})`);
+    while (bits) {
+      const take = Math.min(bits, 8 - this.bitPos);
+      this.bitBuf = this.bitBuf << take | value >> bits - take;
+      this.bitPos += take;
+      bits -= take;
+      value &= 2 ** bits - 1;
+      if (this.bitPos === 8) {
+        this.bitPos = 0;
+        this.buffers.push(new Uint8Array([this.bitBuf]));
+        this.pos++;
+      }
+    }
+  }
+};
+function _wrap(inner) {
+  return {
+    // NOTE: we cannot export validate here, since it is likely mistake.
+    encodeStream: inner.encodeStream,
+    decodeStream: inner.decodeStream,
+    size: inner.size,
+    encode: (value) => {
+      const w = new _Writer();
+      inner.encodeStream(w, value);
+      return w.finish();
+    },
+    decode: (data, opts = {}) => {
+      const r = new _Reader(data, opts);
+      const res = inner.decodeStream(r);
+      r.finish();
+      return res;
+    }
+  };
+}
+function validate(inner, fn) {
+  if (!isCoder(inner))
+    throw new Error(`validate: invalid inner value ${inner}`);
+  if (typeof fn !== "function")
+    throw new Error("validate: fn should be function");
+  return _wrap({
+    size: inner.size,
+    encodeStream: (w, value) => {
+      let res;
+      try {
+        res = fn(value);
+      } catch (e) {
+        throw w.err(e);
+      }
+      inner.encodeStream(w, res);
+    },
+    decodeStream: (r) => {
+      const res = inner.decodeStream(r);
+      try {
+        return fn(res);
+      } catch (e) {
+        throw r.err(e);
+      }
+    }
+  });
+}
+var wrap = (inner) => {
+  const res = _wrap(inner);
+  return inner.validate ? validate(res, inner.validate) : res;
+};
+var isBaseCoder = (elm) => isPlainObject(elm) && typeof elm.decode === "function" && typeof elm.encode === "function";
+function isCoder(elm) {
+  return isPlainObject(elm) && isBaseCoder(elm) && typeof elm.encodeStream === "function" && typeof elm.decodeStream === "function" && (elm.size === void 0 || isNum(elm.size));
+}
+var view = (len, opts) => wrap({
+  size: len,
+  encodeStream: (w, value) => w.writeView(len, (view2) => opts.write(view2, value)),
+  decodeStream: (r) => r.readView(len, opts.read),
+  validate: (value) => {
+    if (typeof value !== "number")
+      throw new Error(`viewCoder: expected number, got ${typeof value}`);
+    if (opts.validate)
+      opts.validate(value);
+    return value;
+  }
+});
+var intView = (len, signed, opts) => {
+  const bits = len * 8;
+  const maxVal = 2 ** bits;
+  const validateUnsigned = (value) => {
+    if (!isNum(value))
+      throw new Error(`uintView: value is not safe integer: ${value}`);
+    if (0 > value || value >= maxVal) {
+      throw new Error(`uintView: value out of bounds. Expected 0 <= ${value} < ${maxVal}`);
+    }
+  };
+  return view(len, {
+    write: opts.write,
+    read: opts.read,
+    validate: validateUnsigned
+  });
+};
+var U32LE = /* @__PURE__ */ intView(4, false, {
+  read: (view2, pos) => view2.getUint32(pos, true),
+  write: (view2, value) => view2.setUint32(0, value, true)
+});
+var U16LE = /* @__PURE__ */ intView(2, false, {
+  read: (view2, pos) => view2.getUint16(pos, true),
+  write: (view2, value) => view2.setUint16(0, value, true)
+});
+var U8 = /* @__PURE__ */ intView(1, false, {
+  read: (view2, pos) => view2.getUint8(pos),
+  write: (view2, value) => view2.setUint8(0, value)
+});
+var ARKADE_OP = {
+  // Merkle Branch Verification (0xb3 — repurposed NOP4 slot)
+  MERKLEBRANCHVERIFY: 179,
+  // Digest (0xc3)
+  DIGEST: 195,
+  // SHA256 Streaming (0xc4-0xc6)
+  SHA256INITIALIZE: 196,
+  SHA256UPDATE: 197,
+  SHA256FINALIZE: 198,
+  // Input Introspection (0xc7-0xcb)
+  INSPECTINPUTOUTPOINT: 199,
+  INSPECTINPUTARKADESCRIPTHASH: 200,
+  INSPECTINPUTVALUE: 201,
+  INSPECTINPUTSCRIPTPUBKEY: 202,
+  INSPECTINPUTSEQUENCE: 203,
+  // Signatures (0xcc-0xcd)
+  CHECKSIGFROMSTACK: 204,
+  PUSHCURRENTINPUTINDEX: 205,
+  // Input Arkade Witness Introspection (0xce)
+  INSPECTINPUTARKADEWITNESSHASH: 206,
+  // Output Introspection (0xcf, 0xd1)
+  INSPECTOUTPUTVALUE: 207,
+  INSPECTOUTPUTSCRIPTPUBKEY: 209,
+  // Transaction Introspection (0xd2-0xd6)
+  INSPECTVERSION: 210,
+  INSPECTLOCKTIME: 211,
+  INSPECTNUMINPUTS: 212,
+  INSPECTNUMOUTPUTS: 213,
+  TXWEIGHT: 214,
+  // Byte/Number Conversion & Arithmetic (0xd7-0xda)
+  NUM2BIN: 215,
+  BIN2NUM: 216,
+  REVERSEBYTES: 217,
+  MODEXP: 218,
+  // 0xdb-0xdf are unassigned (OP_UNKNOWN219-223)
+  // EC Operations (0xe0-0xe2)
+  ECADD: 224,
+  ECMUL: 225,
+  ECPAIRING: 226,
+  // EC Operations (0xe3-0xe4)
+  ECMULSCALARVERIFY: 227,
+  TWEAKVERIFY: 228,
+  // Asset Groups (0xe5-0xf2)
+  INSPECTNUMASSETGROUPS: 229,
+  INSPECTASSETGROUPASSETID: 230,
+  INSPECTASSETGROUPCTRL: 231,
+  FINDASSETGROUPBYASSETID: 232,
+  INSPECTASSETGROUPMETADATAHASH: 233,
+  INSPECTASSETGROUPNUM: 234,
+  INSPECTASSETGROUP: 235,
+  INSPECTASSETGROUPSUM: 236,
+  INSPECTOUTASSETCOUNT: 237,
+  INSPECTOUTASSETAT: 238,
+  INSPECTOUTASSETLOOKUP: 239,
+  INSPECTINASSETCOUNT: 240,
+  INSPECTINASSETAT: 241,
+  INSPECTINASSETLOOKUP: 242,
+  // Transaction ID (0xf3)
+  TXID: 243,
+  // Packet Introspection (0xf4-0xf5) — added in emulator v0.0.1
+  INSPECTPACKET: 244,
+  INSPECTINPUTPACKET: 245,
+  // Signature Hash (0xf6)
+  SIGHASH: 246
+};
+var ARKADE_OPCODES = Object.values(ARKADE_OP);
+var ARKADE_OPCODE_NAMES = Object.fromEntries(
+  Object.entries(ARKADE_OP).map(([name, value]) => [value, name])
+);
+var ARKADE_OPCODE_VALUES = Object.fromEntries(
+  Object.entries(ARKADE_OPCODE_NAMES).map(([value, name]) => [name, Number(value)])
+);
+function buildBitcoinOpcodeNames() {
+  const names = {};
+  for (const [key, value] of Object.entries(btcSigner.OP)) {
+    if (typeof value === "number") {
+      const name = key.startsWith("OP_") ? key : `OP_${key}`;
+      names[value] = name;
+    }
+  }
+  names[0] = "OP_0";
+  return names;
+}
+function buildBitcoinOpcodeValues() {
+  const values = {};
+  for (const [key, value] of Object.entries(btcSigner.OP)) {
+    if (typeof value === "number") {
+      const name = key.startsWith("OP_") ? key : `OP_${key}`;
+      values[name] = value;
+      values[key] = value;
+    }
+  }
+  return values;
+}
+var BITCOIN_OPCODE_NAMES = buildBitcoinOpcodeNames();
+var BITCOIN_OPCODE_VALUES = buildBitcoinOpcodeValues();
+var OPCODE_NAMES = {
+  ...BITCOIN_OPCODE_NAMES,
+  // Add Arkade opcodes with OP_ prefix
+  ...Object.fromEntries(
+    Object.entries(ARKADE_OPCODE_NAMES).map(([value, name]) => [Number(value), `OP_${name}`])
+  )
+};
+var OPCODE_VALUES = {
+  ...BITCOIN_OPCODE_VALUES,
+  // Add Arkade opcodes with and without OP_ prefix
+  ...ARKADE_OPCODE_VALUES,
+  ...Object.fromEntries(
+    Object.entries(ARKADE_OPCODE_VALUES).map(([name, value]) => [`OP_${name}`, value])
+  )
+};
+function getOpcodeName(value) {
+  if (value >= 1 && value <= 75) {
+    return `OP_DATA_${value}`;
+  }
+  return OPCODE_NAMES[value];
+}
+function getOpcodeValue(name) {
+  const dataMatch = name.match(/^OP_DATA_(\d+)$/);
+  if (dataMatch) {
+    const n = parseInt(dataMatch[1], 10);
+    if (n >= 1 && n <= 75) {
+      return n;
+    }
+    return void 0;
+  }
+  return OPCODE_VALUES[name];
+}
+
+// src/arkade/bignum.ts
+var bignum_exports = {};
+chunk5BLDMQED_cjs.__export(bignum_exports, {
+  BIGNUM_MAX_BYTES: () => BIGNUM_MAX_BYTES,
+  decode: () => decode,
+  encode: () => encode
+});
+var BIGNUM_MAX_BYTES = 520;
+var codec = btcSigner.ScriptNum(
+  BIGNUM_MAX_BYTES,
+  /* forceMinimal */
+  true
+);
+function encode(value) {
+  const result = codec.encode(value);
+  if (result.length > BIGNUM_MAX_BYTES) {
+    throw new Error(`BigNum value exceeds 520 bytes (encoded to ${result.length} bytes)`);
+  }
+  return result;
+}
+function decode(value) {
+  return codec.decode(value);
+}
+
+// src/arkade/script.ts
+var ARKADE_OPS = { ...btcSigner.OP, ...ARKADE_OP };
+var ArkadeOPNames = {};
+for (const [k, v] of Object.entries(ARKADE_OPS)) {
+  if (typeof v === "number") ArkadeOPNames[v] = k;
+}
+var ArkadeScript = wrap({
+  encodeStream: (w, value) => {
+    for (let o of value) {
+      if (typeof o === "string") {
+        const v = ARKADE_OPS[o];
+        if (v === void 0) throw new Error(`Unknown opcode=${o}`);
+        w.byte(v);
+        continue;
+      } else if (typeof o === "number" || typeof o === "bigint") {
+        if (o === 0 || o === 0n) {
+          w.byte(0);
+          continue;
+        } else if (o >= 1 && o <= 16) {
+          w.byte(btcSigner.OP.OP_1 - 1 + Number(o));
+          continue;
+        } else if (o === -1 || o === -1n) {
+          w.byte(btcSigner.OP["1NEGATE"]);
+          continue;
+        }
+        const big = typeof o === "number" ? BigInt(o) : o;
+        o = encode(big);
+      }
+      if (!(o instanceof Uint8Array)) throw new Error(`Wrong Script OP=${o} (${typeof o})`);
+      const len = o.length;
+      if (len < btcSigner.OP.PUSHDATA1) w.byte(len);
+      else if (len <= 255) {
+        w.byte(btcSigner.OP.PUSHDATA1);
+        w.byte(len);
+      } else if (len <= 65535) {
+        w.byte(btcSigner.OP.PUSHDATA2);
+        w.bytes(U16LE.encode(len));
+      } else {
+        w.byte(btcSigner.OP.PUSHDATA4);
+        w.bytes(U32LE.encode(len));
+      }
+      w.bytes(o);
+    }
+  },
+  decodeStream: (r) => {
+    const out = [];
+    while (!r.isEnd()) {
+      const cur = r.byte();
+      if (btcSigner.OP.OP_0 < cur && cur <= btcSigner.OP.PUSHDATA4) {
+        let len;
+        if (cur < btcSigner.OP.PUSHDATA1) len = cur;
+        else if (cur === btcSigner.OP.PUSHDATA1) len = U8.decodeStream(r);
+        else if (cur === btcSigner.OP.PUSHDATA2) len = U16LE.decodeStream(r);
+        else if (cur === btcSigner.OP.PUSHDATA4) len = U32LE.decodeStream(r);
+        else throw new Error("Should be not possible");
+        out.push(r.bytes(len));
+      } else if (cur === 0) {
+        out.push(0);
+      } else if (btcSigner.OP.OP_1 <= cur && cur <= btcSigner.OP.OP_16) {
+        out.push(cur - (btcSigner.OP.OP_1 - 1));
+      } else if (cur === btcSigner.OP["1NEGATE"]) {
+        out.push(-1);
+      } else {
+        const op = ArkadeOPNames[cur];
+        if (op === void 0) throw new Error(`Unknown opcode=${cur.toString(16)}`);
+        out.push(op);
+      }
+    }
+    return out;
+  }
+});
+function toASM(script) {
+  const parts = [];
+  for (const op of script) {
+    if (typeof op === "string") {
+      const name = op.startsWith("OP_") ? op : `OP_${op}`;
+      parts.push(name);
+    } else if (typeof op === "number" || typeof op === "bigint") {
+      if (op === 0 || op === 0n) {
+        parts.push("OP_0");
+      } else if (op >= 1 && op <= 16) {
+        parts.push(`OP_${op}`);
+      } else if (op === -1 || op === -1n) {
+        parts.push("OP_1NEGATE");
+      } else {
+        parts.push(base.hex.encode(encode(BigInt(op))));
+      }
+    } else {
+      parts.push(base.hex.encode(op));
+    }
+  }
+  return parts.join(" ");
+}
+function fromASM(asm) {
+  const tokens = asm.trim().split(/\s+/).filter(Boolean);
+  const out = [];
+  for (const token of tokens) {
+    if (token === "OP_0" || token === "OP_FALSE") {
+      out.push(0);
+      continue;
+    }
+    if (token === "OP_TRUE") {
+      out.push(1);
+      continue;
+    }
+    const numMatch = token.match(/^OP_(\d+)$/);
+    if (numMatch) {
+      const n = parseInt(numMatch[1], 10);
+      if (n >= 1 && n <= 16) {
+        out.push(n);
+        continue;
+      }
+    }
+    let key;
+    if (token.startsWith("OP_")) {
+      key = token.slice(3);
+    } else {
+      key = token;
+    }
+    if (key in ARKADE_OPS) {
+      out.push(key);
+      continue;
+    }
+    if (/^[0-9a-fA-F]+$/.test(token) && token.length % 2 === 0) {
+      try {
+        out.push(base.hex.decode(token));
+        continue;
+      } catch {
+      }
+    }
+    throw new Error(`Invalid ASM token: ${token}`);
+  }
+  return out;
+}
+function asmToBytes(asm) {
+  return ArkadeScript.encode(fromASM(asm));
+}
+function bytesToASM(script) {
+  return toASM(ArkadeScript.decode(script));
+}
+var TAG_SCRIPT = "ArkScriptHash";
+var TAG_WITNESS = "ArkWitnessHash";
+function arkadeScriptHash(script) {
+  return secp256k1_js.schnorr.utils.taggedHash(TAG_SCRIPT, script);
+}
+function arkadeWitnessHash(witness) {
+  if (witness.length === 0) {
+    return new Uint8Array(32);
+  }
+  return secp256k1_js.schnorr.utils.taggedHash(TAG_WITNESS, witness);
+}
+function computeArkadeScriptPublicKey(pubKey, script) {
+  const hash = arkadeScriptHash(script);
+  const xOnly = pubKey.length === 33 ? pubKey.subarray(1) : pubKey;
+  const point = secp256k1_js.schnorr.utils.lift_x(utils_js.bytesToNumberBE(xOnly));
+  const scalar = utils_js.bytesToNumberBE(hash) % secp256k1_js.secp256k1.Point.CURVE().n;
+  const tweak = secp256k1_js.secp256k1.Point.BASE.multiply(scalar);
+  return secp256k1_js.schnorr.utils.pointToBytes(point.add(tweak));
+}
+
+// src/arkade/program.ts
+var MinimalScriptNum = btcSigner.ScriptNum(void 0, true);
+var SUPPORTED_PROGRAM_VERSION = 0;
+function inputName(ref) {
+  return typeof ref === "string" ? ref : ref.name;
+}
+function bindValue(bind, name) {
+  const v = bind[name];
+  if (v === void 0) throw new Error(`unbound parameter '${name}'`);
+  return v;
+}
+function resolveTimelockValue(value, args) {
+  if (typeof value === "bigint") return value;
+  if (value.startsWith("$")) {
+    const v = bindValue(args, value.slice(1));
+    if (typeof v === "bigint" || typeof v === "number") return BigInt(v);
+    throw new Error(`timelock value '${value}' must resolve to a number`);
+  }
+  throw new Error(
+    `invalid timelock value '${value}' \u2014 expected a bigint or a '$param' reference`
+  );
+}
+function resolveAsm(asm, bind) {
+  const tokens = asm.map((t) => {
+    if (typeof t === "string" && t.startsWith("$")) {
+      return bindValue(bind, t.slice(1));
+    }
+    if (t === "<SELF>") {
+      throw new Error(
+        "<SELF> is not a placeholder; use INSPECTINPUTSCRIPTPUBKEY for continuation covenants"
+      );
+    }
+    return t;
+  });
+  return ArkadeScript.encode(tokens);
+}
+function witnessRefToBytes(ref, callArgs, programArgs) {
+  if (ref instanceof Uint8Array) return ref;
+  if (typeof ref === "number" || typeof ref === "bigint") {
+    return MinimalScriptNum.encode(BigInt(ref));
+  }
+  const v = ref.startsWith("$") ? bindValue(programArgs, ref.slice(1)) : bindValue(callArgs, ref);
+  if (v instanceof Uint8Array) return v;
+  return MinimalScriptNum.encode(BigInt(v));
+}
+function validateTapscript(seg) {
+  if (!seg.signers || seg.signers.length === 0) {
+    throw new Error("tapscript: at least one signer is required");
+  }
+  if (seg.asm !== void 0 && seg.cltv !== void 0) {
+    throw new Error(
+      "tapscript: `asm` and `cltv` conflict \u2014 arkd has no condition+CLTV closure"
+    );
+  }
+  if (seg.csv !== void 0 && seg.cltv !== void 0) {
+    throw new Error("tapscript: `csv` and `cltv` conflict \u2014 use at most one timelock");
+  }
+  for (const t of seg.asm ?? []) {
+    if (typeof t === "string" && t in ARKADE_OP) {
+      throw new Error(
+        `tapscript: arkade opcode '${t}' is not enforceable on-chain \u2014 move it to arkadeScript`
+      );
+    }
+  }
+}
+function collectParamRefs(program) {
+  const refs = /* @__PURE__ */ new Set();
+  const collect = (items) => {
+    for (const t of items ?? []) {
+      if (typeof t === "string" && t.startsWith("$")) refs.add(t.slice(1));
+    }
+  };
+  for (const fn of Object.values(program.functions)) {
+    const tap = fn.tapscript;
+    collect(tap.signers);
+    collect(tap.asm);
+    collect(tap.witness);
+    collect(tap.csv ? [tap.csv.value] : void 0);
+    collect(tap.cltv !== void 0 ? [tap.cltv] : void 0);
+    collect(fn.arkadeScript?.asm);
+    collect(fn.arkadeScript?.witness);
+  }
+  return refs;
+}
+var TYPED_BYTE_LENGTHS = { pubkey: 32, sig: 64 };
+function validateParamValue(def, value) {
+  if (def.type === "int") {
+    if (typeof value !== "bigint" && typeof value !== "number") {
+      throw new Error(`program parameter '${def.name}' expects an int, got bytes`);
+    }
+    return;
+  }
+  if (!(value instanceof Uint8Array)) {
+    throw new Error(
+      `program parameter '${def.name}' expects ${def.type} bytes, got ${typeof value}`
+    );
+  }
+  const length = TYPED_BYTE_LENGTHS[def.type];
+  if (length !== void 0 && value.length !== length) {
+    throw new Error(
+      `program parameter '${def.name}' expects a ${length}-byte ${def.type}, got ${value.length} bytes`
+    );
+  }
+}
+function validateProgram(program, args) {
+  const params = program.params;
+  if (!params || !params.some((p) => typeof p !== "string")) return;
+  const declared = new Set(params.map(inputName));
+  for (const name of declared) {
+    if (args[name] === void 0) {
+      throw new Error(`program parameter '${name}' is declared but not bound in args`);
+    }
+  }
+  for (const ref of collectParamRefs(program)) {
+    if (!declared.has(ref)) {
+      throw new Error(`'$${ref}' is referenced but not declared in program params`);
+    }
+  }
+  for (const p of params) {
+    if (typeof p !== "string") validateParamValue(p, args[p.name]);
+  }
+}
+function resolveSigner(ref, args) {
+  if (ref instanceof Uint8Array) return ref;
+  if (!ref.startsWith("$")) {
+    throw new Error(`unknown signer reference '${ref}' \u2014 use '$${ref}'`);
+  }
+  const v = bindValue(args, ref.slice(1));
+  if (!(v instanceof Uint8Array)) {
+    throw new Error(`signer ${ref} must be a pubkey (bytes)`);
+  }
+  return v;
+}
+function encodeTapscriptSegment(seg, pubkeys, args) {
+  if (seg.csv) {
+    const timelock = { type: seg.csv.type, value: resolveTimelockValue(seg.csv.value, args) };
+    if (seg.asm) {
+      return chunkL5ND2FJJ_cjs.ConditionCSVMultisigTapscript.encode({
+        conditionScript: resolveAsm(seg.asm, args),
+        timelock,
+        pubkeys
+      });
+    }
+    return chunkL5ND2FJJ_cjs.CSVMultisigTapscript.encode({ timelock, pubkeys });
+  }
+  if (seg.cltv !== void 0) {
+    return chunkL5ND2FJJ_cjs.CLTVMultisigTapscript.encode({
+      absoluteTimelock: resolveTimelockValue(seg.cltv, args),
+      pubkeys
+    });
+  }
+  if (seg.asm) {
+    return chunkL5ND2FJJ_cjs.ConditionMultisigTapscript.encode({
+      conditionScript: resolveAsm(seg.asm, args),
+      pubkeys
+    });
+  }
+  return chunkL5ND2FJJ_cjs.MultisigTapscript.encode({ pubkeys });
+}
+function compileFunctions(program, args, keys) {
+  if (program.version !== SUPPORTED_PROGRAM_VERSION) {
+    throw new Error(
+      `ArkadeContract: unsupported program version ${program.version} \u2014 this SDK supports version ${SUPPORTED_PROGRAM_VERSION}`
+    );
+  }
+  const functions = program.functions;
+  const names = Object.keys(functions);
+  if (names.length === 0) {
+    throw new Error("ArkadeContract: program has no functions");
+  }
+  validateProgram(program, args);
+  const defs = names.map((n) => functions[n]);
+  const covenant = names.find((_, i) => defs[i].arkadeScript);
+  if (covenant && !keys.emulatorKey) {
+    throw new Error(
+      `ArkadeContract: function '${covenant}' has an arkadeScript but no emulator is configured \u2014 pass an \`emulator\` to Arkade.connect`
+    );
+  }
+  return defs.map((def, i) => {
+    validateTapscript(def.tapscript);
+    const pubkeys = def.tapscript.signers.map((s) => resolveSigner(s, args));
+    const arkadeScript = def.arkadeScript ? resolveAsm(def.arkadeScript.asm, args) : void 0;
+    const leafPubkeys = arkadeScript ? [...pubkeys, computeArkadeScriptPublicKey(keys.emulatorKey, arkadeScript)] : pubkeys;
+    const leafScript = encodeTapscriptSegment(def.tapscript, leafPubkeys, args).script;
+    return { name: names[i], def, leafScript, arkadeScript, signerKeys: pubkeys };
+  });
+}
+var ArkadeProgramScript = class extends chunkL5ND2FJJ_cjs.VtxoScript {
+  constructor(program, args, keys) {
+    const partial = compileFunctions(program, args, keys);
+    super(partial.map((p) => p.leafScript));
+    this.program = program;
+    this.args = args;
+    this.keys = keys;
+    this.compiled = partial.map((p) => ({
+      ...p,
+      tapLeafScript: this.findLeaf(base.hex.encode(p.leafScript))
+    }));
+  }
+  program;
+  args;
+  keys;
+  /** Spending paths in declaration order. */
+  compiled;
+  /** The compiled spending path with the given function name, if any. */
+  functionByName(name) {
+    return this.compiled.find((f) => f.name === name);
+  }
+};
+function parseArtifact(artifact) {
+  const hexToken = (t) => typeof t === "string" && t.startsWith("0x") ? base.hex.decode(t.slice(2)) : t;
+  const timelockValue = (v) => typeof v === "string" && v.startsWith("$") ? v : BigInt(v);
+  const functions = {};
+  for (const [name, fn] of Object.entries(artifact.functions)) {
+    const tap = fn.tapscript ?? {};
+    const tapscript = {
+      signers: (tap.signers ?? []).map(hexToken),
+      ...tap.asm ? { asm: tap.asm.map(hexToken) } : {},
+      ...tap.witness ? { witness: tap.witness.map(hexToken) } : {},
+      ...tap.csv ? { csv: { type: tap.csv.type, value: timelockValue(tap.csv.value) } } : {},
+      ...tap.cltv !== void 0 ? { cltv: timelockValue(tap.cltv) } : {}
+    };
+    const arkadeScript = fn.arkadeScript ? {
+      asm: fn.arkadeScript.asm.map(hexToken),
+      ...fn.arkadeScript.witness ? { witness: fn.arkadeScript.witness.map(hexToken) } : {}
+    } : void 0;
+    functions[name] = {
+      ...fn.inputs ? { inputs: fn.inputs } : {},
+      tapscript,
+      ...arkadeScript ? { arkadeScript } : {}
+    };
+  }
+  return {
+    version: artifact.version ?? SUPPORTED_PROGRAM_VERSION,
+    ...artifact.name !== void 0 ? { name: artifact.name } : {},
+    ...artifact.params ? { params: artifact.params } : {},
+    functions
+  };
+}
+function stringifyArtifact(program) {
+  const token = (t) => {
+    if (t instanceof Uint8Array) return "0x" + base.hex.encode(t);
+    if (typeof t === "bigint") {
+      if (t >= BigInt(Number.MIN_SAFE_INTEGER) && t <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number(t);
+      }
+      return "0x" + base.hex.encode(MinimalScriptNum.encode(t));
+    }
+    return t;
+  };
+  const functions = {};
+  for (const [name, fn] of Object.entries(program.functions)) {
+    const tap = fn.tapscript;
+    functions[name] = {
+      ...fn.inputs ? { inputs: fn.inputs } : {},
+      tapscript: {
+        signers: tap.signers.map(token),
+        ...tap.asm ? { asm: tap.asm.map(token) } : {},
+        ...tap.witness ? { witness: tap.witness.map(token) } : {},
+        ...tap.csv ? { csv: { type: tap.csv.type, value: tap.csv.value.toString() } } : {},
+        ...tap.cltv !== void 0 ? { cltv: tap.cltv.toString() } : {}
+      },
+      ...fn.arkadeScript ? {
+        arkadeScript: {
+          asm: fn.arkadeScript.asm.map(token),
+          ...fn.arkadeScript.witness ? { witness: fn.arkadeScript.witness.map(token) } : {}
+        }
+      } : {}
+    };
+  }
+  return JSON.stringify({
+    version: program.version,
+    ...program.name !== void 0 ? { name: program.name } : {},
+    ...program.params ? { params: program.params } : {},
+    functions
+  });
+}
+function serializeArgValue(v) {
+  if (v instanceof Uint8Array) return "0x" + base.hex.encode(v);
+  if (typeof v === "bigint") return v.toString();
+  return v;
+}
+function parseArgValue(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    if (v.startsWith("0x")) return base.hex.decode(v.slice(2));
+    return BigInt(v);
+  }
+  throw new Error(`invalid arkade arg value: ${JSON.stringify(v)}`);
+}
+function parseTypedArgValue(name, type, v) {
+  if (type === "int") {
+    if (typeof v === "number") return v;
+    if (typeof v === "string") return BigInt(v);
+    throw new Error(
+      `arkade contract params: '${name}' expects an int, got ${JSON.stringify(v)}`
+    );
+  }
+  if (typeof v === "string" && v.startsWith("0x")) return base.hex.decode(v.slice(2));
+  throw new Error(
+    `arkade contract params: '${name}' expects ${type} as 0x-prefixed hex, got ${JSON.stringify(v)}`
+  );
+}
+function serializeArkadeContractParams(typed) {
+  const args = {};
+  for (const [k, v] of Object.entries(typed.args)) {
+    args[k] = serializeArgValue(v);
+  }
+  return {
+    program: stringifyArtifact(typed.program),
+    args: JSON.stringify(args),
+    serverKey: base.hex.encode(typed.serverKey),
+    ...typed.userKey ? { userKey: base.hex.encode(typed.userKey) } : {},
+    ...typed.emulatorKey ? { emulatorKey: base.hex.encode(typed.emulatorKey) } : {}
+  };
+}
+function deserializeArkadeContractParams(params) {
+  if (!params.program) {
+    throw new Error("arkade contract params: missing 'program'");
+  }
+  if (!params.serverKey) {
+    throw new Error("arkade contract params: missing 'serverKey'");
+  }
+  const program = parseArtifact(JSON.parse(params.program));
+  const paramTypes = /* @__PURE__ */ new Map();
+  for (const p of program.params ?? []) {
+    if (typeof p !== "string") paramTypes.set(p.name, p.type);
+  }
+  const args = {};
+  if (params.args) {
+    for (const [k, v] of Object.entries(JSON.parse(params.args))) {
+      const type = paramTypes.get(k);
+      args[k] = type ? parseTypedArgValue(k, type, v) : parseArgValue(v);
+    }
+  }
+  return {
+    program,
+    args,
+    serverKey: base.hex.decode(params.serverKey),
+    ...params.userKey ? { userKey: base.hex.decode(params.userKey) } : {},
+    ...params.emulatorKey ? { emulatorKey: base.hex.decode(params.emulatorKey) } : {}
+  };
+}
+
+// src/contracts/handlers/arkade.ts
+function walletKeyFrom(context) {
+  const extract = (value) => {
+    if (!isDescriptor(value)) return value.toLowerCase();
+    try {
+      return extractPubKey(value).toLowerCase();
+    } catch {
+      return void 0;
+    }
+  };
+  if (context.walletDescriptor) {
+    const key = extract(context.walletDescriptor);
+    if (key) return key;
+  }
+  if (context.walletPubKey) {
+    return extract(context.walletPubKey);
+  }
+  return void 0;
+}
+function staticWitness(fn, script) {
+  const refs = fn.def.tapscript.witness ?? [];
+  try {
+    return refs.map((w) => witnessRefToBytes(w, {}, script.args));
+  } catch {
+    return null;
+  }
+}
+function pathsFor(script, context, opts) {
+  const walletKey = walletKeyFrom(context);
+  const serverHex = base.hex.encode(script.keys.serverKey);
+  const paths = [];
+  for (const fn of script.compiled) {
+    if (fn.arkadeScript) continue;
+    const witness = staticWitness(fn, script);
+    if (witness === null) continue;
+    const signerHexes = fn.signerKeys.map((s) => base.hex.encode(s));
+    const requiresServer = signerHexes.includes(serverHex);
+    const nonServer = signerHexes.filter((s) => s !== serverHex);
+    if (walletKey && nonServer.length > 0 && !nonServer.includes(walletKey)) {
+      continue;
+    }
+    const csvDef = fn.def.tapscript.csv;
+    const csv = csvDef ? { type: csvDef.type, value: resolveTimelockValue(csvDef.value, script.args) } : void 0;
+    const cltv = fn.def.tapscript.cltv !== void 0 ? resolveTimelockValue(fn.def.tapscript.cltv, script.args) : void 0;
+    if (context.collaborative) {
+      if (csv) continue;
+      if (opts.checkTimelocks && cltv !== void 0 && !isCltvSatisfied(context, cltv)) {
+        continue;
+      }
+      paths.push({
+        leaf: fn.tapLeafScript,
+        ...witness.length > 0 ? { extraWitness: witness } : {}
+      });
+      continue;
+    }
+    if (requiresServer) continue;
+    const sequence = csv ? Number(chunkL5ND2FJJ_cjs.timelockToSequence(csv)) : void 0;
+    if (opts.checkTimelocks && csv && !isCsvSpendable(context, sequence)) continue;
+    if (opts.checkTimelocks && cltv !== void 0 && !isCltvSatisfied(context, cltv)) {
+      continue;
+    }
+    paths.push({
+      leaf: fn.tapLeafScript,
+      ...sequence !== void 0 ? { sequence } : {},
+      ...witness.length > 0 ? { extraWitness: witness } : {}
+    });
+  }
+  return paths;
+}
+var ArkadeContractHandler = {
+  type: "arkade",
+  createScript(params) {
+    const typed = this.deserializeParams(params);
+    return new ArkadeProgramScript(typed.program, typed.args, {
+      serverKey: typed.serverKey,
+      userKey: typed.userKey,
+      emulatorKey: typed.emulatorKey
+    });
+  },
+  serializeParams(params) {
+    return serializeArkadeContractParams(params);
+  },
+  deserializeParams(params) {
+    return deserializeArkadeContractParams(params);
+  },
+  selectPath(script, _contract, context) {
+    const paths = pathsFor(script, context, { checkTimelocks: true });
+    return paths.length > 0 ? paths[0] : null;
+  },
+  getAllSpendingPaths(script, _contract, context) {
+    return pathsFor(script, context, { checkTimelocks: false });
+  },
+  getSpendablePaths(script, _contract, context) {
+    return pathsFor(script, context, { checkTimelocks: true });
+  },
+  /**
+   * Annotation tapscripts for VTXOs locked to this contract: prefer the
+   * collaborative tapscript path (the multisig the Arkade Service co-signs,
+   * mirroring `forfeit()` on the built-in script shapes); covenant-only
+   * programs fall back to their first covenant leaf (its forfeit is
+   * co-signed by the emulator during batch settlement); otherwise the first
+   * declared leaf.
+   */
+  deriveTapscripts(script, _contract) {
+    const collaborative = pathsFor(
+      script,
+      { collaborative: true, currentTime: 0 },
+      { checkTimelocks: false }
+    );
+    const leaf = collaborative[0]?.leaf ?? script.compiled.find((f) => f.arkadeScript)?.tapLeafScript ?? script.compiled[0].tapLeafScript;
+    return {
+      forfeitTapLeafScript: leaf,
+      intentTapLeafScript: leaf,
+      tapTree: script.encode()
+    };
+  }
+};
+
+// src/contracts/handlers/index.ts
+contractHandlers.register(DefaultContractHandler);
+contractHandlers.register(DelegateContractHandler);
+contractHandlers.register(VHTLCContractHandler);
+contractHandlers.register(BoardingContractHandler);
+contractHandlers.register(ArkadeContractHandler);
+
+exports.ARKADE_OP = ARKADE_OP;
+exports.ARKADE_OPCODES = ARKADE_OPCODES;
+exports.ARKADE_OPCODE_NAMES = ARKADE_OPCODE_NAMES;
+exports.ARKADE_OPCODE_VALUES = ARKADE_OPCODE_VALUES;
+exports.ARKADE_OPS = ARKADE_OPS;
+exports.ArkadeContractHandler = ArkadeContractHandler;
+exports.ArkadeProgramScript = ArkadeProgramScript;
+exports.ArkadeScript = ArkadeScript;
+exports.BoardingContractHandler = BoardingContractHandler;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+exports.DefaultContractHandler = DefaultContractHandler;
+exports.DelegateContractHandler = DelegateContractHandler;
+exports.OPCODE_NAMES = OPCODE_NAMES;
+exports.OPCODE_VALUES = OPCODE_VALUES;
+exports.SUPPORTED_PROGRAM_VERSION = SUPPORTED_PROGRAM_VERSION;
+exports.VHTLCContractHandler = VHTLCContractHandler;
+exports.WALLET_RECEIVE_SOURCE = WALLET_RECEIVE_SOURCE;
+exports.arkadeScriptHash = arkadeScriptHash;
+exports.arkadeWitnessHash = arkadeWitnessHash;
+exports.asmToBytes = asmToBytes;
+exports.bignum_exports = bignum_exports;
+exports.bytesToASM = bytesToASM;
+exports.computeArkadeScriptPublicKey = computeArkadeScriptPublicKey;
+exports.contractHandlers = contractHandlers;
+exports.deriveDescriptorLeafPubKey = deriveDescriptorLeafPubKey;
+exports.descriptorIsOurs = descriptorIsOurs;
+exports.deserializeArkadeContractParams = deserializeArkadeContractParams;
+exports.fromASM = fromASM;
+exports.getOpcodeName = getOpcodeName;
+exports.getOpcodeValue = getOpcodeValue;
+exports.inputName = inputName;
+exports.isCltvSatisfied = isCltvSatisfied;
+exports.isCsvSpendable = isCsvSpendable;
+exports.isMainnetDescriptor = isMainnetDescriptor;
+exports.parseArtifact = parseArtifact;
+exports.resolveAsm = resolveAsm;
+exports.serializeArkadeContractParams = serializeArkadeContractParams;
+exports.stringifyArtifact = stringifyArtifact;
+exports.toASM = toASM;
+exports.validateProgram = validateProgram;
+exports.witnessRefToBytes = witnessRefToBytes;
+//# sourceMappingURL=chunk-RQSA7ADZ.cjs.map
+//# sourceMappingURL=chunk-RQSA7ADZ.cjs.map