@arkade-os/sdk 0.4.59 → 0.4.61

package/dist/{index-BmK6tEqf.d.ts → index-Butfkm-K.d.cts}

@@ -1,71 +1,7 @@
-import { p as RelativeTimelock, V as VtxoScript, q as TapLeafScript, b9 as ContractHandler, bk as Discoverable, cC as TapscriptDeriving } from './ark-C9DsPSm8.js';
-import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-B_oKWm1k.js';
+import { ba as ContractHandler, p as RelativeTimelock, bl as Discoverable, V as VtxoScript, q as TapLeafScript, cO as TapscriptDeriving } from './index-BcRCHnzN.cjs';
+import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-C4Rl6h9l.cjs';
 import { Bytes } from '@scure/btc-signer/utils.js';
 
-/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
-declare namespace VHTLC {
-    interface Options {
-        sender: Bytes;
-        receiver: Bytes;
-        server: Bytes;
-        preimageHash: Bytes;
-        refundLocktime: bigint;
-        unilateralClaimDelay: RelativeTimelock;
-        unilateralRefundDelay: RelativeTimelock;
-        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
-    }
-    /**
-     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
-     *
-     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
-     * It provides multiple spending paths:
-     *
-     * - **claim**: Receiver can claim funds by revealing the preimage
-     * - **refund**: Sender and receiver can collaboratively refund
-     * - **refundWithoutReceiver**: Sender can refund after locktime expires
-     * - **unilateralClaim**: Receiver can claim unilaterally after delay
-     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
-     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
-     *
-     * @example
-     * ```typescript
-     * const vhtlc = new VHTLC.Script({
-     *   sender: alicePubKey,
-     *   receiver: bobPubKey,
-     *   server: serverPubKey,
-     *   preimageHash: hash160(secret),
-     *   refundLocktime: BigInt(chainTip + 10),
-     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
-     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
-     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
-     * });
-     * ```
-     */
-    class Script extends VtxoScript {
-        readonly options: Options;
-        readonly claimScript: string;
-        readonly refundScript: string;
-        readonly refundWithoutReceiverScript: string;
-        readonly unilateralClaimScript: string;
-        readonly unilateralRefundScript: string;
-        readonly unilateralRefundWithoutReceiverScript: string;
-        /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
-        constructor(options: Options);
-        /** Return the collaborative claim tapleaf script. */
-        claim(): TapLeafScript;
-        /** Return the collaborative refund tapleaf script. */
-        refund(): TapLeafScript;
-        /** Return the refund-without-receiver tapleaf script. */
-        refundWithoutReceiver(): TapLeafScript;
-        /** Return the unilateral claim tapleaf script. */
-        unilateralClaim(): TapLeafScript;
-        /** Return the unilateral refund tapleaf script. */
-        unilateralRefund(): TapLeafScript;
-        /** Return the unilateral refund-without-receiver tapleaf script. */
-        unilateralRefundWithoutReceiver(): TapLeafScript;
-    }
-}
-
 /**
  * Registry for contract handlers.
  *
@@ -166,6 +102,142 @@ interface DelegateContractParams {
  */
 declare const DelegateContractHandler: ContractHandler<DelegateContractParams, DelegateVtxo.Script> & Discoverable;
 
