@arkade-os/sdk 0.4.14 → 0.4.16

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

@@ -1,13 +1,49 @@
 import { Transaction } from "../utils/transaction";
 import { SignerSession } from "../tree/signingSession";
 export interface Identity extends ReadonlyIdentity {
+    /** Returns a signer session used for musig2 tree signing flows. */
     signerSession(): SignerSession;
+    /** Sign an arbitrary message using the requested signature type. */
     signMessage(message: Uint8Array, signatureType: "schnorr" | "ecdsa"): Promise<Uint8Array>;
+    /**
+     * Sign the provided transaction inputs.
+     *
+     * @param tx - Transaction to sign
+     * @param inputIndexes - Optional input indexes to sign. When omitted, the implementation should sign every signable input.
+     */
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
 }
 export interface ReadonlyIdentity {
+    /** Returns the x-only public key used by Taproot scripts. */
     xOnlyPublicKey(): Promise<Uint8Array>;
+    /** Returns the compressed public key for this identity. */
     compressedPublicKey(): Promise<Uint8Array>;
 }
+/** A single PSBT signing request within a batch. */
+export interface SignRequest {
+    tx: Transaction;
+    inputIndexes?: number[];
+}
+/**
+ * Identity that supports signing multiple PSBTs in a single wallet interaction.
+ * Browser wallet providers that support batch signing (e.g. Xverse, UniSat, OKX)
+ * should implement this interface to reduce the number of confirmation popups
+ * from N+1 to 1 during Arkade send transactions.
+ *
+ * Contract: implementations MUST return exactly one `Transaction` per request,
+ * in the same order as the input array. The SDK validates this at runtime and
+ * will throw if the lengths do not match.
+ */
+export interface BatchSignableIdentity extends Identity {
+    /**
+     * Sign multiple transactions in a single wallet interaction.
+     *
+     * @param requests - Transactions and optional input indexes to sign
+     * @returns Signed transactions in the same order as the input requests
+     */
+    signMultiple(requests: SignRequest[]): Promise<Transaction[]>;
+}
+/** Type guard for identities that support batch signing. */
+export declare function isBatchSignable(identity: Identity): identity is BatchSignableIdentity;
 export * from "./singleKey";
 export * from "./seedIdentity";

package/dist/types/identity/seedIdentity.d.ts

@@ -1,21 +1,23 @@
 import { Identity, ReadonlyIdentity } from ".";
 import { Transaction } from "../utils/transaction";
 import { SignerSession } from "../tree/signingSession";
-/** Use default BIP86 derivation with network selection. */
+/** Used for default BIP86 derivation with network selection. */
 export interface NetworkOptions {
     /**
      * Mainnet (coin type 0) or testnet (coin type 1).
-     * @default true
+     *
+     * @defaultValue `true`
      */
     isMainnet?: boolean;
 }
-/** Use a custom output descriptor for derivation. */
+/** Used for custom output descriptor derivation. */
 export interface DescriptorOptions {
     /** Custom output descriptor that determines the derivation path. */
     descriptor: string;
 }
-/** Either default BIP86 derivation (with optional network) or a custom descriptor. */
+/** Either default BIP86 derivation (with optional network selection) or a custom descriptor. */
 export type SeedIdentityOptions = NetworkOptions | DescriptorOptions;
