@arkade-os/sdk 0.4.59 → 0.4.61

package/dist/{chunk-PN5RD7ZI.js → chunk-6O5OLYTZ.js}

@@ -1,4 +1,4 @@
-import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, timelockToSequence, sequenceToTimelock, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-FIMOVH25.js';
+import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-PVY6DMN5.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { hex } from '@scure/base';
 import { networks, expand } from '@bitcoinerlab/descriptors-scure';
@@ -210,6 +210,31 @@ function deriveDescriptorLeafCompressedPubKey(descriptor) {
   }
   return key.keyPath ? key.bip32.derivePath(key.keyPath.replace(/^\//, "")).publicKey : key.bip32.publicKey;
 }
+function parseHDDescriptor(descriptor) {
+  if (!isDescriptor(descriptor)) {
+    return null;
+  }
+  let expansion;
+  try {
+    const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;
+    expansion = expand({ descriptor, network });
+  } catch {
+    return null;
+  }
+  const key = expansion.expansionMap?.["@0"];
+  if (!key?.masterFingerprint || !key.originPath || !key.keyPath || !key.bip32) {
+    return null;
+  }
+  return {
+    fingerprint: hex.encode(key.masterFingerprint),
+    basePath: key.originPath.replace(/^\//, ""),
+    xpub: key.bip32.toBase58(),
+    derivationPath: key.keyPath.replace(/^\//, "")
+  };
+}
+async function identityDescriptor(identity) {
+  return normalizeToDescriptor(hex.encode(await identity.xOnlyPublicKey()));
+}
 
 // src/contracts/metadata.ts
 var WALLET_RECEIVE_SOURCE = "wallet-receive";
@@ -265,12 +290,40 @@ function deserializeCsvTimelock(value) {
 }
 var CLTV_HEIGHT_THRESHOLD = 500000000n;
 function isCltvSatisfied(context, locktime) {
+  return cltvMaturity(context, locktime) === "satisfied";
+}
+function cltvMaturity(context, locktime) {
   if (locktime < CLTV_HEIGHT_THRESHOLD) {
-    if (context.blockHeight === void 0) return false;
-    return BigInt(context.blockHeight) >= locktime;
+    if (context.blockHeight === void 0) return "unknown";
+    return BigInt(context.blockHeight) >= locktime ? "satisfied" : "pending";
+  }
+  return nowSeconds(context) >= locktime ? "satisfied" : "pending";
+}
+function nowSeconds(context) {
+  return BigInt(Math.floor(context.chainTime ?? context.currentTime / 1e3));
+}
+function isHeightLocktime(locktime) {
+  return locktime < CLTV_HEIGHT_THRESHOLD;
+}
+function assertVhtlcSpendableNow(contract, context) {
+  if (!context.collaborative) return;
+  if (resolveRole(contract, context) !== "sender") return;
+  const raw = contract.params?.refundLocktime;
+  if (raw === void 0) return;
+  let refundLocktime;
+  try {
+    refundLocktime = BigInt(raw);
+  } catch {
+    return;
   }
-  const currentTimeSec = BigInt(Math.floor(context.currentTime / 1e3));
-  return currentTimeSec >= locktime;
+  if (cltvMaturity(context, refundLocktime) !== "pending") return;
+  const [matures, now] = isHeightLocktime(refundLocktime) ? [`block ${refundLocktime}`, `${context.blockHeight}`] : [
+    `${new Date(Number(refundLocktime) * 1e3).toISOString()}`,
+    new Date(context.currentTime).toISOString()
+  ];
+  throw new Error(
+    `vhtlc ${contract.script} cannot be spent yet: its refund path opens at ${matures}, now ${now}. Until then the lockup is the receiver's to claim, and the server rejects a spend of it. Retry after ${matures}, or wait for the receiver to claim it with the preimage.`
+  );
 }
 function isCsvSpendable(context, sequence) {
   if (sequence === void 0) return true;
@@ -285,7 +338,7 @@ function isCsvSpendable(context, sequence) {
   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 Number(nowSeconds(context)) - blockTime >= Number(timelock.value);
   }
   return false;
 }
@@ -427,6 +480,8 @@ var DefaultContractHandler = {
   getSpendablePaths(script, contract, context) {
     return forfeitExitSpendablePaths(script, contract, context);
   },
+  /** The wallet's own money. */
+  isGenericallySpendable: () => true,
   discoverAt: discoverAtViaRange(discoverDefaultRange),
   discoverRange: discoverDefaultRange,
   candidatesAt: defaultCandidatesAt
@@ -526,6 +581,8 @@ var DelegateContractHandler = {
   getSpendablePaths(script, contract, context) {
     return forfeitExitSpendablePaths(script, contract, context);
   },
+  /** The wallet's own money, delegated signing. */
+  isGenericallySpendable: () => true,
   discoverAt: discoverAtViaRange(discoverDelegateRange),
   discoverRange: discoverDelegateRange,
   candidatesAt: delegateCandidatesAt
@@ -560,1225 +617,1702 @@ function discoverDelegateRange(entries, deps) {
     (c, index, descriptor) => ({ ...c, ...rotatedReceiveMetadata(index, descriptor) })
   );
 }
-var VHTLC;
-((VHTLC2) => {
-  class Script3 extends 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 = ConditionMultisigTapscript.encode({
-        conditionScript,
-        pubkeys: [receiver, server]
-      }).script;
-      const refundScript = MultisigTapscript.encode({
-        pubkeys: [sender, receiver, server]
-      }).script;
-      const refundWithoutReceiverScript = CLTVMultisigTapscript.encode({
-        absoluteTimelock: refundLocktime,
-        pubkeys: [sender, server]
-      }).script;
-      const unilateralClaimScript = ConditionCSVMultisigTapscript.encode({
-        conditionScript,
-        timelock: unilateralClaimDelay,
-        pubkeys: [receiver]
-      }).script;
-      const unilateralRefundScript = CSVMultisigTapscript.encode({
-        timelock: unilateralRefundDelay,
-        pubkeys: [sender, receiver]
-      }).script;
-      const unilateralRefundWithoutReceiverScript = CSVMultisigTapscript.encode({
-        timelock: unilateralRefundWithoutReceiverDelay,
-        pubkeys: [sender]
-      }).script;
-      super([
-        claimScript,
-        refundScript,
-        refundWithoutReceiverScript,
-        unilateralClaimScript,
-        unilateralRefundScript,
-        unilateralRefundWithoutReceiverScript
-      ]);
-      this.options = options;
-      this.claimScript = hex.encode(claimScript);
-      this.refundScript = hex.encode(refundScript);
-      this.refundWithoutReceiverScript = hex.encode(refundWithoutReceiverScript);
-      this.unilateralClaimScript = hex.encode(unilateralClaimScript);
-      this.unilateralRefundScript = hex.encode(unilateralRefundScript);
-      this.unilateralRefundWithoutReceiverScript = hex.encode(
-        unilateralRefundWithoutReceiverScript
-      );
-    }
-    options;
-    claimScript;
-    refundScript;
-    refundWithoutReceiverScript;
-    unilateralClaimScript;
-    unilateralRefundScript;
-    unilateralRefundWithoutReceiverScript;
-    /** Return the collaborative claim tapleaf script. */
-    claim() {
-      return this.findLeaf(this.claimScript);
+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 the collaborative refund tapleaf script. */
-    refund() {
-      return this.findLeaf(this.refundScript);
+    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 the refund-without-receiver tapleaf script. */
-    refundWithoutReceiver() {
-      return this.findLeaf(this.refundWithoutReceiverScript);
+    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;
     }
-    /** Return the unilateral claim tapleaf script. */
-    unilateralClaim() {
-      return this.findLeaf(this.unilateralClaimScript);
+    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 the unilateral refund tapleaf script. */
-    unilateralRefund() {
-      return this.findLeaf(this.unilateralRefundScript);
+    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;
     }
-    /** Return the unilateral refund-without-receiver tapleaf script. */
-    unilateralRefundWithoutReceiver() {
-      return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
+    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;
   }
-  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");
+};
+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: ${hex.encode(this.data.slice(this.pos))}`);
     }
-    if (!receiver || receiver.length !== 32) {
-      throw new Error("Invalid public key length (receiver)");
+    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})[${hex.encode(this.data.subarray(pos, pos + length))}]`).join(", ");
+        throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);
+      } else
+        return;
     }
-    if (!sender || sender.length !== 32) {
-      throw new Error("Invalid public key length (sender)");
+    if (!this.isEnd()) {
+      throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${hex.encode(this.data.slice(this.pos))}`);
     }
-    if (!server || server.length !== 32) {
-      throw new Error("Invalid public key length (server)");
+  }
+  // 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;
     }
-    if (typeof refundLocktime !== "bigint" || refundLocktime <= 0n) {
-      throw new Error("refund locktime must be greater than 0");
+    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;
     }
-    if (!unilateralClaimDelay || typeof unilateralClaimDelay.value !== "bigint" || unilateralClaimDelay.value <= 0n) {
-      throw new Error("unilateral claim delay must greater than 0");
+    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;
     }
-    if (unilateralClaimDelay.type === "seconds" && unilateralClaimDelay.value % 512n !== 0n) {
-      throw new Error("seconds timelock must be multiple of 512");
+    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 (unilateralClaimDelay.type === "seconds" && unilateralClaimDelay.value < 512n) {
-      throw new Error("seconds timelock must be greater or equal to 512");
+    if (clean) {
+      this.buffers = [];
+      for (const p of this.ptrs)
+        p.buffer.fill(0);
+      this.ptrs = [];
+      this.finished = true;
+      this.bitBuf = 0;
     }
-    if (!unilateralRefundDelay || typeof unilateralRefundDelay.value !== "bigint" || unilateralRefundDelay.value <= 0n) {
-      throw new Error("unilateral refund delay must greater than 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++;
+      }
     }
-    if (unilateralRefundDelay.type === "seconds" && unilateralRefundDelay.value % 512n !== 0n) {
-      throw new Error("seconds timelock must be multiple of 512");
+  }
+};
+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;
     }
-    if (unilateralRefundDelay.type === "seconds" && unilateralRefundDelay.value < 512n) {
-      throw new Error("seconds timelock must be greater or equal to 512");
+  };
+}
+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);
+      }
     }
-    if (!unilateralRefundWithoutReceiverDelay || typeof unilateralRefundWithoutReceiverDelay.value !== "bigint" || unilateralRefundWithoutReceiverDelay.value <= 0n) {
-      throw new Error("unilateral refund without receiver delay must greater than 0");
+  });
+}
+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}`);
     }
-    if (unilateralRefundWithoutReceiverDelay.type === "seconds" && unilateralRefundWithoutReceiverDelay.value % 512n !== 0n) {
-      throw new Error("seconds timelock must be multiple of 512");
+  };
+  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(OP)) {
+    if (typeof value === "number") {
+      const name = key.startsWith("OP_") ? key : `OP_${key}`;
+      names[value] = name;
     }
-    if (unilateralRefundWithoutReceiverDelay.type === "seconds" && unilateralRefundWithoutReceiverDelay.value < 512n) {
-      throw new Error("seconds timelock must be greater or equal to 512");
+  }
+  names[0] = "OP_0";
+  return names;
+}
+function buildBitcoinOpcodeValues() {
+  const values = {};
+  for (const [key, value] of Object.entries(OP)) {
+    if (typeof value === "number") {
+      const name = key.startsWith("OP_") ? key : `OP_${key}`;
+      values[name] = value;
+      values[key] = value;
     }
   }
-})(VHTLC || (VHTLC = {}));
-function preimageConditionScript(preimageHash) {
-  return Script.encode(["HASH160", preimageHash, "EQUAL"]);
+  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/contracts/handlers/vhtlc.ts
-var VHTLCContractHandler = {
-  type: "vhtlc",
-  createScript(params) {
-    const typed = this.deserializeParams(params);
-    return new VHTLC.Script(typed);
-  },
-  serializeParams(params) {
-    return {
-      sender: hex.encode(params.sender),
-      receiver: hex.encode(params.receiver),
-      server: hex.encode(params.server),
-      hash: hex.encode(params.preimageHash),
-      refundLocktime: params.refundLocktime.toString(),
-      claimDelay: timelockToSequence(params.unilateralClaimDelay).toString(),
-      refundDelay: timelockToSequence(params.unilateralRefundDelay).toString(),
-      refundNoReceiverDelay: timelockToSequence(
-        params.unilateralRefundWithoutReceiverDelay
-      ).toString()
-    };
-  },
-  deserializeParams(params) {
-    return {
-      sender: hex.decode(params.sender),
-      receiver: hex.decode(params.receiver),
-      server: hex.decode(params.server),
-      preimageHash: hex.decode(params.hash),
-      refundLocktime: BigInt(params.refundLocktime),
-      unilateralClaimDelay: sequenceToTimelock(Number(params.claimDelay)),
-      unilateralRefundDelay: sequenceToTimelock(Number(params.refundDelay)),
-      unilateralRefundWithoutReceiverDelay: 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: [hex.decode(preimage)]
-        };
+// src/arkade/bignum.ts
+var bignum_exports = {};
+__export(bignum_exports, {
+  BIGNUM_MAX_BYTES: () => BIGNUM_MAX_BYTES,
+  decode: () => decode,
+  encode: () => encode
+});
+var BIGNUM_MAX_BYTES = 520;
+var codec = 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 = { ...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") {
+        const big = typeof o === "number" ? BigInt(o) : o;
+        o = encode(big);
       }
-      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
-        return {
-          leaf: script.refundWithoutReceiver()
-        };
+      if (!(o instanceof Uint8Array)) throw new Error(`Wrong Script OP=${o} (${typeof o})`);
+      const len = o.length;
+      if (len === 1 && o[0] >= 1 && o[0] <= 16) {
+        w.byte(OP.OP_1 - 1 + o[0]);
+        continue;
+      } else if (len === 1 && o[0] === 129) {
+        w.byte(OP["1NEGATE"]);
+        continue;
+      } else if (len < OP.PUSHDATA1) w.byte(len);
+      else if (len <= 255) {
+        w.byte(OP.PUSHDATA1);
+        w.byte(len);
+      } else if (len <= 65535) {
+        w.byte(OP.PUSHDATA2);
+        w.bytes(U16LE.encode(len));
+      } else {
+        w.byte(OP.PUSHDATA4);
+        w.bytes(U32LE.encode(len));
       }
-      return null;
-    }
-    if (role === "receiver" && preimage) {
-      const sequence = Number(contract.params.claimDelay);
-      if (!isCsvSpendable(context, sequence)) return null;
-      return {
-        leaf: script.unilateralClaim(),
-        extraWitness: [hex.decode(preimage)],
-        sequence
-      };
-    }
-    if (role === "sender") {
-      const sequence = Number(contract.params.refundNoReceiverDelay);
-      if (!isCsvSpendable(context, sequence)) return null;
-      return {
-        leaf: script.unilateralRefundWithoutReceiver(),
-        sequence
-      };
+      w.bytes(o);
     }
-    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: [hex.decode(preimage)]
-        });
+  decodeStream: (r) => {
+    const out = [];
+    while (!r.isEnd()) {
+      const cur = r.byte();
+      if (OP.OP_0 < cur && cur <= OP.PUSHDATA4) {
+        let len;
+        if (cur < OP.PUSHDATA1) len = cur;
+        else if (cur === OP.PUSHDATA1) len = U8.decodeStream(r);
+        else if (cur === OP.PUSHDATA2) len = U16LE.decodeStream(r);
+        else if (cur === 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 (OP.OP_1 <= cur && cur <= OP.OP_16) {
+        out.push(cur - (OP.OP_1 - 1));
+      } else if (cur === 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);
       }
-      if (role === "sender") {
-        paths.push({
-          leaf: script.refundWithoutReceiver()
-        });
+    }
+    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(hex.encode(encode(BigInt(op))));
       }
     } else {
-      if (role === "receiver" && preimage) {
-        const sequence = Number(contract.params.claimDelay);
-        paths.push({
-          leaf: script.unilateralClaim(),
-          extraWitness: [hex.decode(preimage)],
-          sequence
-        });
-      }
-      if (role === "sender") {
-        const sequence = Number(contract.params.refundNoReceiverDelay);
-        paths.push({
-          leaf: script.unilateralRefundWithoutReceiver(),
-          sequence
-        });
-      }
+      parts.push(hex.encode(op));
     }
-    return paths;
-  },
-  getSpendablePaths(script, contract, context) {
-    const role = resolveRole(contract, context);
-    const paths = [];
-    if (!role) {
-      return paths;
+  }
+  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;
     }
-    const preimage = contract.params?.preimage;
-    const refundLocktime = BigInt(contract.params.refundLocktime);
-    if (context.collaborative) {
-      if (role === "receiver" && preimage) {
-        paths.push({
-          leaf: script.claim(),
-          extraWitness: [hex.decode(preimage)]
-        });
-      }
-      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
-        paths.push({
-          leaf: script.refundWithoutReceiver()
-        });
-      }
-      return paths;
+    if (token === "OP_TRUE") {
+      out.push(1);
+      continue;
     }
-    if (role === "receiver" && preimage) {
-      const sequence = Number(contract.params.claimDelay);
-      if (isCsvSpendable(context, sequence)) {
-        paths.push({
-          leaf: script.unilateralClaim(),
-          extraWitness: [hex.decode(preimage)],
-          sequence
-        });
+    const numMatch = token.match(/^OP_(\d+)$/);
+    if (numMatch) {
+      const n = parseInt(numMatch[1], 10);
+      if (n >= 1 && n <= 16) {
+        out.push(n);
+        continue;
       }
     }
-    if (role === "sender") {
-      const sequence = Number(contract.params.refundNoReceiverDelay);
-      if (isCsvSpendable(context, sequence)) {
-        paths.push({
-          leaf: script.unilateralRefundWithoutReceiver(),
-          sequence
-        });
-      }
+    let key;
+    if (token.startsWith("OP_")) {
+      key = token.slice(3);
+    } else {
+      key = token;
     }
-    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 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 = hex.encode(script.pkScript);
-    const boardingSeq = timelockToSequence(deps.boardingTimelock);
-    return [
-      {
-        type: "boarding",
-        params: {
-          pubKey: hex.encode(pubKey),
-          serverPubKey: 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`.
-        ...rotatedReceiveMetadata(index, descriptor)
+    if (key in ARKADE_OPS) {
+      out.push(key);
+      continue;
+    }
+    if (/^[0-9a-fA-F]+$/.test(token) && token.length % 2 === 0) {
+      try {
+        out.push(hex.decode(token));
+        continue;
+      } catch {
       }
-    ];
+    }
+    throw new Error(`Invalid ASM token: ${token}`);
   }
-};
-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;
+  return out;
 }
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+function asmToBytes(asm) {
+  return ArkadeScript.encode(fromASM(asm));
 }
-var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
+function bytesToASM(script) {
+  return toASM(ArkadeScript.decode(script));
 }
-function isNum(num) {
-  return Number.isSafeInteger(num);
+var TAG_SCRIPT = "ArkScriptHash";
+var TAG_WITNESS = "ArkWitnessHash";
+function arkadeScriptHash(script) {
+  return schnorr.utils.taggedHash(TAG_SCRIPT, script);
 }
-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);
+function arkadeWitnessHash(witness) {
+  if (witness.length === 0) {
+    return new Uint8Array(32);
+  }
+  return 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 = schnorr.utils.lift_x(bytesToNumberBE(xOnly));
+  const scalar = bytesToNumberBE(hash) % secp256k1.Point.CURVE().n;
+  const tweak = secp256k1.Point.BASE.multiply(scalar);
+  return schnorr.utils.pointToBytes(point.add(tweak));
+}
+
+// src/script/vhtlc.ts
+var VHTLC;
+((VHTLC2) => {
+  class BaseScript extends VtxoScript {
+    options;
+    claimScript;
+    refundScript;
+    refundWithoutReceiverScript;
+    unilateralClaimScript;
+    unilateralRefundScript;
+    unilateralRefundWithoutReceiverScript;
+    nonInteractiveClaimScript;
+    nonInteractiveClaimArkadeScript;
+    nonInteractiveRefundScript;
+    nonInteractiveRefundArkadeScript;
+    constructor(options, preimageCondition) {
+      validateOptions(options);
+      const {
+        sender,
+        receiver,
+        server,
+        preimageHash,
+        refundLocktime,
+        unilateralClaimDelay,
+        unilateralRefundDelay,
+        unilateralRefundWithoutReceiverDelay
+      } = options;
+      const conditionScript = preimageCondition(preimageHash);
+      const claimScript = ConditionMultisigTapscript.encode({
+        conditionScript,
+        pubkeys: [receiver, server]
+      }).script;
+      const refundScript = MultisigTapscript.encode({
+        pubkeys: [sender, receiver, server]
+      }).script;
+      const refundWithoutReceiverScript = CLTVMultisigTapscript.encode({
+        absoluteTimelock: refundLocktime,
+        pubkeys: [sender, server]
+      }).script;
+      const unilateralClaimScript = ConditionCSVMultisigTapscript.encode({
+        conditionScript,
+        timelock: unilateralClaimDelay,
+        pubkeys: [receiver]
+      }).script;
+      const unilateralRefundScript = CSVMultisigTapscript.encode({
+        timelock: unilateralRefundDelay,
+        pubkeys: [sender, receiver]
+      }).script;
+      const unilateralRefundWithoutReceiverScript = CSVMultisigTapscript.encode({
+        timelock: unilateralRefundWithoutReceiverDelay,
+        pubkeys: [sender]
+      }).script;
+      const scripts = [
+        claimScript,
+        refundScript,
+        refundWithoutReceiverScript,
+        unilateralClaimScript,
+        unilateralRefundScript,
+        unilateralRefundWithoutReceiverScript
+      ];
+      let arkadeScriptNic;
+      let nonInteractiveClaimScript;
+      if (options.nonInteractiveClaim) {
+        arkadeScriptNic = enforcePayTo(options.nonInteractiveClaim.receiverPkScript);
+        nonInteractiveClaimScript = ConditionMultisigTapscript.encode({
+          conditionScript,
+          pubkeys: [
+            server,
+            computeArkadeScriptPublicKey(
+              options.nonInteractiveClaim.emulatorPubkey,
+              arkadeScriptNic
+            )
+          ]
+        }).script;
+        scripts.push(nonInteractiveClaimScript);
+      }
+      let arkadeScriptNir;
+      let nonInteractiveRefundScript;
+      if (options.nonInteractiveRefund) {
+        arkadeScriptNir = enforcePayTo(options.nonInteractiveRefund.senderPkScript);
+        nonInteractiveRefundScript = MultisigTapscript.encode({
+          pubkeys: [
+            server,
+            receiver,
+            computeArkadeScriptPublicKey(
+              options.nonInteractiveRefund.emulatorPubkey,
+              arkadeScriptNir
+            )
+          ]
+        }).script;
+        scripts.push(nonInteractiveRefundScript);
+      }
+      super(scripts);
+      this.options = options;
+      this.claimScript = hex.encode(claimScript);
+      this.refundScript = hex.encode(refundScript);
+      this.refundWithoutReceiverScript = hex.encode(refundWithoutReceiverScript);
+      this.unilateralClaimScript = hex.encode(unilateralClaimScript);
+      this.unilateralRefundScript = hex.encode(unilateralRefundScript);
+      this.unilateralRefundWithoutReceiverScript = hex.encode(
+        unilateralRefundWithoutReceiverScript
+      );
+      if (nonInteractiveClaimScript) {
+        this.nonInteractiveClaimScript = hex.encode(nonInteractiveClaimScript);
+        this.nonInteractiveClaimArkadeScript = arkadeScriptNic;
+      }
+      if (nonInteractiveRefundScript) {
+        this.nonInteractiveRefundScript = hex.encode(nonInteractiveRefundScript);
+        this.nonInteractiveRefundArkadeScript = arkadeScriptNir;
       }
     }
-    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;
+    /** Return the collaborative claim tapleaf script. */
+    claim() {
+      return this.findLeaf(this.claimScript);
     }
-    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 the collaborative refund tapleaf script. */
+    refund() {
+      return this.findLeaf(this.refundScript);
     }
-    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;
+    /** Return the refund-without-receiver tapleaf script. */
+    refundWithoutReceiver() {
+      return this.findLeaf(this.refundWithoutReceiverScript);
     }
-    let cur = objPath.pop();
-    for (; i < parts.length; i++) {
-      if (!cur || cur[parts[i]] === void 0)
-        return void 0;
-      cur = cur[parts[i]];
+    /** Return the unilateral claim tapleaf script. */
+    unilateralClaim() {
+      return this.findLeaf(this.unilateralClaimScript);
     }
-    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: ${hex.encode(this.data.slice(this.pos))}`);
+    /** Return the unilateral refund tapleaf script. */
+    unilateralRefund() {
+      return this.findLeaf(this.unilateralRefundScript);
     }
-    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})[${hex.encode(this.data.subarray(pos, pos + length))}]`).join(", ");
-        throw this.err(`unread byte ranges: ${formatted} (total=${this.data.length})`);
-      } else
-        return;
+    /** Return the unilateral refund-without-receiver tapleaf script. */
+    unilateralRefundWithoutReceiver() {
+      return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
     }
-    if (!this.isEnd()) {
-      throw this.err(`${this.leftBytes} bytes ${this.bitPos} bits left after unpack: ${hex.encode(this.data.slice(this.pos))}`);
+    /** Return the non-interactive claim tapleaf script as well as the ArkadeScript. */
+    nonInteractiveClaim() {
+      if (!this.nonInteractiveClaimScript || !this.nonInteractiveClaimArkadeScript) {
+        throw new Error("VHTLC has no non-interactive claim leaf");
+      }
+      return [
+        this.findLeaf(this.nonInteractiveClaimScript),
+        this.nonInteractiveClaimArkadeScript
+      ];
+    }
+    /** Return the non-interactive refund tapleaf script as well as the ArkadeScript. */
+    nonInteractiveRefund() {
+      if (!this.nonInteractiveRefundScript || !this.nonInteractiveRefundArkadeScript) {
+        throw new Error("VHTLC has no non-interactive refund leaf");
+      }
+      return [
+        this.findLeaf(this.nonInteractiveRefundScript),
+        this.nonInteractiveRefundArkadeScript
+      ];
     }
   }
-  // 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;
+  class Script3 extends BaseScript {
+    constructor(options) {
+      super(options, preimageConditionScript);
     }
-    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;
+  VHTLC2.Script = Script3;
+  class ScriptV2 extends BaseScript {
+    constructor(options) {
+      super(options, preimageConditionScriptV2);
     }
-    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;
+  VHTLC2.ScriptV2 = ScriptV2;
+  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 (clean) {
-      this.buffers = [];
-      for (const p of this.ptrs)
-        p.buffer.fill(0);
-      this.ptrs = [];
-      this.finished = true;
-      this.bitBuf = 0;
+    if (options.nonInteractiveClaim) {
+      const { emulatorPubkey, receiverPkScript } = options.nonInteractiveClaim;
+      if (!emulatorPubkey || emulatorPubkey.length !== 32 && emulatorPubkey.length !== 33) {
+        throw new Error("Invalid public key length (emulator)");
+      }
+      if (!receiverPkScript || !isP2trPkScript(receiverPkScript)) {
+        throw new Error("Invalid P2TR script");
+      }
     }
-    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++;
+    if (options.nonInteractiveRefund) {
+      const { emulatorPubkey, senderPkScript } = options.nonInteractiveRefund;
+      if (!emulatorPubkey || emulatorPubkey.length !== 32 && emulatorPubkey.length !== 33) {
+        throw new Error("Invalid public key length (emulator)");
+      }
+      if (!senderPkScript || !isP2trPkScript(senderPkScript)) {
+        throw new Error("Invalid P2TR script");
       }
     }
-  }
-};
-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;
+    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");
+    }
+  }
+})(VHTLC || (VHTLC = {}));
+function preimageConditionScript(preimageHash) {
+  return Script.encode(["HASH160", preimageHash, "EQUAL"]);
 }
-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);
+function preimageConditionScriptV2(preimageHash) {
+  return Script.encode(["SIZE", 32, "EQUALVERIFY", "HASH160", preimageHash, "EQUAL"]);
+}
+function isP2trPkScript(pkScript) {
+  return pkScript.length === 34 && pkScript[0] === 81 && pkScript[1] === 32;
+}
+function enforcePayTo(destinationPkScript) {
+  if (!isP2trPkScript(destinationPkScript)) {
+    throw new Error("invalid P2TR script");
+  }
+  return ArkadeScript.encode([
+    "PUSHCURRENTINPUTINDEX",
+    "DUP",
+    "INSPECTOUTPUTSCRIPTPUBKEY",
+    1,
+    "EQUALVERIFY",
+    destinationPkScript.subarray(2),
+    "EQUALVERIFY",
+    "INSPECTOUTPUTVALUE",
+    "PUSHCURRENTINPUTINDEX",
+    "INSPECTINPUTVALUE",
+    "GREATERTHANOREQUAL"
+  ]);
+}
+
+// src/contracts/handlers/vhtlc.ts
+var VHTLCContractHandler = {
+  type: "vhtlc",
+  createScript(params) {
+    const typed = this.deserializeParams(params);
+    return new VHTLC.Script(typed);
+  },
+  serializeParams(params) {
+    return {
+      sender: hex.encode(params.sender),
+      receiver: hex.encode(params.receiver),
+      server: hex.encode(params.server),
+      hash: hex.encode(params.preimageHash),
+      refundLocktime: params.refundLocktime.toString(),
+      claimDelay: timelockToSequence(params.unilateralClaimDelay).toString(),
+      refundDelay: timelockToSequence(params.unilateralRefundDelay).toString(),
+      refundNoReceiverDelay: timelockToSequence(
+        params.unilateralRefundWithoutReceiverDelay
+      ).toString()
+    };
+  },
+  deserializeParams(params) {
+    return {
+      sender: hex.decode(params.sender),
+      receiver: hex.decode(params.receiver),
+      server: hex.decode(params.server),
+      preimageHash: hex.decode(params.hash),
+      refundLocktime: BigInt(params.refundLocktime),
+      unilateralClaimDelay: sequenceToTimelock(Number(params.claimDelay)),
+      unilateralRefundDelay: sequenceToTimelock(Number(params.refundDelay)),
+      unilateralRefundWithoutReceiverDelay: 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: [hex.decode(preimage)]
+        };
       }
-      inner.encodeStream(w, res);
-    },
-    decodeStream: (r) => {
-      const res = inner.decodeStream(r);
-      try {
-        return fn(res);
-      } catch (e) {
-        throw r.err(e);
+      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
+        return {
+          leaf: script.refundWithoutReceiver()
+        };
       }
+      return null;
     }
-  });
-}
-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}`);
+    if (role === "receiver" && preimage) {
+      const sequence = Number(contract.params.claimDelay);
+      if (!isCsvSpendable(context, sequence)) return null;
+      return {
+        leaf: script.unilateralClaim(),
+        extraWitness: [hex.decode(preimage)],
+        sequence
+      };
     }
-  };
-  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(OP)) {
-    if (typeof value === "number") {
-      const name = key.startsWith("OP_") ? key : `OP_${key}`;
-      names[value] = name;
+    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: [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: [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;
     }
-  }
-  names[0] = "OP_0";
-  return names;
-}
-function buildBitcoinOpcodeValues() {
-  const values = {};
-  for (const [key, value] of Object.entries(OP)) {
-    if (typeof value === "number") {
-      const name = key.startsWith("OP_") ? key : `OP_${key}`;
-      values[name] = value;
-      values[key] = value;
+    const preimage = contract.params?.preimage;
+    const refundLocktime = BigInt(contract.params.refundLocktime);
+    if (context.collaborative) {
+      if (role === "receiver" && preimage) {
+        paths.push({
+          leaf: script.claim(),
+          extraWitness: [hex.decode(preimage)]
+        });
+      }
+      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
+        paths.push({
+          leaf: script.refundWithoutReceiver()
+        });
+      }
+      return paths;
     }
-  }
-  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;
+    if (role === "receiver" && preimage) {
+      const sequence = Number(contract.params.claimDelay);
+      if (isCsvSpendable(context, sequence)) {
+        paths.push({
+          leaf: script.unilateralClaim(),
+          extraWitness: [hex.decode(preimage)],
+          sequence
+        });
+      }
     }
-    return void 0;
+    if (role === "sender") {
+      const sequence = Number(contract.params.refundNoReceiverDelay);
+      if (isCsvSpendable(context, sequence)) {
+        paths.push({
+          leaf: script.unilateralRefundWithoutReceiver(),
+          sequence
+        });
+      }
+    }
+    return paths;
+  },
+  /**
+   * Refuse an explicit spend of a lockup whose refund path has not opened.
+   * Shared with the v2 handler so the two cannot drift.
+   * @see assertVhtlcSpendableNow for why this is the one certain case.
+   */
+  assertSpendableNow(_script, contract, context) {
+    assertVhtlcSpendableNow(contract, context);
+  },
+  /**
+   * Never. A live VHTLC is escrow: the counterparty's claim leaf is armed,
+   * and generic selection — send, settle, renewal, offboard — would move the
+   * lockup out from under a swap the counterparty is still entitled to
+   * complete, or race a claim already in flight.
+   *
+   * Two narrow reasons, and neither is "spending this would destroy the
+   * VTXO". It would not: the leaf {@link deriveTapscripts} stamps is
+   * `refundWithoutReceiver` — `CLTV[sender, server]`, the sender's OWN
+   * refund, which the server rejects until `refundLocktime` matures. The
+   * reasons are that an escrowed lockup must not count toward the
+   * `available` balance bucket, and that generic RENEWAL must not silently
+   * execute a refund the caller never asked for — `runPeriodicSettle` selects
+   * through `getSpendableVtxos`, which this gate filters, and it runs
+   * unprompted whenever a wallet is built without an explicit
+   * `settlementConfig`.
+   *
+   * **Inseparable from {@link deriveTapscripts}.** Deriving the leaf without
+   * closing the gate hands generic renewal an escrow it had never been
+   * offered before; before that method existed the answer here was
+   * unobservable, so the two only ever made sense together.
+   *
+   * Recovery is filtered on {@link assertSpendableNow}, not on this: the gate
+   * is permanent, and applying it there would strand a matured lockup.
+   */
+  isGenericallySpendable: () => false,
+  /**
+   * The annotation leaf stamped onto every VTXO locked to this contract.
+   *
+   * **Without this the contract is unusable, not merely unoptimized.**
+   * `deriveContractTapscripts` falls back to `script.forfeit()` for any
+   * handler that does not implement {@link TapscriptDeriving}, and no VHTLC
+   * script version has a `forfeit()` — `VtxoScript` does not define one and
+   * `VHTLC.BaseScript` does not add one. The fallback therefore threw
+   * `legacy.forfeit is not a function`, `annotatableIn` caught it, and
+   * `fetchContractVtxosBulk` dropped this contract's VTXOs before they were
+   * persisted. The row existed and was watched while its balance stayed
+   * permanently invisible, and `getSyncState()` reported `degraded` forever.
+   *
+   * `refundWithoutReceiver` is the leaf, for both roles the annotation
+   * serves, because it is the only collaborative path this wallet can
+   * actually satisfy as the sender — the same conclusion `selectPath`
+   * reaches, kept in step with it deliberately. The claim leaves belong to
+   * the receiver and need a preimage the sender does not have; `refund` and
+   * `unilateralRefund` both need the counterparty's signature, which this
+   * protocol has no message to ask for. V1 has no covenant leaves at all.
+   *
+   * **It carries a CLTV, and callers must respect it.** A settlement built
+   * on this leaf is only valid once `refundLocktime` has matured, so a
+   * recovery round that sweeps this VTXO early is rejected by the server.
+   * Nothing in this handler can enforce that, because the annotation is
+   * derived per contract and knows no clock; `recoverVtxos` filters on
+   * {@link assertSpendableNow} for it.
+   *
+   * **Role-blind.** A receiver's row gets the same leaf, which names keys that
+   * wallet does not hold, so it is satisfiable only by the wallet holding the
+   * lockup's `sender` key and fails at intent registration for anyone else.
+   */
+  deriveTapscripts(script) {
+    const leaf = script.refundWithoutReceiver();
+    return {
+      forfeitTapLeafScript: leaf,
+      intentTapLeafScript: leaf,
+      tapTree: script.encode()
+    };
   }
-  return OPCODE_VALUES[name];
-}
-
-// src/arkade/bignum.ts
-var bignum_exports = {};
-__export(bignum_exports, {
-  BIGNUM_MAX_BYTES: () => BIGNUM_MAX_BYTES,
-  decode: () => decode,
-  encode: () => encode
-});
-var BIGNUM_MAX_BYTES = 520;
-var codec = 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)`);
+};
+function decodeCovenantLeaf(params, destinationKey, emulatorKey, label) {
+  const destination = params[destinationKey];
+  const emulator = params[emulatorKey];
+  if (!destination && !emulator) return void 0;
+  if (!destination || !emulator) {
+    throw new Error(`${label} needs both '${destinationKey}' and '${emulatorKey}', or neither`);
   }
-  return result;
-}
-function decode(value) {
-  return codec.decode(value);
-}
-
-// src/arkade/script.ts
-var ARKADE_OPS = { ...OP, ...ARKADE_OP };
-var ArkadeOPNames = {};
-for (const [k, v] of Object.entries(ARKADE_OPS)) {
-  if (typeof v === "number") ArkadeOPNames[v] = k;
+  return { destination: hex.decode(destination), emulatorPubkey: hex.decode(emulator) };
 }
-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(OP.OP_1 - 1 + Number(o));
-          continue;
-        } else if (o === -1 || o === -1n) {
-          w.byte(OP["1NEGATE"]);
-          continue;
+var VHTLCV2ContractHandler = {
+  type: "vhtlc-v2",
+  createScript(params) {
+    const typed = this.deserializeParams(params);
+    return new VHTLC.ScriptV2(typed);
+  },
+  serializeParams(params) {
+    return {
+      sender: hex.encode(params.sender),
+      receiver: hex.encode(params.receiver),
+      server: hex.encode(params.server),
+      hash: hex.encode(params.preimageHash),
+      refundLocktime: params.refundLocktime.toString(),
+      claimDelay: timelockToSequence(params.unilateralClaimDelay).toString(),
+      refundDelay: timelockToSequence(params.unilateralRefundDelay).toString(),
+      refundNoReceiverDelay: timelockToSequence(
+        params.unilateralRefundWithoutReceiverDelay
+      ).toString(),
+      // Spread rather than written as `undefined`: a `Record<string,
+      // string>` round-tripped through a repository must not gain keys
+      // whose value is the string "undefined".
+      ...params.nonInteractiveClaim && {
+        nonInteractiveClaimReceiverPkScript: hex.encode(
+          params.nonInteractiveClaim.receiverPkScript
+        ),
+        nonInteractiveClaimEmulatorPubkey: hex.encode(
+          params.nonInteractiveClaim.emulatorPubkey
+        )
+      },
+      ...params.nonInteractiveRefund && {
+        nonInteractiveRefundSenderPkScript: hex.encode(
+          params.nonInteractiveRefund.senderPkScript
+        ),
+        nonInteractiveRefundEmulatorPubkey: hex.encode(
+          params.nonInteractiveRefund.emulatorPubkey
+        )
+      }
+    };
+  },
+  deserializeParams(params) {
+    const claim = decodeCovenantLeaf(
+      params,
+      "nonInteractiveClaimReceiverPkScript",
+      "nonInteractiveClaimEmulatorPubkey",
+      "nonInteractiveClaim"
+    );
+    const refund = decodeCovenantLeaf(
+      params,
+      "nonInteractiveRefundSenderPkScript",
+      "nonInteractiveRefundEmulatorPubkey",
+      "nonInteractiveRefund"
+    );
+    return {
+      sender: hex.decode(params.sender),
+      receiver: hex.decode(params.receiver),
+      server: hex.decode(params.server),
+      preimageHash: hex.decode(params.hash),
+      refundLocktime: BigInt(params.refundLocktime),
+      unilateralClaimDelay: sequenceToTimelock(Number(params.claimDelay)),
+      unilateralRefundDelay: sequenceToTimelock(Number(params.refundDelay)),
+      unilateralRefundWithoutReceiverDelay: sequenceToTimelock(
+        Number(params.refundNoReceiverDelay)
+      ),
+      ...claim && {
+        nonInteractiveClaim: {
+          receiverPkScript: claim.destination,
+          emulatorPubkey: claim.emulatorPubkey
+        }
+      },
+      ...refund && {
+        nonInteractiveRefund: {
+          senderPkScript: refund.destination,
+          emulatorPubkey: refund.emulatorPubkey
         }
-        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 < OP.PUSHDATA1) w.byte(len);
-      else if (len <= 255) {
-        w.byte(OP.PUSHDATA1);
-        w.byte(len);
-      } else if (len <= 65535) {
-        w.byte(OP.PUSHDATA2);
-        w.bytes(U16LE.encode(len));
-      } else {
-        w.byte(OP.PUSHDATA4);
-        w.bytes(U32LE.encode(len));
+    };
+  },
+  /**
+   * 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: [hex.decode(preimage)]
+        };
       }
-      w.bytes(o);
+      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: [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;
   },
-  decodeStream: (r) => {
-    const out = [];
-    while (!r.isEnd()) {
-      const cur = r.byte();
-      if (OP.OP_0 < cur && cur <= OP.PUSHDATA4) {
-        let len;
-        if (cur < OP.PUSHDATA1) len = cur;
-        else if (cur === OP.PUSHDATA1) len = U8.decodeStream(r);
-        else if (cur === OP.PUSHDATA2) len = U16LE.decodeStream(r);
-        else if (cur === 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 (OP.OP_1 <= cur && cur <= OP.OP_16) {
-        out.push(cur - (OP.OP_1 - 1));
-      } else if (cur === 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);
-      }
+  /**
+   * 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;
     }
-    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(hex.encode(encode(BigInt(op))));
+    const preimage = contract.params?.preimage;
+    if (context.collaborative) {
+      if (role === "receiver" && preimage) {
+        paths.push({
+          leaf: script.claim(),
+          extraWitness: [hex.decode(preimage)]
+        });
+      }
+      if (role === "sender") {
+        paths.push({
+          leaf: script.refundWithoutReceiver()
+        });
       }
     } else {
-      parts.push(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 (role === "receiver" && preimage) {
+        const sequence = Number(contract.params.claimDelay);
+        paths.push({
+          leaf: script.unilateralClaim(),
+          extraWitness: [hex.decode(preimage)],
+          sequence
+        });
+      }
+      if (role === "sender") {
+        const sequence = Number(contract.params.refundNoReceiverDelay);
+        paths.push({
+          leaf: script.unilateralRefundWithoutReceiver(),
+          sequence
+        });
+      }
     }
-    if (token === "OP_TRUE") {
-      out.push(1);
-      continue;
+    return paths;
+  },
+  getSpendablePaths(script, contract, context) {
+    const role = resolveRole(contract, context);
+    const paths = [];
+    if (!role) {
+      return paths;
     }
-    const numMatch = token.match(/^OP_(\d+)$/);
-    if (numMatch) {
-      const n = parseInt(numMatch[1], 10);
-      if (n >= 1 && n <= 16) {
-        out.push(n);
-        continue;
+    const preimage = contract.params?.preimage;
+    const refundLocktime = BigInt(contract.params.refundLocktime);
+    if (context.collaborative) {
+      if (role === "receiver" && preimage) {
+        paths.push({
+          leaf: script.claim(),
+          extraWitness: [hex.decode(preimage)]
+        });
       }
+      if (role === "sender" && isCltvSatisfied(context, refundLocktime)) {
+        paths.push({
+          leaf: script.refundWithoutReceiver()
+        });
+      }
+      return paths;
     }
-    let key;
-    if (token.startsWith("OP_")) {
-      key = token.slice(3);
-    } else {
-      key = token;
-    }
-    if (key in ARKADE_OPS) {
-      out.push(key);
-      continue;
+    if (role === "receiver" && preimage) {
+      const sequence = Number(contract.params.claimDelay);
+      if (isCsvSpendable(context, sequence)) {
+        paths.push({
+          leaf: script.unilateralClaim(),
+          extraWitness: [hex.decode(preimage)],
+          sequence
+        });
+      }
     }
-    if (/^[0-9a-fA-F]+$/.test(token) && token.length % 2 === 0) {
-      try {
-        out.push(hex.decode(token));
-        continue;
-      } catch {
+    if (role === "sender") {
+      const sequence = Number(contract.params.refundNoReceiverDelay);
+      if (isCsvSpendable(context, sequence)) {
+        paths.push({
+          leaf: script.unilateralRefundWithoutReceiver(),
+          sequence
+        });
       }
     }
-    throw new Error(`Invalid ASM token: ${token}`);
+    return paths;
+  },
+  /**
+   * Refuse an explicit spend of a lockup whose refund path has not opened.
+   * @see assertVhtlcSpendableNow for why this is the one certain case.
+   */
+  assertSpendableNow(_script, contract, context) {
+    assertVhtlcSpendableNow(contract, context);
+  },
+  /**
+   * Never. A live VHTLC is escrow: the counterparty's claim leaf is armed,
+   * and generic selection — send, settle, RENEWAL, offboard — would move the
+   * lockup out from under a swap the counterparty is still entitled to
+   * complete, or race a claim already in flight. The `vhtlc` handler now
+   * answers the same, for the same reason.
+   *
+   * The gate covers `available` and renewal. Recovery is generic and names
+   * nothing, so it is not covered here: `recoverVtxos` filters on
+   * {@link assertSpendableNow} instead, which drops a lockup only while its
+   * refund path is shut rather than forever. The explicit routes out —
+   * `settle({ inputs })`, or `@arkade-os/swap`'s `pushRefundWithoutReceiver`
+   * over `findLockupVtxos`' outpoints — are unaffected either way.
+   */
+  isGenericallySpendable: () => false,
+  /**
+   * The annotation leaf stamped onto every VTXO locked to this contract.
+   *
+   * **Without this the contract is unusable, not merely unoptimized.**
+   * `deriveContractTapscripts` falls back to `script.forfeit()` for any
+   * handler that does not implement {@link TapscriptDeriving}, and no VHTLC
+   * script version has a `forfeit()` — `VtxoScript` does not define one and
+   * `VHTLC.BaseScript` does not add one. The fallback therefore throws
+   * `legacy.forfeit is not a function`, `annotatableIn` catches it, and
+   * `fetchContractVtxosBulk` drops this contract's VTXOs before they are
+   * persisted. The row would exist and be watched while its balance stayed
+   * permanently invisible, and `getSyncState()` would report `degraded`
+   * forever. (The `vhtlc` handler had the same gap and now closes it the same
+   * way; nothing registers V1 rows through `ContractManager` in this repo, so
+   * it was never hit here.)
+   *
+   * `refundWithoutReceiver` is the leaf, for both roles the annotation
+   * serves, because it is the only collaborative path this wallet can
+   * actually satisfy as the sender — the same conclusion `selectPath`
+   * reaches, kept in step with it deliberately. The claim leaves belong to
+   * the receiver and need a preimage the sender does not have; `refund` and
+   * `unilateralRefund` need the counterparty; the covenant leaves are the
+   * emulator's.
+   *
+   * **It carries a CLTV, and callers must respect it.** A settlement built on
+   * this leaf is only valid once `refundLocktime` has matured, so a recovery
+   * round that sweeps this VTXO early is rejected by the server. That is the
+   * same constraint `packages/boltz-swap` encodes as "pre-CLTV recoverable →
+   * skipped"; nothing in this handler can enforce it, because the annotation
+   * is derived per contract and knows no clock. `recoverVtxos` filters on
+   * {@link assertSpendableNow} for it.
+   *
+   * **Role-blind.** A receiver's row gets the same leaf, which names keys that
+   * wallet does not hold, so it is satisfiable only by the wallet holding the
+   * lockup's `sender` key and fails at intent registration for anyone else.
+   */
+  deriveTapscripts(script) {
+    const leaf = script.refundWithoutReceiver();
+    return {
+      forfeitTapLeafScript: leaf,
+      intentTapLeafScript: leaf,
+      tapTree: script.encode()
+    };
   }
-  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 schnorr.utils.taggedHash(TAG_SCRIPT, script);
-}
-function arkadeWitnessHash(witness) {
-  if (witness.length === 0) {
-    return new Uint8Array(32);
+};
+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);
+  },
+  /** Preserves today's settle/board behaviour. */
+  isGenericallySpendable: () => true,
+  /**
+   * 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 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 = hex.encode(script.pkScript);
+    const boardingSeq = timelockToSequence(deps.boardingTimelock);
+    return [
+      {
+        type: "boarding",
+        params: {
+          pubKey: hex.encode(pubKey),
+          serverPubKey: 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`.
+        ...rotatedReceiveMetadata(index, descriptor)
+      }
+    ];
   }
-  return 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 = schnorr.utils.lift_x(bytesToNumberBE(xOnly));
-  const scalar = bytesToNumberBE(hash) % secp256k1.Point.CURVE().n;
-  const tweak = secp256k1.Point.BASE.multiply(scalar);
-  return schnorr.utils.pointToBytes(point.add(tweak));
-}
-
-// src/arkade/program.ts
+};
 var MinimalScriptNum = ScriptNum(void 0, true);
 var SUPPORTED_PROGRAM_VERSION = 0;
 function inputName(ref) {
@@ -2217,6 +2751,18 @@ var ArkadeContractHandler = {
   getSpendablePaths(script, _contract, context) {
     return pathsFor(script, context, { checkTimelocks: true });
   },
+  /**
+   * Opt-in, never opt-out. A program artifact cannot say whether its funds are
+   * escrowed — an escrow's collaborative cancel leaf is indistinguishable from
+   * an ordinary spend — so the answer is read from the row the registering code
+   * wrote. Anything but an explicit `true` (absent, malformed, or a row written
+   * before this gate existed) is not generically spendable: `createContract` is
+   * first-writer-wins, so a fail-open marker would let one unmarked
+   * registration permanently open the gate for every contract sharing the script.
+   */
+  isGenericallySpendable(contract) {
+    return contract.metadata?.genericallySpendable === true;
+  },
   /**
    * Annotation tapscripts for VTXOs locked to this contract: prefer the
    * collaborative tapscript path (the multisig the Arkade Service co-signs,
@@ -2244,9 +2790,10 @@ var ArkadeContractHandler = {
 contractHandlers.register(DefaultContractHandler);
 contractHandlers.register(DelegateContractHandler);
 contractHandlers.register(VHTLCContractHandler);
+contractHandlers.register(VHTLCV2ContractHandler);
 contractHandlers.register(BoardingContractHandler);
 contractHandlers.register(ArkadeContractHandler);
 
-export { ARKADE_OP, ARKADE_OPCODES, ARKADE_OPCODE_NAMES, ARKADE_OPCODE_VALUES, ARKADE_OPS, ArkadeContractHandler, ArkadeProgramScript, ArkadeScript, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, OPCODE_NAMES, OPCODE_VALUES, SUPPORTED_PROGRAM_VERSION, VHTLC, VHTLCContractHandler, WALLET_RECEIVE_SOURCE, arkadeScriptHash, arkadeWitnessHash, asmToBytes, bignum_exports, bytesToASM, computeArkadeScriptPublicKey, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, descriptorIsOurs, deserializeArkadeContractParams, fromASM, getOpcodeName, getOpcodeValue, inputName, isCltvSatisfied, isCsvSpendable, isMainnetDescriptor, parseArtifact, resolveAsm, serializeArkadeContractParams, speculativeReceiveMetadata, stringifyArtifact, toASM, validateProgram, witnessRefToBytes };
-//# sourceMappingURL=chunk-PN5RD7ZI.js.map
-//# sourceMappingURL=chunk-PN5RD7ZI.js.map
+export { ARKADE_OP, ARKADE_OPCODES, ARKADE_OPCODE_NAMES, ARKADE_OPCODE_VALUES, ARKADE_OPS, ArkadeContractHandler, ArkadeProgramScript, ArkadeScript, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, OPCODE_NAMES, OPCODE_VALUES, SUPPORTED_PROGRAM_VERSION, VHTLC, VHTLCContractHandler, VHTLCV2ContractHandler, WALLET_RECEIVE_SOURCE, arkadeScriptHash, arkadeWitnessHash, asmToBytes, bignum_exports, bytesToASM, computeArkadeScriptPublicKey, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, descriptorIsOurs, deserializeArkadeContractParams, fromASM, getOpcodeName, getOpcodeValue, identityDescriptor, inputName, isCltvSatisfied, isCsvSpendable, isMainnetDescriptor, normalizeToDescriptor, parseArtifact, parseHDDescriptor, resolveAsm, serializeArkadeContractParams, speculativeReceiveMetadata, stringifyArtifact, toASM, validateProgram, witnessRefToBytes };
+//# sourceMappingURL=chunk-6O5OLYTZ.js.map
+//# sourceMappingURL=chunk-6O5OLYTZ.js.map