@arkade-os/sdk 0.3.0-alpha.7 → 0.3.0

package/dist/types/index.d.ts

@@ -1,15 +1,16 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
+import { Transaction } from "./utils/transaction";
 import { SingleKey } from "./identity/singleKey";
 import { Identity } from "./identity";
 import { ArkAddress } from "./script/address";
 import { VHTLC } from "./script/vhtlc";
 import { DefaultVtxo } from "./script/default";
-import { VtxoScript, EncodedVtxoScript, TapLeafScript } from "./script/base";
-import { TxType, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, GetVtxosFilter, TapLeaves } from "./wallet";
+import { VtxoScript, EncodedVtxoScript, TapLeafScript, TapTreeCoder } from "./script/base";
+import { TxType, IWallet, WalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, GetVtxosFilter, TapLeaves } from "./wallet";
 import { Wallet, waitForIncomingFunds, IncomingFunds } from "./wallet/wallet";
 import { TxTree, TxTreeNode } from "./tree/txTree";
 import { SignerSession, TreeNonces, TreePartialSigs } from "./tree/signingSession";
 import { Ramps } from "./wallet/ramps";
+import { VtxoManager } from "./wallet/vtxo-manager";
 import { ServiceWorkerWallet } from "./wallet/serviceWorker/wallet";
 import { OnchainWallet } from "./wallet/onchain";
 import { setupServiceWorker } from "./wallet/serviceWorker/utils";
@@ -17,19 +18,20 @@ import { Worker } from "./wallet/serviceWorker/worker";
 import { Request } from "./wallet/serviceWorker/request";
 import { Response } from "./wallet/serviceWorker/response";
 import { ESPLORA_URL, EsploraProvider, OnchainProvider, ExplorerTransaction } from "./providers/onchain";
-import { RestArkProvider, ArkProvider, SettlementEvent, SettlementEventType, ArkInfo, Intent, Output, TxNotification, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour } from "./providers/ark";
+import { RestArkProvider, ArkProvider, SettlementEvent, SettlementEventType, ArkInfo, SignedIntent, Output, TxNotification, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession } from "./providers/ark";
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType, ArkTapscript, RelativeTimelock } from "./script/tapscript";
-import { buildOffchainTx, ArkTxInput, OffchainTx } from "./utils/arkTransaction";
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, ArkTxInput, OffchainTx } from "./utils/arkTransaction";
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry } from "./utils/unknownFields";
-import { BIP322 } from "./bip322";
+import { Intent } from "./intent";
 import { ArkNote } from "./arknote";
 import { networks, Network, NetworkName } from "./networks";
-import { RestIndexerProvider, IndexerProvider, IndexerTxType, ChainTxType, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, VtxoChain, Tx, Vtxo, PaginationOptions, SubscriptionResponse } from "./providers/indexer";
+import { RestIndexerProvider, IndexerProvider, IndexerTxType, ChainTxType, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, VtxoChain, Tx, Vtxo, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent } from "./providers/indexer";
 import { Nonces } from "./musig2/nonces";
 import { PartialSig } from "./musig2/sign";
 import { AnchorBumper, P2A } from "./utils/anchor";
 import { Unroll } from "./wallet/unroll";
 import { WalletRepositoryImpl } from "./repositories/walletRepository";
 import { ContractRepositoryImpl } from "./repositories/contractRepository";
-export { Wallet, SingleKey, OnchainWallet, Ramps, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, waitForIncomingFunds, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, BIP322, TxTree, P2A, Unroll, Transaction, };
-export type { Identity, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, ArkInfo, Intent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour, PaginationOptions, SubscriptionResponse, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };
+import { ArkError, maybeArkError } from "./providers/errors";
+export { Wallet, SingleKey, OnchainWallet, Ramps, VtxoManager, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, Intent, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, };
+export type { Identity, IWallet, WalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, Batch, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, 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, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };

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