+/** Used for deriving an identity from a BIP39 mnemonic. */
 export type MnemonicOptions = SeedIdentityOptions & {
     /** Optional BIP39 passphrase for additional seed entropy. */
     passphrase?: string;
@@ -29,7 +31,7 @@ export type MnemonicOptions = SeedIdentityOptions & {
  * format is HD-ready, allowing future support for multiple addresses
  * and change derivation.
  *
- * Prefer this (or {@link MnemonicIdentity}) over `SingleKey` for new
+ * Prefer this (or @see MnemonicIdentity) over `SingleKey` for new
  * integrations — `SingleKey` exists for backward compatibility with
  * raw nsec-style keys.
  *
@@ -61,7 +63,7 @@ export declare class SeedIdentity implements Identity {
      * @param seed - 64-byte seed (typically from mnemonicToSeedSync)
      * @param opts - Network selection or custom descriptor.
      */
-    static fromSeed(seed: Uint8Array, opts: SeedIdentityOptions): SeedIdentity;
+    static fromSeed(seed: Uint8Array, opts?: SeedIdentityOptions): SeedIdentity;
     xOnlyPublicKey(): Promise<Uint8Array>;
     compressedPublicKey(): Promise<Uint8Array>;
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
@@ -77,7 +79,7 @@ export declare class SeedIdentity implements Identity {
  *
  * This is the most user-friendly identity type — recommended for wallet
  * applications where users manage their own backup phrase. Extends
- * {@link SeedIdentity} with mnemonic validation and optional passphrase
+ * @see SeedIdentity with mnemonic validation and optional passphrase
  * support.
  *
  * @example
@@ -99,7 +101,7 @@ export declare class MnemonicIdentity extends SeedIdentity {
      * @param phrase - BIP39 mnemonic phrase (12 or 24 words)
      * @param opts - Network selection or custom descriptor, plus optional passphrase
      */
-    static fromMnemonic(phrase: string, opts: MnemonicOptions): MnemonicIdentity;
+    static fromMnemonic(phrase: string, opts?: MnemonicOptions): MnemonicIdentity;
 }
 /**
  * Watch-only identity from an output descriptor.

package/dist/types/identity/singleKey.d.ts

@@ -22,8 +22,11 @@ import { SignerSession } from "../tree/signingSession";
 export declare class SingleKey implements Identity {
     private key;
     private constructor();
+    /** Create a signing identity from raw private key bytes. */
     static fromPrivateKey(privateKey: Uint8Array): SingleKey;
+    /** Create a signing identity from a hex-encoded private key. */
     static fromHex(privateKeyHex: string): SingleKey;
+    /** Create a signing identity with a freshly generated random private key. */
     static fromRandomBytes(): SingleKey;
     /**
      * Export the private key as a hex string.
@@ -40,6 +43,7 @@ export declare class SingleKey implements Identity {
 }
 export declare class ReadonlySingleKey implements ReadonlyIdentity {
     private readonly publicKey;
+    /** Create a readonly identity from a compressed public key. */
     constructor(publicKey: Uint8Array);
     /**
      * Create a ReadonlySingleKey from a compressed public key.

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ import { Transaction } from "./utils/transaction";
 import { SingleKey, ReadonlySingleKey } from "./identity/singleKey";
 import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity } from "./identity/seedIdentity";
 import type { SeedIdentityOptions, MnemonicOptions, NetworkOptions, DescriptorOptions } from "./identity/seedIdentity";
-import { Identity, ReadonlyIdentity } from "./identity";
+import { Identity, ReadonlyIdentity, BatchSignableIdentity, SignRequest, isBatchSignable } from "./identity";
 import { ArkAddress } from "./script/address";
 import { VHTLC } from "./script/vhtlc";
 import { DefaultVtxo } from "./script/default";
@@ -50,5 +50,5 @@ import { IContractManager } from "./contracts/contractManager";
 import { closeDatabase, openDatabase } from "./repositories/indexedDB/manager";
 import { WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError } from "./wallet/serviceWorker/wallet-message-handler";
 import { MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError } from "./worker/errors";
-export { Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, MessageBus, WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, ArkNote, networks, closeDatabase, openDatabase, IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, Intent, BIP322, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };
-export type { Identity, ReadonlyIdentity, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, SeedIdentityOptions, MnemonicOptions, NetworkOptions, DescriptorOptions, IndexerProvider, PageResponse, BatchInfo, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, FeeInfo, ArkInfo, SignedIntent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, SettlementConfig, IVtxoManager, Asset, Recipient, IssuanceParams, IssuanceResult, ReissuanceParams, BurnParams, AssetDetails, AssetMetadata, KnownMetadata, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, StorageConfig, Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, IContractManager, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams, MessageHandler, RequestEnvelope, ResponseEnvelope, MessageTimeouts, IDelegatorManager, DelegatorProvider, DelegateInfo, DelegateOptions, WalletRepository, ContractRepository, MigrationStatus, };
+export { Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, isBatchSignable, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, MessageBus, WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, ArkNote, networks, closeDatabase, openDatabase, IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, Intent, BIP322, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };
+export type { Identity, ReadonlyIdentity, BatchSignableIdentity, SignRequest, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, SeedIdentityOptions, MnemonicOptions, NetworkOptions, DescriptorOptions, IndexerProvider, PageResponse, BatchInfo, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, FeeInfo, ArkInfo, SignedIntent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, SettlementConfig, IVtxoManager, Asset, Recipient, IssuanceParams, IssuanceResult, ReissuanceParams, BurnParams, AssetDetails, AssetMetadata, KnownMetadata, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, StorageConfig, Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, IContractManager, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams, MessageHandler, RequestEnvelope, ResponseEnvelope, MessageTimeouts, IDelegatorManager, DelegatorProvider, DelegateInfo, DelegateOptions, WalletRepository, ContractRepository, MigrationStatus, };

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

@@ -5,10 +5,11 @@ import { ExtendedCoin } from "../wallet";
  * Intent proof implementation for Bitcoin message signing.
  *
  * Intent proof defines a standard for signing Bitcoin messages as well as proving
- * ownership of coins. This namespace provides utilities for creating and
- * validating Intent proof.
+ * ownership of outputs.
  *
- * it is greatly inspired by BIP322.
+ * This namespace provides utilities for creating and validating Intent proof.
+ *
+ * It is greatly inspired by BIP322.
  * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
  *
  * @example
@@ -30,15 +31,21 @@ export declare namespace Intent {
      * Creates a new Intent proof unsigned transaction.
      *
      * This function constructs a special transaction that can be signed to prove
-     * ownership of VTXOs and UTXOs. The proof includes the message to be
+     * ownership of onchain and virtual outputs. The proof includes the message to be
      * signed and the inputs/outputs that demonstrate ownership.
      *
      * @param message - The Intent message to be signed, either raw string of Message object
-     * @param inputs - Array of transaction inputs to prove ownership of
+     * @param ins - Array of transaction inputs to prove ownership of
      * @param outputs - Optional array of transaction outputs
      * @returns An unsigned Intent proof transaction
      */
     function create(message: string | Message, ins: (TransactionInput | ExtendedCoin)[], outputs?: TransactionOutput[]): Proof;
+    /**
+     * Compute the fee paid by an intent proof transaction.
+     *
+     * @param proof - Intent proof transaction
+     * @returns The fee in satoshis
+     */
     function fee(proof: Proof): number;
     type RegisterMessage = {
         type: "register";
@@ -56,6 +63,12 @@ export declare namespace Intent {
         expire_at: number;
     };
     type Message = RegisterMessage | DeleteMessage | GetPendingTxMessage;
+    /**
+     * Serialize an intent message to the canonical JSON string used for signing.
+     *
+     * @param message - Intent message payload
+     * @returns Canonical string form of the message
+     */
     function encodeMessage(message: Message): string;
 }
 export declare const OP_RETURN_EMPTY_PKSCRIPT: Uint8Array<ArrayBuffer>;
@@ -68,6 +81,6 @@ export declare const TAG_INTENT_PROOF = "ark-intent-proof-message";
  *
  * @param message - The message to embed
  * @param pkScript - The scriptPubKey of the signer's address
- * @param tag - Tagged-hash tag (defaults to the Ark intent proof tag)
+ * @param tag - Tagged-hash tag (defaults to the Arkade intent proof tag)
  */
 export declare function craftToSpendTx(message: string, pkScript: Uint8Array, tag?: string): Transaction;

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

@@ -3,8 +3,11 @@ import { TreeNonces, TreePartialSigs } from "../tree/signingSession";
 import { Vtxo } from "./indexer";
 import type { IntentFeeConfig } from "../arkfee";
 import { Intent } from "../intent";
+/** Output requested during settlement or transaction submission. */
 export type Output = {
+    /** Destination address, either onchain or Arkade (offchain). */
     address: string;
+    /** Amount to send in satoshis. */
     amount: bigint;
 };
 export declare enum SettlementEventType {
@@ -44,6 +47,7 @@ export type TreeNoncesEvent = {
     id: string;
     topic: string[];
     txid: string;
+    /** Musig2 public nonces keyed by cosigner public key. */
     nonces: TreeNonces;
 };
 export type BatchStartedEvent = {
@@ -108,53 +112,87 @@ export interface ArkInfo {
     sessionDuration: bigint;
     signerPubkey: string;
     unilateralExitDelay: bigint;
+    /**
+     * Maximum boarding input amount.
+     *
+     * @remarks
+     * `-1` means unlimited, while `0` disables boarding.
+     */
     utxoMaxAmount: bigint;
     utxoMinAmount: bigint;
     version: string;
+    /**
+     * Maximum virtual output amount.
+     *
+     * @remarks
+     * `-1` means unlimited.
+     */
     vtxoMaxAmount: bigint;
     vtxoMinAmount: bigint;
 }
+/** Signed intent payload sent to the Arkade server. */
 export interface SignedIntent<T extends Intent.Message> {
+    /** Base64-encoded signed proof transaction. */
     proof: string;
+    /** Intent message payload associated with the proof. */
     message: T;
 }
+/** Transaction notification emitted by the Arkade server stream. */
 export interface TxNotification {
+    /** Transaction id. */
     txid: string;
+    /** Raw transaction payload. */
     tx: string;
+    /** Virtual outputs spent by the transaction. */
     spentVtxos: Vtxo[];
+    /** Virtual outputs made spendable by the transaction. */
     spendableVtxos: Vtxo[];
+    /** Optional checkpoint transactions associated with the notification. */
     checkpointTxs?: Record<string, {
         txid: string;
         tx: string;
     }>;
 }
 export interface ArkProvider {
+    /** Fetch Arkade server configuration and fee settings. */
     getInfo(): Promise<ArkInfo>;
+    /** Submit a signed Arkade transaction and its checkpoint transactions. */
     submitTx(signedArkTx: string, checkpointTxs: string[]): Promise<{
         arkTxid: string;
         finalArkTx: string;
         signedCheckpointTxs: string[];
     }>;
+    /** Finalize a previously submitted Arkade transaction. */
     finalizeTx(arkTxid: string, finalCheckpointTxs: string[]): Promise<void>;
+    /** Register a signed intent with the Arkade server. */
     registerIntent(intent: SignedIntent<Intent.RegisterMessage>): Promise<string>;
+    /** Delete a previously registered intent. */
     deleteIntent(intent: SignedIntent<Intent.DeleteMessage>): Promise<void>;
+    /** Confirm an already registered intent id. */
     confirmRegistration(intentId: string): Promise<void>;
+    /** Submit musig2 tree nonces for a batch signing session. */
     submitTreeNonces(batchId: string, pubkey: string, nonces: TreeNonces): Promise<void>;
+    /** Submit musig2 partial signatures for a batch signing session. */
     submitTreeSignatures(batchId: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
+    /** Submit signed forfeit transactions for cooperative settlement. */
     submitSignedForfeitTxs(signedForfeitTxs: string[], signedCommitmentTx?: string): Promise<void>;
+    /** Open the settlement event stream for the given topics. */
     getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
+    /** Stream transaction notifications emitted by the Arkade server. */
     getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<{
         commitmentTx?: TxNotification;
         arkTx?: TxNotification;
     }>;
+    /** Fetch pending transactions for a signed get-pending-tx intent. */
     getPendingTxs(intent: SignedIntent<Intent.GetPendingTxMessage>): Promise<PendingTx[]>;
 }
 /**
- * REST-based Ark provider implementation.
+ * REST-based Arkade provider implementation.
+ *
  * @see https://buf.build/arkade-os/arkd/docs/main:ark.v1#ark.v1.ArkService
  * @example
  * ```typescript
- * const provider = new RestArkProvider('https://ark.example.com');
+ * const provider = new RestArkProvider('https://arkade.computer');
  * const info = await provider.getInfo();
  * ```
  */

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

@@ -1,19 +1,53 @@
 import { Intent } from "../intent";
 import { SignedIntent } from "./ark";
+/**
+ * Delegate identity and fee information returned by `getDelegateInfo`.
+ */
 export interface DelegateInfo {
+    /** Delegate public key. */
     pubkey: string;
+    /** Delegate fee amount or expression returned by the delegation service. */
     fee: string;
+    /**
+     * Address controlled by the delegation service.
+     * Naming is confusing: should be thought of as a "delegate address".
+     */
     delegatorAddress: string;
 }
+/**
+ * Optional delegate behavior flags.
+ */
 export interface DelegateOptions {
+    /**
+     * Instruct the delegate not to replace an existing delegation
+     * (meaning a signed register intent and its forfeit transactions)
+     * that already includes at least one virtual output from this request.
+     *
+     * @defaultValue `false`
+     */
     rejectReplace?: boolean;
 }
+/**
+ * Provider interface for remote delegation services.
+ */
 export interface DelegatorProvider {
+    /**
+     * Request delegation for a signed register intent and its forfeit transactions.
+     *
+     * @param intent - Signed register intent to delegate
+     * @param forfeitTxs - Forfeit transactions associated with the delegation request
+     * @param options - Optional delegate behavior flags
+     */
     delegate(intent: SignedIntent<Intent.RegisterMessage>, forfeitTxs: string[], options?: DelegateOptions): Promise<void>;
+    /**
+     * Fetch delegate metadata such as pubkey, fee, and delegate address.
+     *
+     * @returns Delegate identity and fee information
+     */
     getDelegateInfo(): Promise<DelegateInfo>;
 }
 /**
- * REST-based Delegator provider implementation.
+ * REST-based delegation provider implementation.
  * @example
  * ```typescript
  * const provider = new RestDelegatorProvider('https://delegator.example.com');
@@ -23,7 +57,26 @@ export interface DelegatorProvider {
  */
 export declare class RestDelegatorProvider implements DelegatorProvider {
     url: string;
+    /**
+     * Create a REST delegation provider targeting the given base URL.
+     *
+     * @param url - Base URL of the delegation service
+     */
     constructor(url: string);
+    /**
+     * 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
+     */
     delegate(intent: SignedIntent<Intent.RegisterMessage>, forfeitTxs: string[], options?: DelegateOptions): Promise<void>;
+    /**
+     * Fetch delegate metadata exposed by the remote delegation service.
+     *
+     * @returns Delegate identity and fee information
+     * @throws Error if the remote service returns invalid data
+     */
     getDelegateInfo(): Promise<DelegateInfo>;
 }

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

@@ -1,6 +1,6 @@
 import { RestArkProvider, SettlementEvent, TxNotification } from "./ark";
 /**
- * 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.
  *
@@ -8,7 +8,7 @@ import { RestArkProvider, SettlementEvent, TxNotification } from "./ark";
  * ```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/types/providers/indexer.d.ts

@@ -33,6 +33,7 @@ export interface ChainTx {
     txid: string;
     expiresAt: string;
     type: ChainTxType;
+    /** IDs of the transactions in the chain used as input of the current transaction. */
     spends: string[];
 }
 export interface CommitmentTx {
@@ -101,61 +102,163 @@ export interface SubscriptionHeartbeat {
 export interface SubscriptionEvent extends SubscriptionResponse {
     type: "event";
 }
+/**
+ * Filters accepted by `IndexerProvider.getVtxos`.
+ *
+ * @remarks
+ * Exactly one of `scripts` or `outpoints` must be supplied.
+ *
+ * @see IndexerProvider.getVtxos
+ */
 export type GetVtxosOptions = PaginationOptions & {
+    /** Only return spendable virtual outputs. */
     spendableOnly?: boolean;
+    /** Only return spent virtual outputs. */
     spentOnly?: boolean;
+    /** Only return recoverable virtual outputs. */
     recoverableOnly?: boolean;
+    /** Only return pending/preconfirmed virtual outputs. */
     pendingOnly?: boolean;
+    /** Only return virtual outputs created after this timestamp. */
     after?: number;
+    /** Only return virtual outputs created before this timestamp. */
     before?: number;
 } & ({
+    /** Scripts to search for matching virtual outputs. */
     scripts: string[];
     outpoints?: never;
 } | {
+    /** Explicit outpoints to fetch. */
     outpoints: Outpoint[];
     scripts?: never;
 });
 export interface IndexerProvider {
+    /**
+     * Fetch the virtual output tree for a batch outpoint.
+     *
+     * @param batchOutpoint - Batch outpoint whose tree should be fetched
+     * @param opts - Optional pagination settings
+     * @returns virtual output tree nodes and optional pagination state
+     */
     getVtxoTree(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
         vtxoTree: Tx[];
         page?: PageResponse;
     }>;
+    /**
+     * Fetch the leaf outpoints for a batch virtual output tree.
+     *
+     * @param batchOutpoint - Batch outpoint whose leaf outpoints should be fetched
+     * @param opts - Optional pagination settings
+     * @returns Leaf outpoints and optional pagination state
+     */
     getVtxoTreeLeaves(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
         leaves: Outpoint[];
         page?: PageResponse;
     }>;
+    /**
+     * Fetch sweep transactions that spent a batch.
+     *
+     * @param batchOutpoint - Batch outpoint to inspect
+     * @returns Sweep transaction ids
+     */
     getBatchSweepTransactions(batchOutpoint: Outpoint): Promise<{
         sweptBy: string[];
     }>;
+    /**
+     * Fetch a commitment transaction by txid.
+     *
+     * @param txid - Commitment transaction id
+     * @returns Commitment transaction details
+     */
     getCommitmentTx(txid: string): Promise<CommitmentTx>;
+    /**
+     * Fetch connector transactions for a commitment transaction.
+     *
+     * @param txid - Commitment transaction id
+     * @param opts - Optional pagination settings
+     * @returns Connector transactions and optional pagination state
+     */
     getCommitmentTxConnectors(txid: string, opts?: PaginationOptions): Promise<{
         connectors: Tx[];
         page?: PageResponse;
     }>;
+    /**
+     * Fetch forfeit transaction ids for a commitment transaction.
+     *
+     * @param txid - Commitment transaction id
+     * @param opts - Optional pagination settings
+     * @returns Forfeit transaction ids and optional pagination state
+     */
     getCommitmentTxForfeitTxs(txid: string, opts?: PaginationOptions): Promise<{
         txids: string[];
         page?: PageResponse;
     }>;
+    /**
+     * Open a streamed subscription for a previously created subscription id.
+     *
+     * @param subscriptionId - Subscription identifier returned by `subscribeForScripts`
+     * @param abortSignal - Signal used to terminate the stream
+     * @returns Async iterator of subscription responses
+     */
     getSubscription(subscriptionId: string, abortSignal: AbortSignal): AsyncIterableIterator<SubscriptionResponse>;
+    /**
+     * Fetch raw virtual transactions by txid.
+     *
+     * @param txids - Virtual transaction ids to fetch
+     * @param opts - Optional pagination settings
+     * @returns Raw virtual transactions and optional pagination state
+     */
     getVirtualTxs(txids: string[], opts?: PaginationOptions): Promise<{
         txs: string[];
         page?: PageResponse;
     }>;
+    /**
+     * Fetch the ancestry chain for a virtual output.
+     *
+     * @param vtxoOutpoint - Virtual output outpoint to inspect
+     * @param opts - Optional pagination settings
+     * @returns Chain data and optional pagination state
+     */
     getVtxoChain(vtxoOutpoint: Outpoint, opts?: PaginationOptions): Promise<VtxoChain>;
+    /**
+     * Fetch virtual outputs by script set or outpoints.
+     *
+     * @param opts - Virtual output filters and pagination settings
+     * @returns Virtual outputs and optional pagination state
+     */
     getVtxos(opts?: GetVtxosOptions): Promise<{
         vtxos: VirtualCoin[];
         page?: PageResponse;
     }>;
+    /**
+     * Fetch metadata for a specific asset id.
+     *
+     * @param assetId - Asset identifier
+     * @returns Asset details
+     */
     getAssetDetails(assetId: string): Promise<AssetDetails>;
+    /**
+     * Create or extend a subscription for a set of scripts.
+     *
+     * @param scripts - Scripts to monitor
+     * @param subscriptionId - Existing subscription id to extend
+     * @returns Subscription id
+     */
     subscribeForScripts(scripts: string[], subscriptionId?: string): Promise<string>;
+    /**
+     * Remove some or all scripts from an existing subscription.
+     *
+     * @param subscriptionId - Subscription identifier to update
+     * @param scripts - Scripts to remove, or omit to remove all
+     */
     unsubscribeForScripts(subscriptionId: string, scripts?: string[]): Promise<void>;
 }
 /**
- * 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");
  * ```
  */