@arkade-os/sdk 0.4.15 → 0.4.17

package/dist/types/script/base.d.ts

@@ -15,26 +15,91 @@ export declare const TapTreeCoder: (typeof PSBTOutput.tapTree)[2];
 export declare function scriptFromTapLeafScript(leaf: TapLeafScript): Bytes;
 /**
  * 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)]);
+ * ```
  */
 export declare class VtxoScript {
     readonly scripts: Bytes[];
     readonly leaves: TapLeafScript[];
     readonly tweakedPublicKey: Bytes;
+    /**
+     * 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: Bytes): VtxoScript;
+    /**
+     * 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: Bytes[]);
+    /**
+     * Encode the virtual output script to a TapTree byte representation.
+     *
+     * @returns Encoded TapTree bytes
+     * @see decode
+     */
     encode(): Bytes;
+    /**
+     * 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: string, serverPubKey: Bytes): ArkAddress;
     get pkScript(): Bytes;
+    /**
+     * Build the Taproot onchain address corresponding to this virtual output script.
+     *
+     * @param network - Bitcoin network descriptor
+     * @returns Taproot onchain address
+     * @see address
+     */
     onchainAddress(network: typeof NETWORK): string;
+    /**
+     * 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: string): TapLeafScript;
+    /**
+     * Return all unilateral exit paths embedded in the virtual output script.
+     *
+     * @returns CSV-based exit paths found in the leaves
+     * @see getSequence
+     */
     exitPaths(): Array<CSVMultisigTapscript.Type | ConditionCSVMultisigTapscript.Type>;
 }
 export type EncodedVtxoScript = {
     tapTree: Bytes;
 };
+/**
+ * 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
+ */
 export declare function getSequence(tapLeafScript: TapLeafScript): number | undefined;

package/dist/types/script/default.d.ts

@@ -34,8 +34,11 @@ export declare namespace DefaultVtxo {
         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;
     }
 }

package/dist/types/script/delegate.d.ts

@@ -28,9 +28,13 @@ export declare namespace DelegateVtxo {
         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;
     }
 }

package/dist/types/script/tapscript.d.ts

@@ -29,9 +29,9 @@ export interface ArkTapscript<T extends TapscriptType, Params> {
     script: Uint8Array;
 }
 /**
- * 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));
@@ -59,8 +59,11 @@ export declare namespace MultisigTapscript {
         pubkeys: Bytes[];
         type?: MultisigType;
     };
+    /** Encode a plain multisig tapscript. */
     function encode(params: Params): Type;
+    /** Decode a plain multisig tapscript from raw script bytes. */
     function decode(script: Uint8Array): Type;
+    /** Return true when the tapscript is a plain multisig tapscript. */
     function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
 }
 /**
@@ -81,8 +84,11 @@ export declare namespace CSVMultisigTapscript {
     type Params = {
         timelock: RelativeTimelock;
     } & MultisigTapscript.Params;
+    /** Encode a CSV multisig tapscript. */
     function encode(params: Params): Type;
+    /** Decode a CSV multisig tapscript from raw script bytes. */
     function decode(script: Uint8Array): Type;
+    /** Return true when the tapscript is a CSV multisig tapscript. */
     function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
 }
 /**
@@ -102,8 +108,11 @@ export declare namespace ConditionCSVMultisigTapscript {
     type Params = {
         conditionScript: Bytes;
     } & CSVMultisigTapscript.Params;
+    /** Encode a condition + CSV multisig tapscript. */
     function encode(params: Params): Type;
+    /** Decode a condition + CSV multisig tapscript from raw script bytes. */
     function decode(script: Uint8Array): Type;
+    /** Return true when the tapscript is a condition + CSV multisig tapscript. */
     function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
 }
 /**
@@ -123,8 +132,11 @@ export declare namespace ConditionMultisigTapscript {
     type Params = {
         conditionScript: Bytes;
     } & MultisigTapscript.Params;
+    /** Encode a condition + multisig tapscript. */
     function encode(params: Params): Type;
+    /** Decode a condition + multisig tapscript from raw script bytes. */
     function decode(script: Uint8Array): Type;
