@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/contracts/handlers/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var chunkI3DGUUCT_cjs = require('../../chunk-I3DGUUCT.cjs');
+require('../../chunk-5PG7DV7A.cjs');
+require('../../chunk-5BLDMQED.cjs');
+
+
+
+Object.defineProperty(exports, "DefaultContractHandler", {
+  enumerable: true,
+  get: function () { return chunkI3DGUUCT_cjs.DefaultContractHandler; }
+});
+Object.defineProperty(exports, "DelegateContractHandler", {
+  enumerable: true,
+  get: function () { return chunkI3DGUUCT_cjs.DelegateContractHandler; }
+});
+Object.defineProperty(exports, "VHTLCContractHandler", {
+  enumerable: true,
+  get: function () { return chunkI3DGUUCT_cjs.VHTLCContractHandler; }
+});
+Object.defineProperty(exports, "contractHandlers", {
+  enumerable: true,
+  get: function () { return chunkI3DGUUCT_cjs.contractHandlers; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/contracts/handlers/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/contracts/handlers/index.d.cts

@@ -0,0 +1,7 @@
+export { D as DefaultContractHandler, a as DefaultContractParams, b as DelegateContractHandler, c as DelegateContractParams, d as VHTLCContractHandler, e as VHTLCContractParams, f as contractHandlers } from '../../index-B22cA64m.cjs';
+import '../../ark-TZ1gXAXU.cjs';
+import '@scure/btc-signer/transaction.js';
+import '@scure/btc-signer/utils.js';
+import '@scure/btc-signer/psbt.js';
+import '@scure/btc-signer';
+import '../../delegate-BFZs69hp.cjs';

package/dist/contracts/handlers/index.d.ts

@@ -0,0 +1,7 @@
+export { D as DefaultContractHandler, a as DefaultContractParams, b as DelegateContractHandler, c as DelegateContractParams, d as VHTLCContractHandler, e as VHTLCContractParams, f as contractHandlers } from '../../index-NDla_UoJ.js';
+import '../../ark-TZ1gXAXU.js';
+import '@scure/btc-signer/transaction.js';
+import '@scure/btc-signer/utils.js';
+import '@scure/btc-signer/psbt.js';
+import '@scure/btc-signer';
+import '../../delegate-aaVGfWsV.js';

package/dist/contracts/handlers/index.js

@@ -0,0 +1,5 @@
+export { DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, contractHandlers } from '../../chunk-T64LAI7L.js';
+import '../../chunk-HW3JJ323.js';
+import '../../chunk-NSBPE2FW.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/contracts/handlers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/delegate-BFZs69hp.d.cts

@@ -0,0 +1,84 @@
+import { Bytes } from '@scure/btc-signer/utils.js';
+import { o as RelativeTimelock, V as VtxoScript, p as TapLeafScript } from './ark-TZ1gXAXU.cjs';
+
+/**
+ * DefaultVtxo is the default implementation of a VtxoScript.
+ * It contains 1 forfeit path and 1 exit path.
+ * - forfeit = (Alice + Server)
+ * - exit = (Alice) after csvTimelock
+ */
+declare namespace DefaultVtxo {
+    /**
+     * Options is the options for the DefaultVtxo.Script class.
+     * csvTimelock is the exit path timelock, default is 144 blocks (1 day).
+     */
+    interface Options {
+        pubKey: Bytes;
+        serverPubKey: Bytes;
+        csvTimelock?: RelativeTimelock;
+    }
+    /**
+     * DefaultVtxo.Script is the class letting to create the vtxo script.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DefaultVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends VtxoScript {
+        readonly options: Options;
+        static readonly DEFAULT_TIMELOCK: RelativeTimelock;
+        readonly forfeitScript: string;
+        readonly exitScript: string;
+        /** Create the default virtual output script with one forfeit path and one exit path. */
+        constructor(options: Options);
+        /** Return the forfeit tapleaf script. */
+        forfeit(): TapLeafScript;
+        /** Return the unilateral exit tapleaf script. */
+        exit(): TapLeafScript;
+    }
+}
+
+/**
+ * DelegateVtxo extends DefaultVtxo with an extra delegator path
+ */
+declare namespace DelegateVtxo {
+    /**
+     * Options extends DefaultVtxo.Options and adds a delegatePubKey
+     */
+    interface Options extends DefaultVtxo.Options {
+        delegatePubKey: Bytes;
+    }
+    /**
+     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DelegateVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     *     delegatePubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends VtxoScript {
+        readonly options: Options;
+        readonly defaultVtxo: DefaultVtxo.Script;
+        readonly delegateScript: string;
+        /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */
+        constructor(options: Options);
+        /** Return the forfeit tapleaf script. */
+        forfeit(): TapLeafScript;
+        /** Return the unilateral exit tapleaf script. */
+        exit(): TapLeafScript;
+        /** Return the delegate tapleaf script. */
+        delegate(): TapLeafScript;
+    }
+}
+
+export { DefaultVtxo as D, DelegateVtxo as a };

package/dist/delegate-aaVGfWsV.d.ts

@@ -0,0 +1,84 @@
+import { Bytes } from '@scure/btc-signer/utils.js';
+import { o as RelativeTimelock, V as VtxoScript, p as TapLeafScript } from './ark-TZ1gXAXU.js';
+
+/**
+ * DefaultVtxo is the default implementation of a VtxoScript.
+ * It contains 1 forfeit path and 1 exit path.
+ * - forfeit = (Alice + Server)
+ * - exit = (Alice) after csvTimelock
+ */
+declare namespace DefaultVtxo {
+    /**
+     * Options is the options for the DefaultVtxo.Script class.
+     * csvTimelock is the exit path timelock, default is 144 blocks (1 day).
+     */
+    interface Options {
+        pubKey: Bytes;
+        serverPubKey: Bytes;
+        csvTimelock?: RelativeTimelock;
+    }
+    /**
+     * DefaultVtxo.Script is the class letting to create the vtxo script.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DefaultVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends VtxoScript {
+        readonly options: Options;
+        static readonly DEFAULT_TIMELOCK: RelativeTimelock;
+        readonly forfeitScript: string;
+        readonly exitScript: string;
+        /** Create the default virtual output script with one forfeit path and one exit path. */
+        constructor(options: Options);
+        /** Return the forfeit tapleaf script. */
+        forfeit(): TapLeafScript;
+        /** Return the unilateral exit tapleaf script. */
+        exit(): TapLeafScript;
+    }
+}
+
+/**
+ * DelegateVtxo extends DefaultVtxo with an extra delegator path
+ */
+declare namespace DelegateVtxo {
+    /**
+     * Options extends DefaultVtxo.Options and adds a delegatePubKey
+     */
+    interface Options extends DefaultVtxo.Options {
+        delegatePubKey: Bytes;
+    }
+    /**
+     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DelegateVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     *     delegatePubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends VtxoScript {
+        readonly options: Options;
+        readonly defaultVtxo: DefaultVtxo.Script;
+        readonly delegateScript: string;
+        /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */
+        constructor(options: Options);
+        /** Return the forfeit tapleaf script. */
+        forfeit(): TapLeafScript;
+        /** Return the unilateral exit tapleaf script. */
+        exit(): TapLeafScript;
+        /** Return the delegate tapleaf script. */
+        delegate(): TapLeafScript;
+    }
+}
+
+export { DefaultVtxo as D, DelegateVtxo as a };