+/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
+declare namespace VHTLC {
+    export interface Options {
+        sender: Bytes;
+        receiver: Bytes;
+        server: Bytes;
+        preimageHash: Bytes;
+        refundLocktime: bigint;
+        unilateralClaimDelay: RelativeTimelock;
+        unilateralRefundDelay: RelativeTimelock;
+        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+        /**
+         * Optional non-interactive claim leaf: `server` plus a covenant-tweaked
+         * emulator co-signer, pinned to `receiverPkScript`. Lets the receiver's
+         * claim be pushed by the emulator without the receiver being online.
+         */
+        nonInteractiveClaim?: {
+            receiverPkScript: Bytes;
+            emulatorPubkey: Bytes;
+        };
+        /**
+         * Optional non-interactive refund leaf: `server` + `receiver` + a
+         * covenant-tweaked emulator co-signer, pinned to `senderPkScript`, no
+         * timelock. Every OTHER refund-side leaf in this contract requires
+         * the sender's own signature — if the sender permanently loses that
+         * key, none of them are reachable. This leaf is the one exception:
+         * it needs neither the sender's presence nor their key, so funds
+         * remain recoverable to the sender's pre-committed address even
+         * then. It still needs the receiver (unlike `nonInteractiveClaim`,
+         * which needs only server + emulator) — deliberately: this is what
+         * lets server + receiver release the refund immediately, the moment
+         * they agree the swap has failed, rather than making the sender wait
+         * out `refundLocktime` the way {@link Script.refundWithoutReceiver}
+         * does.
+         */
+        nonInteractiveRefund?: {
+            senderPkScript: Bytes;
+            emulatorPubkey: Bytes;
+        };
+    }
+    /**
+     * Shared construction and accessors for every VHTLC script version. The
+     * only thing that varies between versions is which preimage-condition
+     * fragment `claim`/`unilateralClaim`/`nonInteractiveClaim` are built
+     * from — everything else (the multisig/timelock leaves, the
+     * non-interactive covenant leaves, the accessor methods) is identical,
+     * so versions are expressed as thin subclasses over one builder rather
+     * than as separate, independently-maintained copies of this class.
+     */
+    abstract class BaseScript extends VtxoScript {
+        readonly options: Options;
+        readonly claimScript: string;
+        readonly refundScript: string;
+        readonly refundWithoutReceiverScript: string;
+        readonly unilateralClaimScript: string;
+        readonly unilateralRefundScript: string;
+        readonly unilateralRefundWithoutReceiverScript: string;
+        readonly nonInteractiveClaimScript?: string;
+        readonly nonInteractiveClaimArkadeScript?: Bytes;
+        readonly nonInteractiveRefundScript?: string;
+        readonly nonInteractiveRefundArkadeScript?: Bytes;
+        protected constructor(options: Options, preimageCondition: (hash: Bytes) => Bytes);
+        /** Return the collaborative claim tapleaf script. */
+        claim(): TapLeafScript;
+        /** Return the collaborative refund tapleaf script. */
+        refund(): TapLeafScript;
+        /** Return the refund-without-receiver tapleaf script. */
+        refundWithoutReceiver(): TapLeafScript;
+        /** Return the unilateral claim tapleaf script. */
+        unilateralClaim(): TapLeafScript;
+        /** Return the unilateral refund tapleaf script. */
+        unilateralRefund(): TapLeafScript;
+        /** Return the unilateral refund-without-receiver tapleaf script. */
+        unilateralRefundWithoutReceiver(): TapLeafScript;
+        /** Return the non-interactive claim tapleaf script as well as the ArkadeScript. */
+        nonInteractiveClaim(): [TapLeafScript, Bytes];
+        /** Return the non-interactive refund tapleaf script as well as the ArkadeScript. */
+        nonInteractiveRefund(): [TapLeafScript, Bytes];
+    }
+    /**
+     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
+     *
+     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
+     * It provides multiple spending paths:
+     *
+     * - **claim**: Receiver can claim funds by revealing the preimage
+     * - **refund**: Sender and receiver can collaboratively refund
+     * - **refundWithoutReceiver**: Sender can refund after locktime expires
+     * - **unilateralClaim**: Receiver can claim unilaterally after delay
+     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
+     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
+     * - **nonInteractiveClaim** (optional): server + emulator can push the
+     *   receiver's claim, pinned to a pre-committed destination
+     * - **nonInteractiveRefund** (optional): server + receiver + emulator
+     *   can push the sender's refund immediately, no timelock, pinned to a
+     *   pre-committed destination — recoverable even if the sender's own key
+     *   is lost
+     *
+     * See {@link ScriptV2} for the current recommended construction — same
+     * leaf ladder, same options shape, an added length check on the claim
+     * preimage. This class is unchanged and stays available as-is.
+     *
+     * @example
+     * ```typescript
+     * const vhtlc = new VHTLC.Script({
+     *   sender: alicePubKey,
+     *   receiver: bobPubKey,
+     *   server: serverPubKey,
+     *   preimageHash: hash160(secret),
+     *   refundLocktime: BigInt(chainTip + 10),
+     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
+     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
+     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
+     * });
+     * ```
+     */
+    export class Script extends BaseScript {
+        constructor(options: Options);
+    }
+    /**
+     * Same leaf ladder as {@link Script}, built with {@link
+     * preimageConditionScriptV2} instead of {@link preimageConditionScript}
+     * for every leaf that gates on the preimage (`claim`, `unilateralClaim`,
+     * and, when present, `nonInteractiveClaim`) — see that function's doc
+     * comment for what differs and why. A distinct class rather than a flag
+     * on {@link Script}: the two produce different script bytes (and so
+     * different addresses) for the same participant keys, and keeping them
+     * as separate types makes that a compile-time-visible choice at every
+     * call site instead of a runtime option that's easy to get wrong.
+     */
+    export class ScriptV2 extends BaseScript {
+        constructor(options: Options);
+    }
+    export {  };
+}
+
 /**
  * Typed parameters for VHTLC contracts.
  */