@@ -0,0 +1,41 @@
+import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt.js";
+import { Transaction } from "../utils/transaction";
+/**
+ * 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.
+ *
+ * it is greatly inspired by BIP322.
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ *
+ * @example
+ * ```typescript
+ * // Create a Intent proof
+ * const proof = Intent.create(
+ *   "Hello Bitcoin!",
+ *   [input],
+ *   [output]
+ * );
+ *
+ * // Sign the proof
+ * const signedProof = await identity.sign(proof);
+ *
+ */
+export declare namespace Intent {
+    type Proof = Transaction;
+    /**
+     * 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
+     * signed and the inputs/outputs that demonstrate ownership.
+     *
+     * @param message - The Intent message to be signed
+     * @param inputs - 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, inputs: TransactionInput[], outputs?: TransactionOutput[]): Proof;
+}

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

@@ -1,4 +1,4 @@
 export type { Nonces } from "./nonces";
-export { generateNonces } from "./nonces";
+export { generateNonces, aggregateNonces } from "./nonces";
 export { PartialSig, sign } from "./sign";
 export { aggregateKeys } from "./keys";

package/dist/types/musig2/nonces.d.ts

@@ -11,3 +11,4 @@ export type Nonces = {
  * Generates a pair of public and secret nonces for MuSig2 signing
  */
 export declare function generateNonces(publicKey: Uint8Array): Nonces;
+export declare function aggregateNonces(pubNonces: Uint8Array[]): Uint8Array;

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

@@ -11,7 +11,7 @@ export declare enum SettlementEventType {
     BatchFinalized = "batch_finalized",
     BatchFailed = "batch_failed",
     TreeSigningStarted = "tree_signing_started",
-    TreeNoncesAggregated = "tree_nonces_aggregated",
+    TreeNonces = "tree_nonces",
     TreeTx = "tree_tx",
     TreeSignature = "tree_signature"
 }
@@ -36,10 +36,12 @@ export type TreeSigningStartedEvent = {
     cosignersPublicKeys: string[];
     unsignedCommitmentTx: string;
 };
-export type TreeNoncesAggregatedEvent = {
-    type: SettlementEventType.TreeNoncesAggregated;
+export type TreeNoncesEvent = {
+    type: SettlementEventType.TreeNonces;
     id: string;
-    treeNonces: TreeNonces;
+    topic: string[];
+    txid: string;
+    nonces: TreeNonces;
 };
 export type BatchStartedEvent = {
     type: SettlementEventType.BatchStarted;
@@ -62,32 +64,57 @@ export type TreeSignatureEvent = {
     txid: string;
     signature: string;
 };
-export type SettlementEvent = BatchFinalizationEvent | BatchFinalizedEvent | BatchFailedEvent | TreeSigningStartedEvent | TreeNoncesAggregatedEvent | BatchStartedEvent | TreeTxEvent | TreeSignatureEvent;
-export interface MarketHour {
-    nextStartTime: bigint;
+export type SettlementEvent = BatchFinalizationEvent | BatchFinalizedEvent | BatchFailedEvent | TreeSigningStartedEvent | TreeNoncesEvent | BatchStartedEvent | TreeTxEvent | TreeSignatureEvent;
+export interface ScheduledSession {
+    duration: bigint;
+    fees: FeeInfo;
     nextEndTime: bigint;
+    nextStartTime: bigint;
     period: bigint;
-    roundInterval: bigint;
 }
+export interface IntentFeeInfo {
+    offchainInput: string;
+    offchainOutput: string;
+    onchainInput: string;
+    onchainOutput: string;
+}
+export interface FeeInfo {
+    intentFee: IntentFeeInfo;
+    txFeeRate: string;
+}
+export interface PendingTx {
+    arkTxid: string;
+    finalArkTx: string;
+    signedCheckpointTxs: string[];
+}
+export interface DeprecatedSigner {
+    cutoffDate: bigint;
+    pubkey: string;
+}
+export type ServiceStatus = Record<string, string>;
 export interface ArkInfo {
-    signerPubkey: string;
-    vtxoTreeExpiry: bigint;
-    unilateralExitDelay: bigint;
-    roundInterval: bigint;
-    network: string;
+    boardingExitDelay: bigint;
+    checkpointTapscript: string;
+    deprecatedSigners: DeprecatedSigner[];
+    digest: string;
     dust: bigint;
+    fees: FeeInfo;
     forfeitAddress: string;
-    marketHour?: MarketHour;
-    version: string;
-    utxoMinAmount: bigint;
+    forfeitPubkey: string;
+    network: string;
+    scheduledSession: ScheduledSession;
+    serviceStatus: ServiceStatus;
+    sessionDuration: bigint;
+    signerPubkey: string;
+    unilateralExitDelay: bigint;
     utxoMaxAmount: bigint;
-    vtxoMinAmount: bigint;
+    utxoMinAmount: bigint;
+    version: string;
     vtxoMaxAmount: bigint;
-    boardingExitDelay: bigint;
-    checkpointExitClosure: string;
+    vtxoMinAmount: bigint;
 }
-export interface Intent {
-    signature: string;
+export interface SignedIntent {
+    proof: string;
     message: string;
 }
 export interface TxNotification {
@@ -108,8 +135,8 @@ export interface ArkProvider {
         signedCheckpointTxs: string[];
     }>;
     finalizeTx(arkTxid: string, finalCheckpointTxs: string[]): Promise<void>;
-    registerIntent(intent: Intent): Promise<string>;
-    deleteIntent(intent: Intent): Promise<void>;
+    registerIntent(intent: SignedIntent): Promise<string>;
+    deleteIntent(intent: SignedIntent): Promise<void>;
     confirmRegistration(intentId: string): Promise<void>;
     submitTreeNonces(batchId: string, pubkey: string, nonces: TreeNonces): Promise<void>;
     submitTreeSignatures(batchId: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
@@ -119,6 +146,7 @@ export interface ArkProvider {
         commitmentTx?: TxNotification;
         arkTx?: TxNotification;
     }>;
+    getPendingTxs(intent: SignedIntent): Promise<PendingTx[]>;
 }
 /**
  * REST-based Ark provider implementation.
@@ -139,8 +167,8 @@ export declare class RestArkProvider implements ArkProvider {
         signedCheckpointTxs: string[];
     }>;
     finalizeTx(arkTxid: string, finalCheckpointTxs: string[]): Promise<void>;
-    registerIntent(intent: Intent): Promise<string>;
-    deleteIntent(intent: Intent): Promise<void>;
+    registerIntent(intent: SignedIntent): Promise<string>;
+    deleteIntent(intent: SignedIntent): Promise<void>;
     confirmRegistration(intentId: string): Promise<void>;
     submitTreeNonces(batchId: string, pubkey: string, nonces: TreeNonces): Promise<void>;
     submitTreeSignatures(batchId: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
@@ -150,7 +178,149 @@ export declare class RestArkProvider implements ArkProvider {
         commitmentTx?: TxNotification;
         arkTx?: TxNotification;
     }>;
-    private parseSettlementEvent;
-    private parseTransactionNotification;
+    getPendingTxs(intent: SignedIntent): Promise<PendingTx[]>;
+    protected parseSettlementEvent(data: ProtoTypes.GetEventStreamResponse): SettlementEvent | null;
+    protected parseTransactionNotification(data: ProtoTypes.GetTransactionsStreamResponse): {
+        commitmentTx?: TxNotification;
+        arkTx?: TxNotification;
+    } | null;
+}
+declare namespace ProtoTypes {
+    interface BatchStartedEvent {
+        id: string;
+        intentIdHashes: string[];
+        batchExpiry: number;
+    }
+    interface BatchFailed {
+        id: string;
+        reason: string;
+    }
+    export interface BatchFinalizationEvent {
+        id: string;
+        commitmentTx: string;
+    }
+    interface BatchFinalizedEvent {
+        id: string;
+        commitmentTxid: string;
+    }
+    interface TreeSigningStartedEvent {
+        id: string;
+        cosignersPubkeys: string[];
+        unsignedCommitmentTx: string;
+    }
+    interface TreeNoncesAggregatedEvent {
+        id: string;
+        treeNonces: Record<string, string>;
+    }
+    interface TreeNoncesEvent {
+        id: string;
+        topic: string[];
+        txid: string;
+        nonces: Record<string, string>;
+    }
+    interface TreeTxEvent {
+        id: string;
+        topic: string[];
+        batchIndex: number;
+        txid: string;
+        tx: string;
+        children: Record<string, string>;
+    }
+    interface TreeSignatureEvent {
+        id: string;
+        topic: string[];
+        batchIndex: number;
+        txid: string;
+        signature: string;
+    }
+    interface Heartbeat {
+    }
+    export interface VtxoData {
+        outpoint: {
+            txid: string;
+            vout: number;
+        };
+        amount: string;
+        script: string;
+        createdAt: string;
+        expiresAt: string | null;
+        commitmentTxids: string[];
+        isPreconfirmed: boolean;
+        isSwept: boolean;
+        isUnrolled: boolean;
+        isSpent: boolean;
+        spentBy: string;
+        settledBy?: string;
+        arkTxid?: string;
+    }
+    export interface GetEventStreamResponse {
+        batchStarted?: BatchStartedEvent;
+        batchFailed?: BatchFailed;
+        batchFinalization?: BatchFinalizationEvent;
+        batchFinalized?: BatchFinalizedEvent;
+        treeSigningStarted?: TreeSigningStartedEvent;
+        treeNoncesAggregated?: TreeNoncesAggregatedEvent;
+        treeNonces?: TreeNoncesEvent;
+        treeTx?: TreeTxEvent;
+        treeSignature?: TreeSignatureEvent;
+        heartbeat?: Heartbeat;
+    }
+    export interface GetTransactionsStreamResponse {
+        commitmentTx?: {
+            txid: string;
+            tx: string;
+            spentVtxos: VtxoData[];
+            spendableVtxos: VtxoData[];
+            checkpointTxs?: Record<string, {
+                txid: string;
+                tx: string;
+            }>;
+        };
+        arkTx?: {
+            txid: string;
+            tx: string;
+            spentVtxos: VtxoData[];
+            spendableVtxos: VtxoData[];
+            checkpointTxs?: Record<string, {
+                txid: string;
+                tx: string;
+            }>;
+        };
+        heartbeat?: Heartbeat;
+    }
+    export interface EventData {
+        batchStarted?: BatchStartedEvent;
+        batchFailed?: BatchFailed;
+        batchFinalization?: BatchFinalizationEvent;
+        batchFinalized?: BatchFinalizedEvent;
+        treeSigningStarted?: TreeSigningStartedEvent;
+        treeNoncesAggregated?: TreeNoncesAggregatedEvent;
+        treeTx?: TreeTxEvent;
+        treeSignature?: TreeSignatureEvent;
+    }
+    export interface TransactionData {
+        commitmentTx?: {
+            txid: string;
+            tx: string;
+            spentVtxos: VtxoData[];
+            spendableVtxos: VtxoData[];
+            checkpointTxs?: Record<string, {
+                txid: string;
+                tx: string;
+            }>;
+        };
+        arkTx?: {
+            txid: string;
+            tx: string;
+            spentVtxos: VtxoData[];
+            spendableVtxos: VtxoData[];
+            checkpointTxs?: Record<string, {
+                txid: string;
+                tx: string;
+            }>;
+        };
+    }
+    export {};
 }
 export declare function isFetchTimeoutError(err: any): boolean;
+export {};

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

@@ -0,0 +1,13 @@
+export declare class ArkError extends Error {
+    readonly code: number;
+    readonly message: string;
+    readonly name: string;
+    readonly metadata?: Record<string, string> | undefined;
+    constructor(code: number, message: string, name: string, metadata?: Record<string, string> | undefined);
+}
+/**
+ * Try to convert an error to an ArkError class, returning undefined if the error is not an ArkError
+ * @param error - The error to parse
+ * @returns The parsed ArkError, or undefined if the error is not an ArkError
+ */
+export declare function maybeArkError(error: any): ArkError | undefined;

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

@@ -0,0 +1,22 @@
+import { RestArkProvider, SettlementEvent, TxNotification } from "./ark";
+/**
+ * Expo-compatible Ark 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.
+ *
+ * @example
+ * ```typescript
+ * import { ExpoArkProvider } from '@arkade-os/sdk/providers/expo';
+ *
+ * const provider = new ExpoArkProvider('https://ark.example.com');
+ * const info = await provider.getInfo();
+ * ```
+ */
+export declare class ExpoArkProvider extends RestArkProvider {
+    constructor(serverUrl: string);
+    getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
+    getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<{
+        commitmentTx?: TxNotification;
+        arkTx?: TxNotification;
+    }>;
+}

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

@@ -0,0 +1,18 @@
+import { RestIndexerProvider, SubscriptionResponse } from "./indexer";
+/**
+ * Expo-compatible Indexer provider implementation using expo/fetch for streaming support.
+ * This provider works specifically in React Native/Expo environments where
+ * standard fetch streaming may not work properly but expo/fetch provides streaming capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo';
+ *
+ * const provider = new ExpoIndexerProvider('https://indexer.example.com');
+ * const vtxos = await provider.getVtxos({ scripts: ['script1'] });
+ * ```
+ */
+export declare class ExpoIndexerProvider extends RestIndexerProvider {
+    constructor(serverUrl: string);
+    getSubscription(subscriptionId: string, abortSignal: AbortSignal): AsyncIterableIterator<SubscriptionResponse>;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Dynamically imports expo/fetch with fallback to standard fetch.
+ * @returns A fetch function suitable for SSE streaming
+ */
+export declare function getExpoFetch(options?: {
+    requireExpo?: boolean;
+}): Promise<typeof fetch>;
+/**
+ * Generic SSE stream processor using fetch API with ReadableStream.
+ * Handles SSE format parsing, buffer management, and abort signals.
+ *
+ * @param url - The SSE endpoint URL
+ * @param abortSignal - Signal to abort the stream
+ * @param fetchFn - Fetch function to use (defaults to standard fetch)
+ * @param headers - Additional headers to send
+ * @param parseData - Function to parse and yield data from SSE events
+ */
+export declare function sseStreamIterator<T>(url: string, abortSignal: AbortSignal, fetchFn: typeof fetch, headers: Record<string, string>, parseData: (data: any) => T | null): AsyncGenerator<T, void, unknown>;

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

@@ -80,12 +80,19 @@ export interface SubscriptionResponse {
     scripts: string[];
     newVtxos: VirtualCoin[];
     spentVtxos: VirtualCoin[];
+    sweptVtxos: VirtualCoin[];
     tx?: string;
     checkpointTxs?: Record<string, {
         txid: string;
         tx: string;
     }>;
 }
+export interface SubscriptionHeartbeat {
+    type: "heartbeat";
+}
+export interface SubscriptionEvent extends SubscriptionResponse {
+    type: "event";
+}
 export interface IndexerProvider {
     getVtxoTree(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
         vtxoTree: Tx[];
@@ -158,14 +165,7 @@ export declare class RestIndexerProvider implements IndexerProvider {
         txids: string[];
         page?: PageResponse;
     }>;
-    getSubscription(subscriptionId: string, abortSignal: AbortSignal): AsyncGenerator<{
-        txid: any;
-        scripts: any;
-        newVtxos: any;
-        spentVtxos: any;
-        tx: any;
-        checkpointTxs: any;
-    }, void, unknown>;
+    getSubscription(subscriptionId: string, abortSignal: AbortSignal): AsyncIterableIterator<SubscriptionResponse>;
     getVirtualTxs(txids: string[], opts?: PaginationOptions): Promise<{
         txs: string[];
         page?: PageResponse;

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

@@ -49,8 +49,12 @@ export interface OnchainProvider {
  */
 export declare class EsploraProvider implements OnchainProvider {
     private baseUrl;
-    private polling;
-    constructor(baseUrl: string);
+    readonly pollingInterval: number;
+    readonly forcePolling: boolean;
+    constructor(baseUrl: string, opts?: {
+        pollingInterval?: number;
+        forcePolling?: boolean;
+    });
     getCoins(address: string): Promise<Coin[]>;
     getFeeRate(): Promise<number | undefined>;
     broadcastTransaction(...txs: string[]): Promise<string>;

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

@@ -1,17 +1,19 @@
 import { StorageAdapter } from "../storage";
-import { ArkTransaction, ExtendedVirtualCoin } from "../wallet";
+import { ArkTransaction, ExtendedCoin, ExtendedVirtualCoin } from "../wallet";
 export interface WalletState {
     lastSyncTime?: number;
     settings?: Record<string, any>;
 }
 export interface WalletRepository {
     getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
-    saveVtxo(address: string, vtxo: ExtendedVirtualCoin): Promise<void>;
     saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
     removeVtxo(address: string, vtxoId: string): Promise<void>;
     clearVtxos(address: string): Promise<void>;
+    getUtxos(address: string): Promise<ExtendedCoin[]>;
+    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    removeUtxo(address: string, utxoId: string): Promise<void>;
+    clearUtxos(address: string): Promise<void>;
     getTransactionHistory(address: string): Promise<ArkTransaction[]>;
-    saveTransaction(address: string, tx: ArkTransaction): Promise<void>;
     saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
     clearTransactions(address: string): Promise<void>;
     getWalletState(): Promise<WalletState | null>;
@@ -22,12 +24,14 @@ export declare class WalletRepositoryImpl implements WalletRepository {
     private cache;
     constructor(storage: StorageAdapter);
     getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
-    saveVtxo(address: string, vtxo: ExtendedVirtualCoin): Promise<void>;
     saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
     removeVtxo(address: string, vtxoId: string): Promise<void>;
     clearVtxos(address: string): Promise<void>;
+    getUtxos(address: string): Promise<ExtendedCoin[]>;
+    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    removeUtxo(address: string, utxoId: string): Promise<void>;
+    clearUtxos(address: string): Promise<void>;
     getTransactionHistory(address: string): Promise<ArkTransaction[]>;
-    saveTransaction(address: string, tx: ArkTransaction): Promise<void>;
     saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
     clearTransactions(address: string): Promise<void>;
     getWalletState(): Promise<WalletState | null>;

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

@@ -1,4 +1,6 @@
-import { BTC_NETWORK, Bytes } from "@scure/btc-signer/utils.js";
+import { NETWORK } from "@scure/btc-signer";
+import { PSBTOutput } from "@scure/btc-signer/psbt.js";
+import { Bytes } from "@scure/btc-signer/utils.js";
 import { ArkAddress } from "./address";
 import { ConditionCSVMultisigTapscript, CSVMultisigTapscript } from "./tapscript";
 export type TapLeafScript = [
@@ -9,6 +11,7 @@ export type TapLeafScript = [
     },
     Bytes
 ];
+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.
@@ -27,7 +30,7 @@ export declare class VtxoScript {
     encode(): Bytes;
     address(prefix: string, serverPubKey: Bytes): ArkAddress;
     get pkScript(): Bytes;
-    onchainAddress(network: BTC_NETWORK): string;
+    onchainAddress(network: typeof NETWORK): string;
     findLeaf(scriptHex: string): TapLeafScript;
     exitPaths(): Array<CSVMultisigTapscript.Type | ConditionCSVMultisigTapscript.Type>;
 }

package/dist/types/tree/signingSession.d.ts

@@ -2,14 +2,17 @@ import * as musig2 from "../musig2";
 import { TxTree } from "./txTree";
 export declare const ErrMissingVtxoGraph: Error;
 export declare const ErrMissingAggregateKey: Error;
-export type TreeNonces = Map<string, Pick<musig2.Nonces, "pubNonce">>;
+export type Musig2PublicNonce = Pick<musig2.Nonces, "pubNonce">;
+export type TreeNonces = Map<string, Musig2PublicNonce>;
 export type TreePartialSigs = Map<string, musig2.PartialSig>;
 export interface SignerSession {
-    getPublicKey(): Uint8Array;
-    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): void;
-    getNonces(): TreeNonces;
-    setAggregatedNonces(nonces: TreeNonces): void;
-    sign(): TreePartialSigs;
+    getPublicKey(): Promise<Uint8Array>;
+    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): Promise<void>;
+    getNonces(): Promise<TreeNonces>;
+    aggregatedNonces(txid: string, noncesByPubkey: TreeNonces): Promise<{
+        hasAllNonces: boolean;
+    }>;
+    sign(): Promise<TreePartialSigs>;
 }
 export declare class TreeSignerSession implements SignerSession {
     private secretKey;
@@ -21,11 +24,13 @@ export declare class TreeSignerSession implements SignerSession {
     private rootSharedOutputAmount;
     constructor(secretKey: Uint8Array);
     static random(): TreeSignerSession;
-    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): void;
-    getPublicKey(): Uint8Array;
-    getNonces(): TreeNonces;
-    setAggregatedNonces(nonces: TreeNonces): void;
-    sign(): TreePartialSigs;
+    init(tree: TxTree, scriptRoot: Uint8Array, rootInputAmount: bigint): Promise<void>;
+    getPublicKey(): Promise<Uint8Array>;
+    getNonces(): Promise<TreeNonces>;
+    aggregatedNonces(txid: string, noncesByPubkey: TreeNonces): Promise<{
+        hasAllNonces: boolean;
+    }>;
+    sign(): Promise<TreePartialSigs>;
     private generateNonces;
     private signPartial;
 }

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

@@ -1,5 +1,5 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-import { TransactionInputUpdate } from "@scure/btc-signer/psbt";
+import { Transaction } from "@scure/btc-signer";
+import { TransactionInputUpdate } from "@scure/btc-signer/psbt.js";
 export declare const ANCHOR_VALUE = 0n;
 export declare const ANCHOR_PKSCRIPT: Uint8Array<ArrayBuffer>;
 /**