@arkade-os/sdk 0.4.15 → 0.4.16

package/dist/cjs/providers/delegator.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestDelegatorProvider = void 0;
 const intent_1 = require("../intent");
 /**
- * REST-based Delegator provider implementation.
+ * REST-based delegation provider implementation.
  * @example
  * ```typescript
  * const provider = new RestDelegatorProvider('https://delegator.example.com');
@@ -12,9 +12,22 @@ const intent_1 = require("../intent");
  * ```
  */
 class RestDelegatorProvider {
+    /**
+     * Create a REST delegation provider targeting the given base URL.
+     *
+     * @param url - Base URL of the delegation service
+     */
     constructor(url) {
         this.url = url;
     }
+    /**
+     * Submit a delegation request to the remote delegation service.
+     *
+     * @param intent - Signed register intent to delegate
+     * @param forfeitTxs - Forfeit transactions associated with the delegation request
+     * @param options - Optional delegate behavior flags
+     * @throws Error if the remote service rejects the request
+     */
     async delegate(intent, forfeitTxs, options) {
         const url = `${this.url}/v1/delegate`;
         const response = await fetch(url, {
@@ -36,6 +49,12 @@ class RestDelegatorProvider {
             throw new Error(`Failed to delegate: ${errorText}`);
         }
     }
+    /**
+     * Fetch delegate metadata exposed by the remote delegation service.
+     *
+     * @returns Delegate identity and fee information
+     * @throws Error if the remote service returns invalid data
+     */
     async getDelegateInfo() {
         const url = `${this.url}/v1/delegator/info`;
         const response = await fetch(url);

package/dist/cjs/providers/expoArk.js

@@ -4,7 +4,7 @@ exports.ExpoArkProvider = void 0;
 const ark_1 = require("./ark");
 const expoUtils_1 = require("./expoUtils");
 /**
- * Expo-compatible Ark provider implementation using expo/fetch for SSE support.
+ * Expo-compatible Arkade provider implementation using expo/fetch for SSE support.
  * This provider works specifically in React Native/Expo environments where
  * standard EventSource is not available but expo/fetch provides SSE capabilities.
  *
@@ -12,7 +12,7 @@ const expoUtils_1 = require("./expoUtils");
  * ```typescript
  * import { ExpoArkProvider } from '@arkade-os/sdk/providers/expo';
  *
- * const provider = new ExpoArkProvider('https://ark.example.com');
+ * const provider = new ExpoArkProvider('https://arkade.computer');
  * const info = await provider.getInfo();
  * ```
  */

package/dist/cjs/providers/indexer.js

@@ -20,11 +20,11 @@ var ChainTxType;
     ChainTxType["CHECKPOINT"] = "INDEXER_CHAINED_TX_TYPE_CHECKPOINT";
 })(ChainTxType || (exports.ChainTxType = ChainTxType = {}));
 /**
- * REST-based Indexer provider implementation.
+ * REST-based indexer provider implementation.
  * @see https://buf.build/arkade-os/arkd/docs/main:ark.v1#ark.v1.IndexerService
  * @example
  * ```typescript
- * const provider = new RestIndexerProvider('https://ark.indexer.example.com');
+ * const provider = new RestIndexerProvider('https://arkade.computer');
  * const commitmentTx = await provider.getCommitmentTx("6686af8f3be3517880821f62e6c3d749b9d6713736a1d8e229a55daa659446b2");
  * ```
  */

package/dist/cjs/providers/onchain.js

@@ -13,11 +13,12 @@ exports.ESPLORA_URL = {
 };
 /**
  * Implementation of the onchain provider interface for esplora REST API.
+ *
  * @see https://mempool.space/docs/api/rest
  * @example
  * ```typescript
  * const provider = new EsploraProvider("https://mempool.space/api");
- * const utxos = await provider.getCoins("bcrt1q679zsd45msawvr7782r0twvmukns3drlstjt77");
+ * const outputs = await provider.getCoins("bcrt1q679zsd45msawvr7782r0twvmukns3drlstjt77");
  * ```
  */
 class EsploraProvider {

package/dist/cjs/repositories/realm/schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Realm object schemas for the Ark wallet.
+ * Realm object schemas for the Arkade wallet.
  *
  * All schema names are prefixed with "Ark" to avoid collisions with
  * other Realm schemas in the consuming application.
@@ -96,7 +96,7 @@ exports.ArkContractSchema = {
     },
 };
 /**
- * All Realm schemas needed by the Ark wallet repositories.
+ * All Realm schemas needed by the Arkade wallet repositories.
  * Pass this array to your Realm configuration's `schema` property.
  */
 exports.ArkRealmSchemas = [

package/dist/cjs/repositories/realm/types.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * Minimal interface for the subset of the Realm API used by the
- * Ark repositories.  Consumers pass their real Realm instance and
+ * Arkade repositories. Consumers pass their real Realm instance and
  * the compiler validates it satisfies this shape.
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/script/address.js

@@ -4,13 +4,20 @@ exports.ArkAddress = void 0;
 const base_1 = require("@scure/base");
 const script_js_1 = require("@scure/btc-signer/script.js");
 /**
- * ArkAddress allows to create and decode bech32m encoded ark address.
- * An ark address is composed of:
+ * ArkAddress allows creating and decoding bech32m-encoded Arkade addresses.
+ *
+ * An Arkade address is composed of:
  * - a human readable prefix (hrp)
  * - a version byte (1 byte)
  * - a server public key (32 bytes)
  * - a vtxo taproot public key (32 bytes)
  *
+ * @remarks
+ * This is an Arkade-specific address format.
+ * It is distinct from the Taproot onchain address returned by `VtxoScript.onchainAddress`.
+ *
+ * @see VtxoScript
+ *
  * @example
  * ```typescript
  * const address = new ArkAddress(
@@ -26,6 +33,16 @@ const script_js_1 = require("@scure/btc-signer/script.js");
  * ```
  */
 class ArkAddress {
+    /**
+     * Create an Arkade address from its server key, vtxo taproot public key, and prefix.
+     *
+     * @param serverPubKey - 32-byte Arkade server public key
+     * @param vtxoTaprootKey - 32-byte tweaked vtxo taproot public key
+     * @param hrp - Bech32 human-readable prefix
+     * @param version - Address version byte
+     * @defaultValue `version = 0`
+     * @throws Error if either public key is not 32 bytes long
+     */
     constructor(serverPubKey, vtxoTaprootKey, hrp, version = 0) {
         this.serverPubKey = serverPubKey;
         this.vtxoTaprootKey = vtxoTaprootKey;
@@ -40,13 +57,21 @@ class ArkAddress {
                 vtxoTaprootKey.length);
         }
     }
+    /**
+     * Decode an Arkade address from its bech32m string form.
+     *
+     * @param address - Bech32m-encoded Arkade address
+     * @returns Decoded Arkade address
+     * @throws Error if the address is malformed or has an invalid payload length
+     * @see encode
+     */
     static decode(address) {
         const decoded = base_1.bech32m.decodeUnsafe(address, 1023);
         if (!decoded) {
             throw new Error("Invalid address");
         }
         const data = new Uint8Array(base_1.bech32m.fromWords(decoded.words));
-        // First the version byte, then 32 bytes server pubkey, then 32 bytes vtxo taproot pubkey
+        // First the version byte, then 32 bytes server pubkey, then 32 bytes vtxo taproot public key.
         if (data.length !== 1 + 32 + 32) {
             throw new Error("Invalid data length, expected 65 bytes, got " + data.length);
         }
@@ -55,8 +80,14 @@ class ArkAddress {
         const vtxoTaprootPubKey = data.slice(33, 65);
         return new ArkAddress(serverPubKey, vtxoTaprootPubKey, decoded.prefix, version);
     }
+    /**
+     * Encode the address to its bech32m string form.
+     *
+     * @returns Bech32m-encoded Arkade address
+     * @see decode
+     */
     encode() {
-        // Combine version byte, server pubkey, and vtxo taproot pubkey
+        // Combine version byte, server pubkey, and vtxo taproot public key.
         const data = new Uint8Array(1 + 32 + 32);
         data[0] = this.version;
         data.set(this.serverPubKey, 1);
@@ -64,11 +95,11 @@ class ArkAddress {
         const words = base_1.bech32m.toWords(data);
         return base_1.bech32m.encode(this.hrp, words, 1023);
     }
-    // pkScript is the script that should be used to send non-dust funds to the address
+    /** ScriptPubKey used to send non-dust funds to the address. */
     get pkScript() {
         return script_js_1.Script.encode(["OP_1", this.vtxoTaprootKey]);
     }
-    // subdustPkScript is the script that should be used to send sub-dust funds to the address
+    /** ScriptPubKey used to send sub-dust funds to the address. */
     get subdustPkScript() {
         return script_js_1.Script.encode(["RETURN", this.vtxoTaprootKey]);
     }

package/dist/cjs/script/base.js

@@ -49,18 +49,35 @@ function scriptFromTapLeafScript(leaf) {
 }
 /**
  * VtxoScript is a script that contains a list of tapleaf scripts.
- * It is used to create vtxo scripts.
+ * It is used to create virtual output scripts.
+ *
+ * @see ArkAddress
  *
  * @example
  * ```typescript
  * const vtxoScript = new VtxoScript([new Uint8Array(32), new Uint8Array(32)]);
+ * ```
  */
 class VtxoScript {
+    /**
+     * Decode a virtual output script from an encoded TapTree.
+     *
+     * @param tapTree - Encoded TapTree bytes
+     * @returns Decoded virtual output script
+     * @throws Error if the TapTree cannot be decoded into a valid script set
+     * @see encode
+     */
     static decode(tapTree) {
         const leaves = exports.TapTreeCoder.decode(tapTree);
         const scripts = leaves.map((leaf) => leaf.script);
         return new VtxoScript(scripts);
     }
+    /**
+     * Create a virtual output script from its tapleaf scripts.
+     *
+     * @param scripts - Raw tapscript bytes for each leaf
+     * @throws Error if the provided leaves cannot produce a valid Taproot tree
+     */
     constructor(scripts) {
         this.scripts = scripts;
         // reverse the scripts if the number of scripts is odd
@@ -81,6 +98,12 @@ class VtxoScript {
         this.leaves = payment.tapLeafScript;
         this.tweakedPublicKey = payment.tweakedPubkey;
     }
+    /**
+     * Encode the virtual output script to a TapTree byte representation.
+     *
+     * @returns Encoded TapTree bytes
+     * @see decode
+     */
     encode() {
         const tapTree = exports.TapTreeCoder.encode(this.scripts.map((script) => ({
             depth: 1,
@@ -89,18 +112,40 @@ class VtxoScript {
         })));
         return tapTree;
     }
+    /**
+     * Build the Arkade address corresponding to this virtual output script.
+     *
+     * @param prefix - Bech32 human-readable prefix
+     * @param serverPubKey - 32-byte Arkade server public key
+     * @returns Arkade address for this script
+     * @see ArkAddress
+     */
     address(prefix, serverPubKey) {
         return new address_1.ArkAddress(serverPubKey, this.tweakedPublicKey, prefix);
     }
     get pkScript() {
         return btc_signer_1.Script.encode(["OP_1", this.tweakedPublicKey]);
     }
+    /**
+     * Build the Taproot onchain address corresponding to this virtual output script.
+     *
+     * @param network - Bitcoin network descriptor
+     * @returns Taproot onchain address
+     * @see address
+     */
     onchainAddress(network) {
         return (0, btc_signer_1.Address)(network).encode({
             type: "tr",
             pubkey: this.tweakedPublicKey,
         });
     }
+    /**
+     * Look up a tapleaf script by its hex-encoded tapscript body.
+     *
+     * @param scriptHex - Hex-encoded tapscript body without the leaf version byte
+     * @returns Matching tapleaf script
+     * @throws Error if no matching leaf exists
+     */
     findLeaf(scriptHex) {
         const leaf = this.leaves.find((leaf) => base_1.hex.encode(scriptFromTapLeafScript(leaf)) === scriptHex);
         if (!leaf) {
@@ -108,6 +153,12 @@ class VtxoScript {
         }
         return leaf;
     }
+    /**
+     * Return all unilateral exit paths embedded in the virtual output script.
+     *
+     * @returns CSV-based exit paths found in the leaves
+     * @see getSequence
+     */
     exitPaths() {
         const paths = [];
         for (const leaf of this.leaves) {
@@ -130,6 +181,24 @@ class VtxoScript {
     }
 }
 exports.VtxoScript = VtxoScript;
+/**
+ * Extract the timelock value encoded in a timelocked tapleaf, if any.
+ *
+ * The return value is unit-ambiguous: for a CSV leaf it is a BIP-68
+ * nSequence (relative timelock); for a CLTV leaf it is an absolute
+ * nLockTime. Callers must know which leaf shape they are inspecting to
+ * interpret the number correctly, and must not copy a CSV result into
+ * `Transaction.lockTime` (or vice versa).
+ *
+ * @param tapLeafScript - Tapleaf script to inspect
+ * @returns The encoded timelock value, or `undefined` when neither a CSV
+ *          nor CLTV path is present
+ * @see VtxoScript.exitPaths
+ */
+// TODO(next-major): return a discriminated union
+// (`{ kind: "relative", nSequence } | { kind: "absolute", lockTime }`)
+// so callers can't conflate the two. Deferred because changing the
+// return type is a breaking change.
 function getSequence(tapLeafScript) {
     let sequence = undefined;
     try {

package/dist/cjs/script/default.js

@@ -25,6 +25,7 @@ var DefaultVtxo;
      * ```
      */
     class Script extends base_1.VtxoScript {
+        /** Create the default virtual output script with one forfeit path and one exit path. */
         constructor(options) {
             const { pubKey, serverPubKey, csvTimelock = Script.DEFAULT_TIMELOCK, } = options;
             const forfeitScript = tapscript_1.MultisigTapscript.encode({
@@ -39,9 +40,11 @@ var DefaultVtxo;
             this.forfeitScript = base_2.hex.encode(forfeitScript);
             this.exitScript = base_2.hex.encode(exitScript);
         }
+        /** Return the forfeit tapleaf script. */
         forfeit() {
             return this.findLeaf(this.forfeitScript);
         }
+        /** Return the unilateral exit tapleaf script. */
         exit() {
             return this.findLeaf(this.exitScript);
         }

package/dist/cjs/script/delegate.js

@@ -24,6 +24,7 @@ var DelegateVtxo;
      * ```
      */
     class Script extends base_1.VtxoScript {
+        /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */
         constructor(options) {
             const defaultVtxo = new default_1.DefaultVtxo.Script(options);
             const { delegatePubKey, pubKey, serverPubKey } = options;
@@ -35,12 +36,15 @@ var DelegateVtxo;
             this.defaultVtxo = defaultVtxo;
             this.delegateScript = base_2.hex.encode(delegateScript);
         }
+        /** Return the forfeit tapleaf script. */
         forfeit() {
             return this.findLeaf(this.defaultVtxo.forfeitScript);
         }
+        /** Return the unilateral exit tapleaf script. */
         exit() {
             return this.findLeaf(this.defaultVtxo.exitScript);
         }
+        /** Return the delegate tapleaf script. */
         delegate() {
             return this.findLeaf(this.delegateScript);
         }

package/dist/cjs/script/tapscript.js

@@ -48,9 +48,9 @@ var TapscriptType;
     TapscriptType["CLTVMultisig"] = "cltv-multisig";
 })(TapscriptType || (exports.TapscriptType = TapscriptType = {}));
 /**
- * decodeTapscript is a function that decodes an ark tapsript from a raw script.
+ * decodeTapscript is a function that decodes an Arkade tapscript from a raw script.
  *
- * @throws {Error} if the script is not a valid ark tapscript
+ * @throws {Error} if the script is not a valid Arkade tapscript
  * @example
  * ```typescript
  * const arkTapscript = decodeTapscript(new Uint8Array(32));
@@ -92,6 +92,7 @@ var MultisigTapscript;
         MultisigType[MultisigType["CHECKSIG"] = 0] = "CHECKSIG";
         MultisigType[MultisigType["CHECKSIGADD"] = 1] = "CHECKSIGADD";
     })(MultisigType = MultisigTapscript.MultisigType || (MultisigTapscript.MultisigType = {}));
+    /** Encode a plain multisig tapscript. */
     function encode(params) {
         if (params.pubkeys.length === 0) {
             throw new Error("At least 1 pubkey is required");
@@ -129,6 +130,7 @@ var MultisigTapscript;
         };
     }
     MultisigTapscript.encode = encode;
+    /** Decode a plain multisig tapscript from raw script bytes. */
     function decode(script) {
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
@@ -241,6 +243,7 @@ var MultisigTapscript;
             script,
         };
     }
+    /** Return true when the tapscript is a plain multisig tapscript. */
     function is(tapscript) {
         return tapscript.type === TapscriptType.Multisig;
     }
@@ -261,6 +264,7 @@ var MultisigTapscript;
  */
 var CSVMultisigTapscript;
 (function (CSVMultisigTapscript) {
+    /** Encode a CSV multisig tapscript. */
     function encode(params) {
         for (const pubkey of params.pubkeys) {
             if (pubkey.length !== 32) {
@@ -287,6 +291,7 @@ var CSVMultisigTapscript;
         };
     }
     CSVMultisigTapscript.encode = encode;
+    /** Decode a CSV multisig tapscript from raw script bytes. */
     function decode(script) {
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
@@ -338,6 +343,7 @@ var CSVMultisigTapscript;
         };
     }
     CSVMultisigTapscript.decode = decode;
+    /** Return true when the tapscript is a CSV multisig tapscript. */
     function is(tapscript) {
         return tapscript.type === TapscriptType.CSVMultisig;
     }
@@ -357,6 +363,7 @@ var CSVMultisigTapscript;
  */
 var ConditionCSVMultisigTapscript;
 (function (ConditionCSVMultisigTapscript) {
+    /** Encode a condition + CSV multisig tapscript. */
     function encode(params) {
         const script = new Uint8Array([
             ...params.conditionScript,
@@ -370,6 +377,7 @@ var ConditionCSVMultisigTapscript;
         };
     }
     ConditionCSVMultisigTapscript.encode = encode;
+    /** Decode a condition + CSV multisig tapscript from raw script bytes. */
     function decode(script) {
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
@@ -413,6 +421,7 @@ var ConditionCSVMultisigTapscript;
         };
     }
     ConditionCSVMultisigTapscript.decode = decode;
+    /** Return true when the tapscript is a condition + CSV multisig tapscript. */
     function is(tapscript) {
         return tapscript.type === TapscriptType.ConditionCSVMultisig;
     }
@@ -432,6 +441,7 @@ var ConditionCSVMultisigTapscript;
  */
 var ConditionMultisigTapscript;
 (function (ConditionMultisigTapscript) {
+    /** Encode a condition + multisig tapscript. */
     function encode(params) {
         const script = new Uint8Array([
             ...params.conditionScript,
@@ -445,6 +455,7 @@ var ConditionMultisigTapscript;
         };
     }
     ConditionMultisigTapscript.encode = encode;
+    /** Decode a condition + multisig tapscript from raw script bytes. */
     function decode(script) {
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
@@ -488,6 +499,7 @@ var ConditionMultisigTapscript;
         };
     }
     ConditionMultisigTapscript.decode = decode;
+    /** Return true when the tapscript is a condition + multisig tapscript. */
     function is(tapscript) {
         return tapscript.type === TapscriptType.ConditionMultisig;
     }
@@ -507,6 +519,7 @@ var ConditionMultisigTapscript;
  */
 var CLTVMultisigTapscript;
 (function (CLTVMultisigTapscript) {
+    /** Encode a CLTV multisig tapscript. */
     function encode(params) {
         const locktime = MinimalScriptNum.encode(params.absoluteTimelock);
         const asm = [
@@ -526,6 +539,7 @@ var CLTVMultisigTapscript;
         };
     }
     CLTVMultisigTapscript.encode = encode;
+    /** Decode a CLTV multisig tapscript from raw script bytes. */
     function decode(script) {
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
@@ -573,6 +587,7 @@ var CLTVMultisigTapscript;
         };
     }
     CLTVMultisigTapscript.decode = decode;
+    /** Return true when the tapscript is a CLTV multisig tapscript. */
     function is(tapscript) {
         return tapscript.type === TapscriptType.CLTVMultisig;
     }

package/dist/cjs/script/vhtlc.js

@@ -5,36 +5,38 @@ const btc_signer_1 = require("@scure/btc-signer");
 const tapscript_1 = require("./tapscript");
 const base_1 = require("@scure/base");
 const base_2 = require("./base");
-/**
- * Virtual Hash Time Lock Contract (VHTLC) implementation.
- *
- * VHTLC is a contract that enables atomic swaps and conditional payments
- * in the Ark 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 }
- * });
- * ```
- */
+/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
 var VHTLC;
 (function (VHTLC) {
+    /**
+     * 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 base_2.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;
@@ -79,21 +81,27 @@ var VHTLC;
             this.unilateralRefundScript = base_1.hex.encode(unilateralRefundScript);
             this.unilateralRefundWithoutReceiverScript = base_1.hex.encode(unilateralRefundWithoutReceiverScript);
         }
+        /** Return the collaborative claim tapleaf script. */
         claim() {
             return this.findLeaf(this.claimScript);
         }
+        /** Return the collaborative refund tapleaf script. */
         refund() {
             return this.findLeaf(this.refundScript);
         }
+        /** Return the refund-without-receiver tapleaf script. */
         refundWithoutReceiver() {
             return this.findLeaf(this.refundWithoutReceiverScript);
         }
+        /** Return the unilateral claim tapleaf script. */
         unilateralClaim() {
             return this.findLeaf(this.unilateralClaimScript);
         }
+        /** Return the unilateral refund tapleaf script. */
         unilateralRefund() {
             return this.findLeaf(this.unilateralRefundScript);
         }
+        /** Return the unilateral refund-without-receiver tapleaf script. */
         unilateralRefundWithoutReceiver() {
             return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
         }

package/dist/cjs/storage/fileSystem.js

@@ -37,7 +37,7 @@ exports.FileSystemStorageAdapter = void 0;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 class FileSystemStorageAdapter {
     constructor(dirPath) {

package/dist/cjs/storage/inMemory.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryStorageAdapter = void 0;
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 class InMemoryStorageAdapter {
     constructor() {

package/dist/cjs/storage/indexedDB.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexedDBStorageAdapter = void 0;
 const db_1 = require("../repositories/indexedDB/db");
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 class IndexedDBStorageAdapter {
     constructor(dbName, version = db_1.DB_VERSION) {

package/dist/cjs/storage/localStorage.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorageAdapter = void 0;
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 class LocalStorageAdapter {
     getSafeLocalStorage() {

package/dist/cjs/tree/validation.js

@@ -38,7 +38,7 @@ function validateConnectorsTxGraph(settlementTxB64, connectorsGraph) {
     if (rootInput.index !== BATCH_OUTPUT_CONNECTORS_INDEX)
         throw exports.ErrWrongSettlementTxid;
 }
-// ValidateVtxoTxGraph checks if the given vtxo graph is valid.
+// ValidateVtxoTxGraph checks if the given virtual output tx graph is valid.
 // The function validates:
 // - the number of nodes
 // - the number of leaves