+    /** Return true when the tapscript is a condition + multisig tapscript. */
     function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
 }
 /**
@@ -144,7 +156,10 @@ export declare namespace CLTVMultisigTapscript {
     type Params = {
         absoluteTimelock: bigint;
     } & MultisigTapscript.Params;
+    /** Encode a CLTV multisig tapscript. */
     function encode(params: Params): Type;
+    /** Decode a CLTV multisig tapscript from raw script bytes. */
     function decode(script: Uint8Array): Type;
+    /** Return true when the tapscript is a CLTV multisig tapscript. */
     function is(tapscript: ArkTapscript<any, any>): tapscript is Type;
 }

package/dist/types/script/vhtlc.d.ts

@@ -1,33 +1,7 @@
 import { Bytes } from "@scure/btc-signer/utils.js";
 import { RelativeTimelock } from "./tapscript";
 import { TapLeafScript, VtxoScript } from "./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. */
 export declare namespace VHTLC {
     interface Options {
         sender: Bytes;
@@ -39,6 +13,33 @@ export declare namespace VHTLC {
         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;
@@ -47,12 +48,19 @@ export declare namespace VHTLC {
         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;
     }
 }

package/dist/types/storage/fileSystem.d.ts

@@ -1,6 +1,6 @@
 import type { StorageAdapter } from "./index";
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 export declare class FileSystemStorageAdapter implements StorageAdapter {
     private readonly basePath;

package/dist/types/storage/inMemory.d.ts

@@ -1,6 +1,6 @@
 import type { StorageAdapter } from "./index";
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 export declare class InMemoryStorageAdapter implements StorageAdapter {
     private store;

package/dist/types/storage/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @deprecated Use StorageConfig instead
+ * @deprecated Use `StorageConfig` with repository implementations such as `IndexedDBWalletRepository` and `IndexedDBContractRepository` instead.
  */
 export interface StorageAdapter {
     getItem(key: string): Promise<string | null>;

package/dist/types/storage/indexedDB.d.ts

@@ -1,6 +1,6 @@
 import type { StorageAdapter } from "./index";
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 export declare class IndexedDBStorageAdapter implements StorageAdapter {
     private dbName;

package/dist/types/storage/localStorage.d.ts

@@ -1,6 +1,6 @@
 import type { StorageAdapter } from "./index";
 /**
- * @deprecated Use repositories instead
+ * @deprecated Use repository implementations via `StorageConfig` instead.
  */
 export declare class LocalStorageAdapter implements StorageAdapter {
     private getSafeLocalStorage;

package/dist/types/utils/arkTransaction.d.ts

@@ -16,7 +16,7 @@ export type OffchainTx = {
  *
  * Creates one checkpoint transaction per input and a virtual transaction that
  * combines all the checkpoints, sending to the specified outputs. This is the
- * core function for creating Ark transactions.
+ * core function for creating Arkade transactions.
  *
  * @param inputs - Array of virtual transaction inputs
  * @param outputs - Array of transaction outputs
@@ -42,8 +42,8 @@ export declare function verifyTapscriptSignatures(tx: Transaction, inputIndex: n
  */
 export declare function combineTapscriptSigs(signedTx: Transaction, originalTx: Transaction): Transaction;
 /**
- * Validates if a given string is a valid Ark address by attempting to decode it.
- * @param address The Ark address to validate.
+ * Validates if a given string is a valid Arkade address by attempting to decode it.
+ * @param address The Arkade address to validate.
  * @returns True if the address is valid, false otherwise.
  */
 export declare function isValidArkAddress(address: string): boolean;

package/dist/types/utils/bip21.d.ts

@@ -1,12 +1,16 @@
+/** Known BIP21 parameters including Arkade-specific extensions. */
 export interface BIP21Params {
     address?: string;
     amount?: number;
     label?: string;
     message?: string;
+    /** Optional Arkade address parameter. */
     ark?: string;
+    /** Optional Silent Payment address parameter. */
     sp?: string;
     [key: string]: string | number | undefined;
 }
+/** Result returned by `BIP21.parse`. */
 export interface BIP21ParseResult {
     originalString: string;
     params: BIP21Params;
@@ -16,6 +20,19 @@ export declare enum BIP21Error {
     INVALID_ADDRESS = "Invalid address"
 }
 export declare class BIP21 {
+    /**
+     * Create a BIP21 URI from the provided parameters.
+     *
+     * @param params - BIP21 parameters to encode
+     * @returns Encoded BIP21 URI
+     */
     static create(params: BIP21Params): string;
+    /**
+     * Parse a BIP21 URI and return its decoded parameters.
+     *
+     * @param uri - BIP21 URI to parse
+     * @returns Parsed BIP21 URI data
+     * @throws Error if the URI does not start with the `bitcoin:` scheme
+     */
     static parse(uri: string): BIP21ParseResult;
 }

package/dist/types/utils/syncCursors.d.ts

@@ -1,7 +1,7 @@
 import { WalletRepository, WalletState } from "../repositories/walletRepository";
 /** Lag behind real-time to avoid racing with indexer writes. */
 export declare const SAFETY_LAG_MS = 30000;
-/** Overlap window so boundary VTXOs are never missed. */
+/** Overlap window so boundary virtual outputs are never missed. */
 export declare const OVERLAP_MS = 60000;
 type SyncCursors = Record<string, number>;
 /**
@@ -38,15 +38,15 @@ export declare function clearSyncCursors(repo: WalletRepository, scripts?: strin
  * Returns `undefined` when the script has no cursor (bootstrap needed).
  *
  * No upper bound (`before`) is applied to the query so that freshly
- * created VTXOs are never excluded. The safety lag is applied only
- * when advancing the cursor (see {@link cursorCutoff}).
+ * created virtual outputs are never excluded. The safety lag is applied only
+ * when advancing the cursor (see @see cursorCutoff).
  */
 export declare function computeSyncWindow(cursor: number | undefined): {
     after: number;
 } | undefined;
 /**
  * The safe high-water mark for cursor advancement.
- * Lags behind real-time by {@link SAFETY_LAG_MS} so that VTXOs still
+ * Lags behind real-time by @see SAFETY_LAG_MS so that virtual outputs still
  * being indexed are re-queried on the next sync.
  *
  * When `requestStartedAt` is provided the cutoff is frozen to the

package/dist/types/utils/transaction.d.ts

@@ -3,7 +3,7 @@ import { TxOpts } from "@scure/btc-signer/transaction";
 import { Bytes } from "@scure/btc-signer/utils";
 /**
  * Transaction is a wrapper around the @scure/btc-signer Transaction class.
- * It adds the Ark protocol specific options to the transaction.
+ * It adds the Arkade protocol specific options to the transaction.
  */
 export declare class Transaction extends BtcSignerTransaction {
     static ARK_TX_OPTS: TxOpts;

package/dist/types/utils/transactionHistory.d.ts

@@ -3,13 +3,13 @@ type ExtendedArkTransaction = ArkTransaction & {
     tag: "offchain" | "boarding" | "exit" | "batch";
 };
 /**
- * Builds the transaction history by analyzing virtual coins (VTXOs), boarding transactions, and ignored commitments.
+ * Builds the transaction history by analyzing virtual outputs, boarding transactions, and ignored commitments.
  * History is sorted from newest to oldest and is composed only of SENT and RECEIVED transactions.
  *
- * @param {VirtualCoin[]} vtxos - An array of virtual coins representing the user's transactions and balances.
+ * @param {VirtualCoin[]} vtxos - An array of virtual outputs representing the user's transactions and balances.
  * @param {ArkTransaction[]} allBoardingTxs - An array of boarding transactions to include in the history.
  * @param {Set<string>} commitmentsToIgnore - A set of commitment IDs that should be excluded from processing.
- * @return {ExtendedArkTransaction[]} A sorted array of extended Ark transactions, representing the transaction history.
+ * @return {ExtendedArkTransaction[]} A sorted array of extended Arkade transactions, representing the transaction history.
  */
 export declare function buildTransactionHistory(vtxos: VirtualCoin[], allBoardingTxs: ArkTransaction[], commitmentsToIgnore: Set<string>, getTxCreatedAt?: (txid: string) => Promise<number | undefined>): Promise<ExtendedArkTransaction[]>;
 export {};

package/dist/types/utils/unknownFields.d.ts

@@ -1,7 +1,7 @@
 import { Transaction } from "@scure/btc-signer";
 import { TransactionInputUpdate } from "@scure/btc-signer/psbt.js";
 /**
- * ArkPsbtFieldKey is the key values for ark psbt fields.
+ * ArkPsbtFieldKey are the available key names for the Arkade PSBT custom fields.
  */
 export declare enum ArkPsbtFieldKey {
     VtxoTaprootTree = "taptree",
@@ -10,13 +10,13 @@ export declare enum ArkPsbtFieldKey {
     ConditionWitness = "condition"
 }
 /**
- * ArkPsbtFieldKeyType is the type of the ark psbt field key.
- * Every ark psbt field has key type 222.
+ * ArkPsbtFieldKeyType is the key type of the Arkade PSBT custom field.
+ * Every Arkade PSBT field has key type 222.
  */
 export declare const ArkPsbtFieldKeyType = 222;
 /**
- * ArkPsbtFieldCoder is the coder for the ark psbt fields.
- * each type has its own coder.
+ * ArkPsbtFieldCoder is the coder for the Arkade PSBT custom fields.
+ * Each type has its own coder.
  */
 export interface ArkPsbtFieldCoder<T> {
     key: ArkPsbtFieldKey;

package/dist/types/wallet/asset-manager.d.ts

@@ -15,7 +15,7 @@ export declare class AssetManager extends ReadonlyAssetManager implements IAsset
      * @param params.amount - Amount of asset units to issue
      * @param params.controlAssetId - Optional control asset ID (for reissuable assets)
      * @param params.metadata - Optional metadata to attach to the asset
-     * @returns Promise resolving to the ark transaction ID and asset ID
+     * @returns Promise resolving to the Arkade transaction ID and asset ID
      *
      * @example
      * ```typescript
@@ -39,7 +39,7 @@ export declare class AssetManager extends ReadonlyAssetManager implements IAsset
      * @param params - Parameters for asset reissuance
      * @param params.assetId - The asset ID to reissue (control asset ID is resolved via getAssetDetails)
      * @param params.amount - Amount of additional units to issue
-     * @returns Promise resolving to the ark transaction ID
+     * @returns Promise resolving to the Arkade transaction ID
      *
      * @example
      * ```typescript
@@ -55,7 +55,7 @@ export declare class AssetManager extends ReadonlyAssetManager implements IAsset
      * @param params - Parameters for burning
      * @param params.assetId - The asset ID to burn
      * @param params.amount - Amount of units to burn
-     * @returns Promise resolving to the ark transaction ID
+     * @returns Promise resolving to the Arkade transaction ID
      *
      * @example
      * ```typescript

package/dist/types/wallet/batch.d.ts

@@ -10,7 +10,7 @@ import { TxTree } from "../tree/txTree";
  * const handler = wallet.createBatchHandler(intentId, inputs, expectedRecipients, musig2session);
  *
  * const abortController = new AbortController();
- * // Get event stream from Ark provider
+ * // Get event stream from the Arkade provider
  * const eventStream = arkProvider.getEventStream(
  *   abortController.signal,
  *   ['your-topic-1', 'your-topic-2']
@@ -39,7 +39,7 @@ export declare namespace Batch {
         /**
          * Called when tree signing starts.
          * @param event The tree signing started event.
-         * @param vtxoTree The unsigned VTXO tree, reconstructed from the TreeTxEvent events.
+         * @param vtxoTree The unsigned virtual output tree, reconstructed from the TreeTxEvent events.
          * @returns Promise resolving to a boolean indicating whether to continue processing.
          */
         onTreeSigningStarted(event: TreeSigningStartedEvent, vtxoTree: TxTree): Promise<{
@@ -56,21 +56,41 @@ export declare namespace Batch {
         /**
          * Called during batch finalization.
          * @param event The batch finalization event.
-         * @param vtxoTree The signed VTXO tree, reconstructed from the TreeTxEvent events.
+         * @param vtxoTree The signed virtual output tree, reconstructed from the TreeTxEvent events.
          * @param connectorTree The connector transaction tree, reconstructed from the TreeTxEvent events.
          */
         onBatchFinalization(event: BatchFinalizationEvent, vtxoTree?: TxTree, connectorTree?: TxTree): Promise<void>;
+        /**
+         * Called when batch finalization completes successfully.
+         *
+         * @param event - Batch finalized event
+         */
         onBatchFinalized?(event: BatchFinalizedEvent): Promise<void>;
+        /**
+         * Called when batch processing fails.
+         *
+         * @param event - Batch failed event
+         */
         onBatchFailed?(event: BatchFailedEvent): Promise<void>;
+        /**
+         * Called for each virtual output tree transaction chunk received during batch processing.
+         *
+         * @param event - Tree transaction event
+         */
         onTreeTxEvent?(event: TreeTxEvent): Promise<void>;
+        /**
+         * Called for each tree signature event received during batch processing.
+         *
+         * @param event - Tree signature event
+         */
         onTreeSignatureEvent?(event: TreeSignatureEvent): Promise<void>;
     }
     /**
      * Options for the join function.
-     * @param @optional abortController - The abort controller to use to abort the operation.
-     * @param @optional skipVtxoTreeSigning - ignore events related to vtxo tree musig2 signing session.
-     * @param @optional eventCallback - A callback to be called for each event.
-     * @param eventCallback - A callback to be called for each event.
+     *
+     * @property abortController - Abort controller used to cancel batch processing.
+     * @property skipVtxoTreeSigning - Ignore events related to the virtual output tree musig2 signing session.
+     * @property eventCallback - Callback invoked for each settlement event received while joining the batch.
      */
     type JoinOptions = Partial<{
         abortController: AbortController;

package/dist/types/wallet/delegator.d.ts

@@ -3,6 +3,14 @@ import { ArkProvider, DelegateInfo, ExtendedVirtualCoin, Identity, Outpoint } fr
 import { DelegatorProvider } from "../providers/delegator";
 import { Bytes } from "@scure/btc-signer/utils";
 export interface IDelegatorManager {
+    /**
+     * Delegate virtual outputs to the remote delegation service.
+     *
+     * @param vtxos - Virtual outputs to delegate
+     * @param destination - Arkade address that should receive renewed funds
+     * @param delegateAt - Optional timestamp to force a specific delegation time
+     * @returns Successfully delegated and failed outpoint groups
+     */
     delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
         delegated: Outpoint[];
         failed: {
@@ -10,12 +18,14 @@ export interface IDelegatorManager {
             error: unknown;
         }[];
     }>;
+    /** Fetch delegate metadata such as pubkey, fee, and delegate address. */
     getDelegateInfo(): Promise<DelegateInfo>;
 }
 export declare class DelegatorManagerImpl implements IDelegatorManager {
     readonly delegatorProvider: DelegatorProvider;
     readonly arkInfoProvider: Pick<ArkProvider, "getInfo">;
     readonly identity: Identity;
+    /** Create a delegator manager from the configured provider, Arkade info source, and wallet identity. */
     constructor(delegatorProvider: DelegatorProvider, arkInfoProvider: Pick<ArkProvider, "getInfo">, identity: Identity);
     getDelegateInfo(): Promise<DelegateInfo>;
     delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{

package/dist/types/wallet/expo/background.d.ts

@@ -3,7 +3,7 @@ import type { ContractRepository } from "../../repositories/contractRepository";
 import type { AsyncStorageTaskQueue } from "../../worker/expo/asyncStorageTaskQueue";
 import type { TaskProcessor } from "../../worker/expo/taskRunner";
 /**
- * Wallet parameters persisted by {@link ExpoWallet.setup} and read
+ * Wallet parameters persisted by @see ExpoWallet.setup and read
  * by the background handler to reconstruct providers and `extendVtxo`
  * without a network call.
  */
@@ -15,7 +15,7 @@ export interface PersistedBackgroundConfig {
     exitTimelockType: "blocks" | "seconds";
 }
 /**
- * Options for {@link defineExpoBackgroundTask}.
+ * Options for @see defineExpoBackgroundTask.
  */
 export interface DefineBackgroundTaskOptions {
     /** AsyncStorage-backed queue (must match the one passed to ExpoWallet.setup). */
@@ -52,8 +52,8 @@ export declare function defineExpoBackgroundTask(taskName: string, options: Defi
 /**
  * Activate the OS-level background task scheduler.
  *
- * Call this after {@link defineExpoBackgroundTask} (typically inside
- * {@link ExpoWallet.setup} or in a React component after wallet init).
+ * Call this after @see defineExpoBackgroundTask (typically inside
+ * @see ExpoWallet.setup or in a React component after wallet init).
  *
  * @param minimumInterval - Minimum interval in minutes (default 15).
  */