package/dist/index-B22cA64m.d.cts

@@ -0,0 +1,199 @@
+import { o as RelativeTimelock, V as VtxoScript, p as TapLeafScript, aL as ContractHandler, aS as Discoverable } from './ark-TZ1gXAXU.cjs';
+import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-BFZs69hp.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.
+ *
+ * Each contract type ("default", "vhtlc", etc.) has a handler that knows
+ * how to create VtxoScripts, serialize params, and select spending paths.
+ *
+ * @example
+ * ```typescript
+ * // Register a custom handler
+ * contractHandlers.register(myCustomHandler);
+ *
+ * // Get handler for a type
+ * const handler = contractHandlers.get("vhtlc");
+ * const script = handler.createScript(contract.params);
+ * ```
+ */
+declare class ContractHandlerRegistry {
+    private handlers;
+    /**
+     * Register a contract handler.
+     *
+     * @param handler - The handler to register
+     * @throws If a handler for this type is already registered
+     */
+    register(handler: ContractHandler<unknown>): void;
+    /**
+     * Get a handler by type.
+     *
+     * @param type - The contract type
+     * @returns The handler, or undefined if not found
+     */
+    get(type: string): ContractHandler<unknown> | undefined;
+    /**
+     * Get a handler by type, throwing if not found.
+     *
+     * @param type - The contract type
+     * @returns The handler
+     * @throws If no handler is registered for this type
+     */
+    getOrThrow(type: string): ContractHandler<unknown>;
+    /**
+     * Check if a handler is registered.
+     *
+     * @param type - The contract type
+     */
+    has(type: string): boolean;
+    /**
+     * Get all registered types.
+     */
+    getRegisteredTypes(): string[];
+    /**
+     * Unregister a handler (mainly for testing).
+     */
+    unregister(type: string): boolean;
+    /**
+     * Clear all handlers (mainly for testing).
+     */
+    clear(): void;
+}
+/**
+ * Global registry of contract handlers.
+ */
+declare const contractHandlers: ContractHandlerRegistry;
+
+/**
+ * Typed parameters for DefaultVtxo contracts.
+ */
+interface DefaultContractParams {
+    pubKey: Uint8Array;
+    serverPubKey: Uint8Array;
+    csvTimelock: RelativeTimelock;
+}
+/**
+ * Handler for default wallet VTXOs.
+ *
+ * Default contracts use the standard forfeit + exit tapscript:
+ * - forfeit: (Alice + Server) multisig for collaborative spending
+ * - exit: (Alice) + CSV timelock for unilateral exit
+ */
+declare const DefaultContractHandler: ContractHandler<DefaultContractParams, DefaultVtxo.Script> & Discoverable;
+
+/**
+ * Typed parameters for DelegateVtxo contracts.
+ */
+interface DelegateContractParams {
+    pubKey: Uint8Array;
+    serverPubKey: Uint8Array;
+    delegatePubKey: Uint8Array;
+    csvTimelock: RelativeTimelock;
+}
+/**
+ * Handler for delegate wallet virtual outputs.
+ *
+ * Delegate contracts extend the default tapscript with an additional delegate path:
+ * - forfeit: (Alice + Server) multisig for collaborative spending
+ * - exit: (Alice) + CSV timelock for unilateral exit
+ * - delegate: (Alice + Delegate + Server) multisig for delegated renewal
+ */
+declare const DelegateContractHandler: ContractHandler<DelegateContractParams, DelegateVtxo.Script> & Discoverable;
+
+/**
+ * Typed parameters for VHTLC contracts.
+ */
+interface VHTLCContractParams {
+    sender: Uint8Array;
+    receiver: Uint8Array;
+    server: Uint8Array;
+    preimageHash: Uint8Array;
+    refundLocktime: bigint;
+    unilateralClaimDelay: RelativeTimelock;
+    unilateralRefundDelay: RelativeTimelock;
+    unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+}
+/**
+ * Handler for Virtual Hash Time Lock Contract (VHTLC).
+ *
+ * VHTLC supports multiple spending paths:
+ *
+ * Collaborative paths (with server):
+ * - claim: Receiver + Server with preimage
+ * - refund: Sender + Receiver + Server
+ * - refundWithoutReceiver: Sender + Server after CLTV locktime
+ *
+ * Unilateral paths (without server):
+ * - unilateralClaim: Receiver with preimage after CSV delay
+ * - unilateralRefund: Sender + Receiver after CSV delay
+ * - unilateralRefundWithoutReceiver: Sender after CSV delay
+ */
+declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script>;
+
+export { DefaultContractHandler as D, VHTLC as V, type DefaultContractParams as a, DelegateContractHandler as b, type DelegateContractParams as c, VHTLCContractHandler as d, type VHTLCContractParams as e, contractHandlers as f };

