@arkade-os/sdk 0.4.14 → 0.4.16

package/dist/types/providers/onchain.d.ts

@@ -16,14 +16,57 @@ export type ExplorerTransaction = {
     };
 };
 export interface OnchainProvider {
+    /**
+     * Fetch spendable onchain outputs for an address.
+     *
+     * @param address - Bitcoin address to query
+     * @returns Spendable onchain outputs for the address
+     * @see Coin
+     */
     getCoins(address: string): Promise<Coin[]>;
+    /**
+     * Fetch the current fastest fee rate estimate.
+     *
+     * @returns Fee rate in sats/vB, if available
+     * @remarks
+     * Implementations may return `undefined` when the backing service does not expose
+     * a usable fee estimate.
+     */
     getFeeRate(): Promise<number | undefined>;
+    /**
+     * Broadcast a single transaction or a 1P1C package.
+     *
+     * @param txs - One or more raw transaction hex strings
+     * @returns Broadcast transaction id
+     * @throws Error if the broadcast request fails or the package shape is invalid
+     */
     broadcastTransaction(...txs: string[]): Promise<string>;
+    /**
+     * Fetch outspend information for every output in a transaction.
+     *
+     * @param txid - Transaction id to inspect
+     * @returns Per-output spend status information
+     * @see getTxStatus
+     */
     getTxOutspends(txid: string): Promise<{
         spent: boolean;
         txid: string;
     }[]>;
+    /**
+     * Fetch transactions associated with an address.
+     *
+     * @param address - Bitcoin address to query
+     * @returns Transactions involving the address
+     * @see ExplorerTransaction
+     */
     getTransactions(address: string): Promise<ExplorerTransaction[]>;
+    /**
+     * Fetch confirmation status for a transaction.
+     *
+     * @param txid - Transaction id to inspect
+     * @returns Confirmation status and block metadata when confirmed
+     * @see getTxOutspends
+     */
     getTxStatus(txid: string): Promise<{
         confirmed: false;
     } | {
@@ -31,20 +74,36 @@ export interface OnchainProvider {
         blockTime: number;
         blockHeight: number;
     }>;
+    /**
+     * Fetch the current chain tip.
+     *
+     * @returns Current chain height, block time, and block hash
+     */
     getChainTip(): Promise<{
         height: number;
         time: number;
         hash: string;
     }>;
+    /**
+     * Watch a set of addresses and invoke the callback when transactions are observed.
+     *
+     * @param addresses - Addresses to monitor
+     * @param eventCallback - Callback invoked when matching transactions are seen
+     * @returns Stop function that cancels the watch
+     * @remarks
+     * Implementations may use websockets, server-sent events, polling, or a hybrid strategy.
+     * @see getTransactions
+     */
     watchAddresses(addresses: string[], eventCallback: (txs: ExplorerTransaction[]) => void): Promise<() => void>;
 }
 /**
  * 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");
  * ```
  */
 export declare class EsploraProvider implements OnchainProvider {
@@ -52,7 +111,9 @@ export declare class EsploraProvider implements OnchainProvider {
     readonly pollingInterval: number;
     readonly forcePolling: boolean;
     constructor(baseUrl: string, opts?: {
+        /** Polling interval in milliseconds. */
         pollingInterval?: number;
+        /** Force polling even when websocket transport is available. */
         forcePolling?: boolean;
     });
     getCoins(address: string): Promise<Coin[]>;

package/dist/types/repositories/realm/schemas.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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.
@@ -108,7 +108,7 @@ export declare const 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.
  */
 export declare const ArkRealmSchemas: ({

package/dist/types/repositories/realm/types.d.ts

@@ -1,13 +1,13 @@
 /**
  * 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.
  */
 /** Result set returned by `realm.objects()`. */
 export interface RealmResults<T = Record<string, unknown>> extends Iterable<T> {
     filtered(query: string, ...args: unknown[]): RealmResults<T>;
 }
-/** The Realm API surface used by Ark repositories. */
+/** The Realm API surface used by Arkade repositories. */
 export interface RealmLike {
     write(callback: () => void): void;
     objects<T = Record<string, unknown>>(schemaName: string): RealmResults<T>;

package/dist/types/repositories/walletRepository.d.ts

@@ -1,10 +1,15 @@
 import { ArkTransaction, ExtendedCoin, ExtendedVirtualCoin } from "../wallet";
 export interface WalletState {
+    /** Timestamp of the last successful wallet sync, in milliseconds. */
     lastSyncTime?: number;
+    /** Arbitrary stored wallet settings. */
     settings?: Record<string, any>;
 }
+/** Stored commitment transaction metadata. */
 export type CommitmentTxRecord = {
+    /** Commitment transaction id. */
     txid: string;
+    /** Creation timestamp in milliseconds. */
     createdAt: number;
 };
 export interface WalletRepository extends AsyncDisposable {
@@ -13,15 +18,26 @@ export interface WalletRepository extends AsyncDisposable {
      * Clear all data from storage.
      */
     clear(): Promise<void>;
+    /** Fetch stored virtual outputs for an address. */
     getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    /** Save virtual outputs for an address. */
     saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
+    /** Delete stored virtual outputs for an address. */
     deleteVtxos(address: string): Promise<void>;
+    /** Fetch stored boarding inputs for an address. */
     getUtxos(address: string): Promise<ExtendedCoin[]>;
+    /** Save boarding inputs for an address. */
     saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    /** Delete stored boarding inputs for an address. */
     deleteUtxos(address: string): Promise<void>;
+    /** Fetch stored transaction history for an address. */
     getTransactionHistory(address: string): Promise<ArkTransaction[]>;
+    /** Save transaction history for an address. */
     saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
+    /** Delete stored transaction history for an address. */
     deleteTransactions(address: string): Promise<void>;
+    /** Fetch stored wallet state. */
     getWalletState(): Promise<WalletState | null>;
+    /** Save wallet state. */
     saveWalletState(state: WalletState): Promise<void>;
 }

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

@@ -1,12 +1,19 @@
 import { Bytes } from "@scure/btc-signer/utils.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,9 +33,35 @@ export declare class ArkAddress {
     readonly vtxoTaprootKey: Bytes;
     readonly hrp: string;
     readonly version: number;
+    /**
+     * 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: Bytes, vtxoTaprootKey: Bytes, hrp: string, version?: number);
+    /**
+     * 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: string): ArkAddress;
+    /**
+     * Encode the address to its bech32m string form.
+     *
+     * @returns Bech32m-encoded Arkade address
+     * @see decode
+     */
     encode(): string;
+    /** ScriptPubKey used to send non-dust funds to the address. */
     get pkScript(): Bytes;
+    /** ScriptPubKey used to send sub-dust funds to the address. */
     get subdustPkScript(): Bytes;
 }

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;