@@ -194,7 +266,91 @@ interface VHTLCContractParams {
  * - unilateralRefund: Sender + Receiver after CSV delay
  * - unilateralRefundWithoutReceiver: Sender after CSV delay
  */
-declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script>;
+declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script> & TapscriptDeriving<VHTLC.Script>;
+
+/**
+ * Typed parameters for {@link VHTLC.ScriptV2} contracts.
+ *
+ * The eight mandatory fields are `VHTLCContractParams` verbatim — the two
+ * script versions take the same {@link VHTLC.Options}, so a divergent shape
+ * here would be a difference with no cause. What V1's handler has no field for
+ * is the two optional covenant leaves, and those are exactly what the swap
+ * corridor's lockup carries, so leaving them out would make this handler unable
+ * to round-trip the contract it exists to serve.
+ */
+interface VHTLCV2ContractParams {
+    sender: Uint8Array;
+    receiver: Uint8Array;
+    server: Uint8Array;
+    preimageHash: Uint8Array;
+    refundLocktime: bigint;
+    unilateralClaimDelay: RelativeTimelock;
+    unilateralRefundDelay: RelativeTimelock;
+    unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+    /** @see VHTLC.Options.nonInteractiveClaim */
+    nonInteractiveClaim?: {
+        receiverPkScript: Uint8Array;
+        emulatorPubkey: Uint8Array;
+    };
+    /** @see VHTLC.Options.nonInteractiveRefund */
+    nonInteractiveRefund?: {
+        senderPkScript: Uint8Array;
+        emulatorPubkey: Uint8Array;
+    };
+}
+/**
+ * Handler for {@link VHTLC.ScriptV2} — the VHTLC whose preimage leaves carry an
+ * explicit `OP_SIZE 32 OP_EQUALVERIFY` before the hash check, and which the RFQ
+ * swap corridor builds (`@arkade-os/swap`'s `lightningSendVtxoScript`).
+ *
+ * **Why a separate type string rather than a flag on `vhtlc`.** A handler's
+ * `type` names the script class it derives, the way every other registered type
+ * does (`default` → `DefaultVtxo.Script`, `vhtlc` → `VHTLC.Script`, `boarding`,
+ * `arkade`). V1 and V2 produce different script bytes — and so different
+ * pkScripts — for identical participant keys, and `upsertContractRow` derives
+ * the script from `params` and refuses any row whose supplied `script` does not
+ * match. One type cannot serve both. `vhtlc-v2` also cannot COLLIDE with
+ * `vhtlc`: a colliding row needs one pkScript claimed by two types, and the two
+ * versions' preimage conditions differ in every tree, so no parameters make
+ * them equal. A use-named type (`swap-lockup`) was the alternative and is
+ * worse: contracts are keyed by script, so the moment a second use registered
+ * the same ScriptV2 the two uses would fight over one row.
+ *
+ * **Which leaves this offers, and why the set is smaller than the ladder.**
+ * ScriptV2 has eight leaves; a wallet holding ONE of the two participant keys
+ * can satisfy four of them, and offering a leaf whose signature the caller
+ * cannot produce is worse than offering fewer — it turns a refusal into a
+ * transaction that gets built and then rejected.
+ *
+ * | leaf                              | needs                          | offered |
+ * |-----------------------------------|--------------------------------|---------|
+ * | `claim`                           | receiver + server, preimage    | yes, to the receiver |
+ * | `refund`                          | sender + receiver + server     | no — needs the counterparty live |
+ * | `refundWithoutReceiver`           | sender + server, CLTV          | yes, to the sender |
+ * | `unilateralClaim`                 | receiver, CSV                  | yes, to the receiver |
+ * | `unilateralRefund`                | sender + receiver, CSV         | no — needs the counterparty live |
+ * | `unilateralRefundWithoutReceiver` | sender, CSV                    | yes, to the sender |
+ * | `nonInteractiveClaim`             | server + emulator              | no — the wallet holds neither key |
+ * | `nonInteractiveRefund`            | server + receiver + emulator   | no — the wallet holds neither key |
+ *
+ * The two omitted interactive leaves are the same two the `vhtlc` handler
+ * omits, for the same reason: `refund` and `unilateralRefund` both need the
+ * OTHER party's signature, and this protocol has no message that asks for one
+ * (see `@arkade-os/swap`'s `refund.ts` module doc). The two covenant leaves are
+ * pushed by the emulator on the counterparty's behalf and are not this wallet's
+ * to build at all.
+ *
+ * So `refundWithoutReceiver` is the sender's only collaborative way out, gated
+ * on the CLTV the quote committed to — which is exactly the leaf
+ * `pushRefundWithoutReceiver` builds. The CSV leaves are offered only in the
+ * non-collaborative context, where the caller has already accepted that
+ * spending them means a real unilateral exit first.
+ *
+ * The selection discipline is deliberately identical to the `vhtlc` handler's,
+ * and `test/contracts/vhtlcV2-handler.test.ts` pins the two against each other
+ * rung-for-rung across every role and timelock context so they cannot drift.
+ */
+declare const VHTLCV2ContractHandler: ContractHandler<VHTLCV2ContractParams, VHTLC.ScriptV2> & TapscriptDeriving<VHTLC.ScriptV2>;
 
 /**
  * Typed parameters for boarding contracts.
@@ -509,4 +665,4 @@ declare function deserializeArkadeContractParams(params: Record<string, string>)
  */
 declare const ArkadeContractHandler: ContractHandler<ArkadeContractParams, ArkadeProgramScript> & TapscriptDeriving<ArkadeProgramScript>;
 
-export { type ArkadeParamValue as A, BoardingContractHandler as B, type CompiledProgramFunction as C, DefaultContractHandler as D, type InputRef as I, type Program as P, SUPPORTED_PROGRAM_VERSION as S, type TapscriptSegment as T, VHTLC as V, type WitnessRef as W, ArkadeProgramScript as a, type ProgramKeys as b, type ArkadeArgValue as c, type ArkadeFunction as d, type InputDef as e, type ArkadeValueType as f, type ArkadeArgType as g, type ArkadeContractParams as h, type ArkadeSegment as i, type AsmToken as j, type SignerRef as k, deserializeArkadeContractParams as l, stringifyArtifact as m, ArkadeContractHandler as n, type BoardingContractParams as o, parseArtifact as p, type DefaultContractParams as q, resolveAsm as r, serializeArkadeContractParams as s, DelegateContractHandler as t, type DelegateContractParams as u, validateProgram as v, witnessRefToBytes as w, VHTLCContractHandler as x, type VHTLCContractParams as y, contractHandlers as z };
+export { type ArkadeParamValue as A, BoardingContractHandler as B, type CompiledProgramFunction as C, DefaultContractHandler as D, type VHTLCV2ContractParams as E, contractHandlers as F, type InputRef as I, type Program as P, SUPPORTED_PROGRAM_VERSION as S, type TapscriptSegment as T, VHTLC as V, type WitnessRef as W, ArkadeProgramScript as a, type ProgramKeys as b, type ArkadeArgValue as c, type ArkadeFunction as d, type InputDef as e, type ArkadeValueType as f, type ArkadeArgType as g, type ArkadeContractParams as h, type ArkadeSegment as i, type AsmToken as j, type SignerRef as k, deserializeArkadeContractParams as l, stringifyArtifact as m, ArkadeContractHandler as n, type BoardingContractParams as o, parseArtifact as p, type DefaultContractParams as q, resolveAsm as r, serializeArkadeContractParams as s, DelegateContractHandler as t, type DelegateContractParams as u, validateProgram as v, witnessRefToBytes as w, VHTLCContractHandler as x, type VHTLCContractParams as y, VHTLCV2ContractHandler as z };

package/dist/{index-BG2AL2Ie.d.cts → index-C29VNcxC.d.ts}

@@ -1,71 +1,7 @@
-import { p as RelativeTimelock, V as VtxoScript, q as TapLeafScript, b9 as ContractHandler, bk as Discoverable, cC as TapscriptDeriving } from './ark-C9DsPSm8.cjs';
-import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-D0eGaz3J.cjs';
+import { ba as ContractHandler, p as RelativeTimelock, bl as Discoverable, V as VtxoScript, q as TapLeafScript, cO as TapscriptDeriving } from './index-BcRCHnzN.js';
+import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-BySzD37I.js';
 import { Bytes } from '@scure/btc-signer/utils.js';
 
-/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
-declare namespace VHTLC {
-    interface Options {
-        sender: Bytes;
-        receiver: Bytes;
-        server: Bytes;
-        preimageHash: Bytes;
-        refundLocktime: bigint;
-        unilateralClaimDelay: RelativeTimelock;
-        unilateralRefundDelay: RelativeTimelock;
-        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
-    }
-    /**
-     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
-     *
-     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
-     * It provides multiple spending paths:
-     *
-     * - **claim**: Receiver can claim funds by revealing the preimage
-     * - **refund**: Sender and receiver can collaboratively refund
-     * - **refundWithoutReceiver**: Sender can refund after locktime expires
-     * - **unilateralClaim**: Receiver can claim unilaterally after delay
-     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
-     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
-     *
-     * @example
-     * ```typescript
-     * const vhtlc = new VHTLC.Script({
-     *   sender: alicePubKey,
-     *   receiver: bobPubKey,
-     *   server: serverPubKey,
-     *   preimageHash: hash160(secret),
-     *   refundLocktime: BigInt(chainTip + 10),
-     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
-     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
-     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
-     * });
-     * ```
-     */
-    class Script extends VtxoScript {
-        readonly options: Options;
-        readonly claimScript: string;
-        readonly refundScript: string;
-        readonly refundWithoutReceiverScript: string;
-        readonly unilateralClaimScript: string;
-        readonly unilateralRefundScript: string;
-        readonly unilateralRefundWithoutReceiverScript: string;
-        /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
-        constructor(options: Options);
-        /** Return the collaborative claim tapleaf script. */
-        claim(): TapLeafScript;
-        /** Return the collaborative refund tapleaf script. */
-        refund(): TapLeafScript;
-        /** Return the refund-without-receiver tapleaf script. */
-        refundWithoutReceiver(): TapLeafScript;
-        /** Return the unilateral claim tapleaf script. */
-        unilateralClaim(): TapLeafScript;
-        /** Return the unilateral refund tapleaf script. */
-        unilateralRefund(): TapLeafScript;
-        /** Return the unilateral refund-without-receiver tapleaf script. */
-        unilateralRefundWithoutReceiver(): TapLeafScript;
-    }
-}
-
 /**
  * Registry for contract handlers.
  *
@@ -166,6 +102,142 @@ interface DelegateContractParams {
  */
 declare const DelegateContractHandler: ContractHandler<DelegateContractParams, DelegateVtxo.Script> & Discoverable;
 
+/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
+declare namespace VHTLC {
+    export interface Options {
+        sender: Bytes;
+        receiver: Bytes;
+        server: Bytes;
+        preimageHash: Bytes;
+        refundLocktime: bigint;
+        unilateralClaimDelay: RelativeTimelock;
+        unilateralRefundDelay: RelativeTimelock;
+        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+        /**
+         * Optional non-interactive claim leaf: `server` plus a covenant-tweaked
+         * emulator co-signer, pinned to `receiverPkScript`. Lets the receiver's
+         * claim be pushed by the emulator without the receiver being online.
+         */
+        nonInteractiveClaim?: {
+            receiverPkScript: Bytes;
+            emulatorPubkey: Bytes;
+        };
+        /**
+         * Optional non-interactive refund leaf: `server` + `receiver` + a
+         * covenant-tweaked emulator co-signer, pinned to `senderPkScript`, no
+         * timelock. Every OTHER refund-side leaf in this contract requires
+         * the sender's own signature — if the sender permanently loses that
+         * key, none of them are reachable. This leaf is the one exception:
+         * it needs neither the sender's presence nor their key, so funds
+         * remain recoverable to the sender's pre-committed address even
+         * then. It still needs the receiver (unlike `nonInteractiveClaim`,
+         * which needs only server + emulator) — deliberately: this is what
+         * lets server + receiver release the refund immediately, the moment
+         * they agree the swap has failed, rather than making the sender wait
+         * out `refundLocktime` the way {@link Script.refundWithoutReceiver}
+         * does.
+         */
+        nonInteractiveRefund?: {
+            senderPkScript: Bytes;
+            emulatorPubkey: Bytes;
+        };
+    }
+    /**
+     * Shared construction and accessors for every VHTLC script version. The
+     * only thing that varies between versions is which preimage-condition
+     * fragment `claim`/`unilateralClaim`/`nonInteractiveClaim` are built
+     * from — everything else (the multisig/timelock leaves, the
+     * non-interactive covenant leaves, the accessor methods) is identical,
+     * so versions are expressed as thin subclasses over one builder rather
+     * than as separate, independently-maintained copies of this class.
+     */
+    abstract class BaseScript extends VtxoScript {
+        readonly options: Options;
+        readonly claimScript: string;
+        readonly refundScript: string;
+        readonly refundWithoutReceiverScript: string;
+        readonly unilateralClaimScript: string;
+        readonly unilateralRefundScript: string;
+        readonly unilateralRefundWithoutReceiverScript: string;
+        readonly nonInteractiveClaimScript?: string;
+        readonly nonInteractiveClaimArkadeScript?: Bytes;
+        readonly nonInteractiveRefundScript?: string;
+        readonly nonInteractiveRefundArkadeScript?: Bytes;
+        protected constructor(options: Options, preimageCondition: (hash: Bytes) => Bytes);
+        /** Return the collaborative claim tapleaf script. */
+        claim(): TapLeafScript;
+        /** Return the collaborative refund tapleaf script. */
+        refund(): TapLeafScript;
+        /** Return the refund-without-receiver tapleaf script. */
+        refundWithoutReceiver(): TapLeafScript;
+        /** Return the unilateral claim tapleaf script. */
+        unilateralClaim(): TapLeafScript;
+        /** Return the unilateral refund tapleaf script. */
+        unilateralRefund(): TapLeafScript;
+        /** Return the unilateral refund-without-receiver tapleaf script. */
+        unilateralRefundWithoutReceiver(): TapLeafScript;
+        /** Return the non-interactive claim tapleaf script as well as the ArkadeScript. */
+        nonInteractiveClaim(): [TapLeafScript, Bytes];
+        /** Return the non-interactive refund tapleaf script as well as the ArkadeScript. */
+        nonInteractiveRefund(): [TapLeafScript, Bytes];
+    }
+    /**
+     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
+     *
+     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
+     * It provides multiple spending paths:
+     *
+     * - **claim**: Receiver can claim funds by revealing the preimage
+     * - **refund**: Sender and receiver can collaboratively refund
+     * - **refundWithoutReceiver**: Sender can refund after locktime expires
+     * - **unilateralClaim**: Receiver can claim unilaterally after delay
+     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
+     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
+     * - **nonInteractiveClaim** (optional): server + emulator can push the
+     *   receiver's claim, pinned to a pre-committed destination
+     * - **nonInteractiveRefund** (optional): server + receiver + emulator
+     *   can push the sender's refund immediately, no timelock, pinned to a
+     *   pre-committed destination — recoverable even if the sender's own key
+     *   is lost
+     *
+     * See {@link ScriptV2} for the current recommended construction — same
+     * leaf ladder, same options shape, an added length check on the claim
+     * preimage. This class is unchanged and stays available as-is.
+     *
+     * @example
+     * ```typescript
+     * const vhtlc = new VHTLC.Script({
+     *   sender: alicePubKey,
+     *   receiver: bobPubKey,
+     *   server: serverPubKey,
+     *   preimageHash: hash160(secret),
+     *   refundLocktime: BigInt(chainTip + 10),
+     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
+     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
+     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
+     * });
+     * ```
+     */
+    export class Script extends BaseScript {
+        constructor(options: Options);
+    }
+    /**
+     * Same leaf ladder as {@link Script}, built with {@link
+     * preimageConditionScriptV2} instead of {@link preimageConditionScript}
+     * for every leaf that gates on the preimage (`claim`, `unilateralClaim`,
+     * and, when present, `nonInteractiveClaim`) — see that function's doc
+     * comment for what differs and why. A distinct class rather than a flag
+     * on {@link Script}: the two produce different script bytes (and so
+     * different addresses) for the same participant keys, and keeping them
+     * as separate types makes that a compile-time-visible choice at every
+     * call site instead of a runtime option that's easy to get wrong.
+     */
+    export class ScriptV2 extends BaseScript {
+        constructor(options: Options);
+    }
+    export {  };
+}
+
 /**
  * Typed parameters for VHTLC contracts.
  */
@@ -194,7 +266,91 @@ interface VHTLCContractParams {
  * - unilateralRefund: Sender + Receiver after CSV delay
  * - unilateralRefundWithoutReceiver: Sender after CSV delay
  */
-declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script>;
+declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script> & TapscriptDeriving<VHTLC.Script>;
+
+/**
+ * Typed parameters for {@link VHTLC.ScriptV2} contracts.
+ *
+ * The eight mandatory fields are `VHTLCContractParams` verbatim — the two
+ * script versions take the same {@link VHTLC.Options}, so a divergent shape
+ * here would be a difference with no cause. What V1's handler has no field for
+ * is the two optional covenant leaves, and those are exactly what the swap
+ * corridor's lockup carries, so leaving them out would make this handler unable
+ * to round-trip the contract it exists to serve.
+ */
+interface VHTLCV2ContractParams {
+    sender: Uint8Array;
+    receiver: Uint8Array;
+    server: Uint8Array;
+    preimageHash: Uint8Array;
+    refundLocktime: bigint;
+    unilateralClaimDelay: RelativeTimelock;
+    unilateralRefundDelay: RelativeTimelock;
+    unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+    /** @see VHTLC.Options.nonInteractiveClaim */
+    nonInteractiveClaim?: {
+        receiverPkScript: Uint8Array;
+        emulatorPubkey: Uint8Array;
+    };
+    /** @see VHTLC.Options.nonInteractiveRefund */
+    nonInteractiveRefund?: {
+        senderPkScript: Uint8Array;
+        emulatorPubkey: Uint8Array;
+    };
+}
+/**
+ * Handler for {@link VHTLC.ScriptV2} — the VHTLC whose preimage leaves carry an
+ * explicit `OP_SIZE 32 OP_EQUALVERIFY` before the hash check, and which the RFQ
+ * swap corridor builds (`@arkade-os/swap`'s `lightningSendVtxoScript`).
+ *
+ * **Why a separate type string rather than a flag on `vhtlc`.** A handler's
+ * `type` names the script class it derives, the way every other registered type
+ * does (`default` → `DefaultVtxo.Script`, `vhtlc` → `VHTLC.Script`, `boarding`,
+ * `arkade`). V1 and V2 produce different script bytes — and so different
+ * pkScripts — for identical participant keys, and `upsertContractRow` derives
+ * the script from `params` and refuses any row whose supplied `script` does not
+ * match. One type cannot serve both. `vhtlc-v2` also cannot COLLIDE with
+ * `vhtlc`: a colliding row needs one pkScript claimed by two types, and the two
+ * versions' preimage conditions differ in every tree, so no parameters make
+ * them equal. A use-named type (`swap-lockup`) was the alternative and is
+ * worse: contracts are keyed by script, so the moment a second use registered
+ * the same ScriptV2 the two uses would fight over one row.
+ *
+ * **Which leaves this offers, and why the set is smaller than the ladder.**
+ * ScriptV2 has eight leaves; a wallet holding ONE of the two participant keys
+ * can satisfy four of them, and offering a leaf whose signature the caller
+ * cannot produce is worse than offering fewer — it turns a refusal into a
+ * transaction that gets built and then rejected.
+ *
+ * | leaf                              | needs                          | offered |
+ * |-----------------------------------|--------------------------------|---------|
+ * | `claim`                           | receiver + server, preimage    | yes, to the receiver |
+ * | `refund`                          | sender + receiver + server     | no — needs the counterparty live |
+ * | `refundWithoutReceiver`           | sender + server, CLTV          | yes, to the sender |
+ * | `unilateralClaim`                 | receiver, CSV                  | yes, to the receiver |
+ * | `unilateralRefund`                | sender + receiver, CSV         | no — needs the counterparty live |
+ * | `unilateralRefundWithoutReceiver` | sender, CSV                    | yes, to the sender |
+ * | `nonInteractiveClaim`             | server + emulator              | no — the wallet holds neither key |
+ * | `nonInteractiveRefund`            | server + receiver + emulator   | no — the wallet holds neither key |
+ *
+ * The two omitted interactive leaves are the same two the `vhtlc` handler
+ * omits, for the same reason: `refund` and `unilateralRefund` both need the
+ * OTHER party's signature, and this protocol has no message that asks for one
+ * (see `@arkade-os/swap`'s `refund.ts` module doc). The two covenant leaves are
+ * pushed by the emulator on the counterparty's behalf and are not this wallet's
+ * to build at all.
+ *
+ * So `refundWithoutReceiver` is the sender's only collaborative way out, gated
+ * on the CLTV the quote committed to — which is exactly the leaf
+ * `pushRefundWithoutReceiver` builds. The CSV leaves are offered only in the
+ * non-collaborative context, where the caller has already accepted that
+ * spending them means a real unilateral exit first.
+ *
+ * The selection discipline is deliberately identical to the `vhtlc` handler's,
+ * and `test/contracts/vhtlcV2-handler.test.ts` pins the two against each other
+ * rung-for-rung across every role and timelock context so they cannot drift.
+ */
+declare const VHTLCV2ContractHandler: ContractHandler<VHTLCV2ContractParams, VHTLC.ScriptV2> & TapscriptDeriving<VHTLC.ScriptV2>;
 
 /**
  * Typed parameters for boarding contracts.
@@ -509,4 +665,4 @@ declare function deserializeArkadeContractParams(params: Record<string, string>)
  */
 declare const ArkadeContractHandler: ContractHandler<ArkadeContractParams, ArkadeProgramScript> & TapscriptDeriving<ArkadeProgramScript>;
 
-export { type ArkadeParamValue as A, BoardingContractHandler as B, type CompiledProgramFunction as C, DefaultContractHandler as D, type InputRef as I, type Program as P, SUPPORTED_PROGRAM_VERSION as S, type TapscriptSegment as T, VHTLC as V, type WitnessRef as W, ArkadeProgramScript as a, type ProgramKeys as b, type ArkadeArgValue as c, type ArkadeFunction as d, type InputDef as e, type ArkadeValueType as f, type ArkadeArgType as g, type ArkadeContractParams as h, type ArkadeSegment as i, type AsmToken as j, type SignerRef as k, deserializeArkadeContractParams as l, stringifyArtifact as m, ArkadeContractHandler as n, type BoardingContractParams as o, parseArtifact as p, type DefaultContractParams as q, resolveAsm as r, serializeArkadeContractParams as s, DelegateContractHandler as t, type DelegateContractParams as u, validateProgram as v, witnessRefToBytes as w, VHTLCContractHandler as x, type VHTLCContractParams as y, contractHandlers as z };
+export { type ArkadeParamValue as A, BoardingContractHandler as B, type CompiledProgramFunction as C, DefaultContractHandler as D, type VHTLCV2ContractParams as E, contractHandlers as F, type InputRef as I, type Program as P, SUPPORTED_PROGRAM_VERSION as S, type TapscriptSegment as T, VHTLC as V, type WitnessRef as W, ArkadeProgramScript as a, type ProgramKeys as b, type ArkadeArgValue as c, type ArkadeFunction as d, type InputDef as e, type ArkadeValueType as f, type ArkadeArgType as g, type ArkadeContractParams as h, type ArkadeSegment as i, type AsmToken as j, type SignerRef as k, deserializeArkadeContractParams as l, stringifyArtifact as m, ArkadeContractHandler as n, type BoardingContractParams as o, parseArtifact as p, type DefaultContractParams as q, resolveAsm as r, serializeArkadeContractParams as s, DelegateContractHandler as t, type DelegateContractParams as u, validateProgram as v, witnessRefToBytes as w, VHTLCContractHandler as x, type VHTLCContractParams as y, VHTLCV2ContractHandler as z };