package/dist/{types/storage/index.d.ts → index-C0IanN1m.d.cts}

@@ -1,9 +1,11 @@
 /**
  * @deprecated Use `StorageConfig` with repository implementations such as `IndexedDBWalletRepository` and `IndexedDBContractRepository` instead.
  */
-export interface StorageAdapter {
+interface StorageAdapter {
     getItem(key: string): Promise<string | null>;
     setItem(key: string, value: string): Promise<void>;
     removeItem(key: string): Promise<void>;
     clear(): Promise<void>;
 }
+
+export type { StorageAdapter as S };

package/dist/index-C0IanN1m.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @deprecated Use `StorageConfig` with repository implementations such as `IndexedDBWalletRepository` and `IndexedDBContractRepository` instead.
+ */
+interface StorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+export type { StorageAdapter as S };

package/dist/index-NDla_UoJ.d.ts

@@ -0,0 +1,199 @@
+import { o as RelativeTimelock, V as VtxoScript, p as TapLeafScript, aL as ContractHandler, aS as Discoverable } from './ark-TZ1gXAXU.js';
+import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-aaVGfWsV.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.
+ *
+ * Each contract type ("default", "vhtlc", etc.) has a handler that knows
+ * how to create VtxoScripts, serialize params, and select spending paths.
+ *
+ * @example
+ * ```typescript
+ * // Register a custom handler
+ * contractHandlers.register(myCustomHandler);
+ *
+ * // Get handler for a type
+ * const handler = contractHandlers.get("vhtlc");
+ * const script = handler.createScript(contract.params);
+ * ```
+ */
+declare class ContractHandlerRegistry {
+    private handlers;
+    /**
+     * Register a contract handler.
+     *
+     * @param handler - The handler to register
+     * @throws If a handler for this type is already registered
+     */
+    register(handler: ContractHandler<unknown>): void;
+    /**
+     * Get a handler by type.
+     *
+     * @param type - The contract type
+     * @returns The handler, or undefined if not found
+     */
+    get(type: string): ContractHandler<unknown> | undefined;
+    /**
+     * Get a handler by type, throwing if not found.
+     *
+     * @param type - The contract type
+     * @returns The handler
+     * @throws If no handler is registered for this type
+     */
+    getOrThrow(type: string): ContractHandler<unknown>;
+    /**
+     * Check if a handler is registered.
+     *
+     * @param type - The contract type
+     */
+    has(type: string): boolean;
+    /**
+     * Get all registered types.
+     */
+    getRegisteredTypes(): string[];
+    /**
+     * Unregister a handler (mainly for testing).
+     */
+    unregister(type: string): boolean;
+    /**
+     * Clear all handlers (mainly for testing).
+     */
+    clear(): void;
+}
+/**
+ * Global registry of contract handlers.
+ */
+declare const contractHandlers: ContractHandlerRegistry;
+
+/**
+ * Typed parameters for DefaultVtxo contracts.
+ */
+interface DefaultContractParams {
+    pubKey: Uint8Array;
+    serverPubKey: Uint8Array;
+    csvTimelock: RelativeTimelock;
+}
+/**
+ * Handler for default wallet VTXOs.
+ *
+ * Default contracts use the standard forfeit + exit tapscript:
+ * - forfeit: (Alice + Server) multisig for collaborative spending
+ * - exit: (Alice) + CSV timelock for unilateral exit
+ */
+declare const DefaultContractHandler: ContractHandler<DefaultContractParams, DefaultVtxo.Script> & Discoverable;
+
+/**
+ * Typed parameters for DelegateVtxo contracts.
+ */
+interface DelegateContractParams {
+    pubKey: Uint8Array;
+    serverPubKey: Uint8Array;
+    delegatePubKey: Uint8Array;
+    csvTimelock: RelativeTimelock;
+}
+/**
+ * Handler for delegate wallet virtual outputs.
+ *
+ * Delegate contracts extend the default tapscript with an additional delegate path:
+ * - forfeit: (Alice + Server) multisig for collaborative spending
+ * - exit: (Alice) + CSV timelock for unilateral exit
+ * - delegate: (Alice + Delegate + Server) multisig for delegated renewal
+ */
+declare const DelegateContractHandler: ContractHandler<DelegateContractParams, DelegateVtxo.Script> & Discoverable;
+
+/**
+ * Typed parameters for VHTLC contracts.
+ */
+interface VHTLCContractParams {
+    sender: Uint8Array;
+    receiver: Uint8Array;
+    server: Uint8Array;
+    preimageHash: Uint8Array;
+    refundLocktime: bigint;
+    unilateralClaimDelay: RelativeTimelock;
+    unilateralRefundDelay: RelativeTimelock;
+    unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+}
+/**
+ * Handler for Virtual Hash Time Lock Contract (VHTLC).
+ *
+ * VHTLC supports multiple spending paths:
+ *
+ * Collaborative paths (with server):
+ * - claim: Receiver + Server with preimage
+ * - refund: Sender + Receiver + Server
+ * - refundWithoutReceiver: Sender + Server after CLTV locktime
+ *
+ * Unilateral paths (without server):
+ * - unilateralClaim: Receiver with preimage after CSV delay
+ * - unilateralRefund: Sender + Receiver after CSV delay
+ * - unilateralRefundWithoutReceiver: Sender after CSV delay
+ */
+declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script>;
+
+export { DefaultContractHandler as D, VHTLC as V, type DefaultContractParams as a, DelegateContractHandler as b, type DelegateContractParams as c, VHTLCContractHandler as d, type VHTLCContractParams as e, contractHandlers as f };