@arkade-os/sdk 0.1.3 → 0.2.0

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

@@ -1,17 +1,44 @@
-export declare class ArkNoteData {
-    id: bigint;
+import { TapLeafScript, VtxoScript } from "../script/base";
+import { Bytes } from "@scure/btc-signer/utils";
+import { ExtendedCoin, Status } from "../wallet";
+/**
+ * ArkNotes are special virtual coins in the Ark protocol that can be created
+ * and spent without requiring any transactions. The server mints them, and they
+ * are encoded as base58 strings with a human-readable prefix. It contains a
+ * preimage and value.
+ *
+ * @example
+ * ```typescript
+ * // Create an ArkNote
+ * const note = new ArkNote(preimage, 50000);
+ *
+ * // Encode to string
+ * const noteString = note.toString();
+ *
+ * // Decode from string
+ * const decodedNote = ArkNote.fromString(noteString);
+ * ```
+ */
+export declare class ArkNote implements ExtendedCoin {
+    preimage: Uint8Array;
     value: number;
-    constructor(id: bigint, value: number);
+    HRP: string;
+    static readonly DefaultHRP = "arknote";
+    static readonly PreimageLength = 32;
+    static readonly ValueLength = 4;
+    static readonly Length: number;
+    static readonly FakeOutpointIndex = 0;
+    readonly vtxoScript: VtxoScript;
+    readonly txid: string;
+    readonly vout = 0;
+    readonly forfeitTapLeafScript: TapLeafScript;
+    readonly intentTapLeafScript: TapLeafScript;
+    readonly tapTree: Bytes;
+    readonly status: Status;
+    readonly extraWitness?: Bytes[] | undefined;
+    constructor(preimage: Uint8Array, value: number, HRP?: string);
     encode(): Uint8Array;
-    static decode(data: Uint8Array): ArkNoteData;
-}
-export declare class ArkNote {
-    data: ArkNoteData;
-    signature: Uint8Array;
-    static readonly HRP = "arknote";
-    constructor(data: ArkNoteData, signature: Uint8Array);
-    encode(): Uint8Array;
-    static decode(data: Uint8Array): ArkNote;
-    static fromString(noteStr: string): ArkNote;
+    static decode(data: Uint8Array, hrp?: string): ArkNote;
+    static fromString(noteStr: string, hrp?: string): ArkNote;
     toString(): string;
 }

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

@@ -0,0 +1,6 @@
+export declare class BIP322Error extends Error {
+    constructor(message: string);
+}
+export declare const ErrMissingInputs: BIP322Error;
+export declare const ErrMissingData: BIP322Error;
+export declare const ErrMissingWitnessUtxo: BIP322Error;

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

@@ -0,0 +1,57 @@
+import { Transaction } from "@scure/btc-signer";
+import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt";
+/**
+ * BIP-322 signature implementation for Bitcoin message signing.
+ *
+ * BIP-322 defines a standard for signing Bitcoin messages as well as proving
+ * ownership of coins. This namespace provides utilities for creating and
+ * validating BIP-322.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ *
+ * @example
+ * ```typescript
+ * // Create a BIP-322 proof
+ * const proof = BIP322.create(
+ *   "Hello Bitcoin!",
+ *   [input],
+ *   [output]
+ * );
+ *
+ * // Sign the proof
+ * const signedProof = await identity.sign(proof);
+ *
+ * // Extract the signature
+ * const signature = BIP322.signature(signedProof);
+ * ```
+ */
+export declare namespace BIP322 {
+    type FullProof = Transaction;
+    type Signature = string;
+    /**
+     * Creates a new BIP-322 "full" proof of funds 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 BIP-322 message to be signed
+     * @param inputs - Array of transaction inputs to prove ownership of
+     * @param outputs - Optional array of transaction outputs
+     * @returns An unsigned BIP-322 proof transaction
+     */
+    function create(message: string, inputs: TransactionInput[], outputs?: TransactionOutput[]): FullProof;
+    /**
+     * Finalizes and extracts the FullProof transaction into a BIP-322 signature.
+     *
+     * This function takes a signed proof transaction and converts it into a
+     * base64-encoded signature string. If the proof's inputs have special
+     * spending conditions, a custom finalizer can be provided.
+     *
+     * @param signedProof - The signed BIP-322 proof transaction
+     * @param finalizer - Optional custom finalizer function
+     * @returns Base64-encoded BIP-322 signature
+     */
+    function signature(signedProof: FullProof, finalizer?: (tx: FullProof) => void): Signature;
+}
+export declare function craftToSpendTx(message: string, pkScript: Uint8Array): Transaction;

package/dist/types/forfeit.d.ts

@@ -1,15 +1,3 @@
 import { Transaction } from "@scure/btc-signer";
-import { Outpoint } from "./wallet";
-interface ForfeitTxParams {
-    connectorInput: Outpoint;
-    vtxoInput: Outpoint;
-    vtxoAmount: bigint;
-    connectorAmount: bigint;
-    feeAmount: bigint;
-    vtxoPkScript: Uint8Array;
-    connectorPkScript: Uint8Array;
-    serverPkScript: Uint8Array;
-    txLocktime?: number;
-}
-export declare function buildForfeitTx({ connectorInput, vtxoInput, vtxoAmount, connectorAmount, feeAmount, vtxoPkScript, connectorPkScript, serverPkScript, txLocktime, }: ForfeitTxParams): Transaction;
-export {};
+import { TransactionInputUpdate } from "@scure/btc-signer/psbt";
+export declare function buildForfeitTx(inputs: TransactionInputUpdate[], forfeitPkScript: Uint8Array, txLocktime?: number): Transaction;

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

@@ -0,0 +1,27 @@
+import { Transaction } from "@scure/btc-signer";
+import { Identity } from ".";
+import { SignerSession } from "../tree/signingSession";
+/**
+ * In-memory single key implementation for Bitcoin transaction signing.
+ *
+ * @example
+ * ```typescript
+ * // Create from hex string
+ * const key = SingleKey.fromHex('your_private_key_hex');
+ *
+ * // Create from raw bytes
+ * const key = SingleKey.fromPrivateKey(privateKeyBytes);
+ *
+ * // Sign a transaction
+ * const signedTx = await key.sign(transaction);
+ * ```
+ */
+export declare class SingleKey implements Identity {
+    private key;
+    private constructor();
+    static fromPrivateKey(privateKey: Uint8Array): SingleKey;
+    static fromHex(privateKeyHex: string): SingleKey;
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+    xOnlyPublicKey(): Uint8Array;
+    signerSession(): SignerSession;
+}

package/dist/types/index.d.ts

@@ -1,23 +1,34 @@
-import { InMemoryKey } from "./identity/inMemoryKey";
+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 } from "./script/base";
-import { TxType, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, VtxoTaprootAddress, AddressInfo, TapscriptInfo, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, Addresses } from "./wallet/index";
-import { Wallet } from "./wallet/wallet";
+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 { 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 { ServiceWorkerWallet } from "./wallet/serviceWorker/wallet";
+import { OnchainWallet } from "./wallet/onchain";
 import { setupServiceWorker } from "./wallet/serviceWorker/utils";
 import { Worker } from "./wallet/serviceWorker/worker";
 import { Request } from "./wallet/serviceWorker/request";
 import { Response } from "./wallet/serviceWorker/response";
-import { ESPLORA_URL, EsploraProvider } from "./providers/onchain";
-import { RestArkProvider } from "./providers/ark";
-import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType } from "./script/tapscript";
-import { addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx } from "./utils/psbt";
-import { ArkNote, ArkNoteData } from "./arknote";
+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 { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType, ArkTapscript, RelativeTimelock } from "./script/tapscript";
+import { buildOffchainTx, ArkTxInput, OffchainTx } from "./utils/arkTransaction";
+import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry } from "./utils/unknownFields";
+import { BIP322 } from "./bip322";
+import { ArkNote } from "./arknote";
 import { IndexedDBVtxoRepository } from "./wallet/serviceWorker/db/vtxo/idb";
 import { VtxoRepository } from "./wallet/serviceWorker/db/vtxo";
-import { networks } from "./networks";
-export { Wallet, InMemoryKey, ESPLORA_URL, EsploraProvider, RestArkProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, setupServiceWorker, Worker, ServiceWorkerWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, addConditionWitness, CONDITION_WITNESS_KEY_PREFIX, createVirtualTx, ArkNote, ArkNoteData, networks, IndexedDBVtxoRepository, };
-export type { Identity, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, VtxoTaprootAddress, AddressInfo, Addresses, TapscriptInfo, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, VtxoRepository, };
+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 { Nonces } from "./musig2/nonces";
+import { PartialSig } from "./musig2/sign";
+import { AnchorBumper, P2A } from "./utils/anchor";
+import { Unroll } from "./wallet/unroll";
+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, IndexedDBVtxoRepository, BIP322, TxTree, P2A, Unroll, };
+export type { Identity, IWallet, WalletConfig, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, VtxoRepository, 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, };

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

@@ -1,136 +1,155 @@
-import { TxTree } from "../tree/vtxoTree";
-import { Outpoint, VirtualCoin } from "../wallet";
+import { TxTreeNode } from "../tree/txTree";
 import { TreeNonces, TreePartialSigs } from "../tree/signingSession";
-export interface ArkEvent {
-    type: "vtxo_created" | "vtxo_spent" | "vtxo_swept" | "vtxo_expired";
-    data: {
-        txid?: string;
-        address?: string;
-        amount?: number;
-        roundTxid?: string;
-        expireAt?: number;
-    };
-}
-export type NoteInput = string;
-export type VtxoInput = {
-    outpoint: Outpoint;
-    tapscripts: string[];
-};
-export type Input = NoteInput | VtxoInput;
+import { Vtxo } from "./indexer";
 export type Output = {
     address: string;
     amount: bigint;
 };
 export declare enum SettlementEventType {
-    Finalization = "finalization",
-    Finalized = "finalized",
-    Failed = "failed",
-    SigningStart = "signing_start",
-    SigningNoncesGenerated = "signing_nonces_generated"
+    BatchStarted = "batch_started",
+    BatchFinalization = "batch_finalization",
+    BatchFinalized = "batch_finalized",
+    BatchFailed = "batch_failed",
+    TreeSigningStarted = "tree_signing_started",
+    TreeNoncesAggregated = "tree_nonces_aggregated",
+    TreeTx = "tree_tx",
+    TreeSignature = "tree_signature"
 }
-export type FinalizationEvent = {
-    type: SettlementEventType.Finalization;
+export type BatchFinalizationEvent = {
+    type: SettlementEventType.BatchFinalization;
     id: string;
-    roundTx: string;
-    vtxoTree: TxTree;
-    connectors: TxTree;
-    minRelayFeeRate: bigint;
-    connectorsIndex: Map<string, Outpoint>;
+    commitmentTx: string;
 };
-export type FinalizedEvent = {
-    type: SettlementEventType.Finalized;
+export type BatchFinalizedEvent = {
+    type: SettlementEventType.BatchFinalized;
     id: string;
-    roundTxid: string;
+    commitmentTxid: string;
 };
-export type FailedEvent = {
-    type: SettlementEventType.Failed;
+export type BatchFailedEvent = {
+    type: SettlementEventType.BatchFailed;
     id: string;
     reason: string;
 };
-export type SigningStartEvent = {
-    type: SettlementEventType.SigningStart;
+export type TreeSigningStartedEvent = {
+    type: SettlementEventType.TreeSigningStarted;
     id: string;
     cosignersPublicKeys: string[];
-    unsignedVtxoTree: TxTree;
-    unsignedSettlementTx: string;
+    unsignedCommitmentTx: string;
 };
-export type SigningNoncesGeneratedEvent = {
-    type: SettlementEventType.SigningNoncesGenerated;
+export type TreeNoncesAggregatedEvent = {
+    type: SettlementEventType.TreeNoncesAggregated;
     id: string;
     treeNonces: TreeNonces;
 };
-export type SettlementEvent = FinalizationEvent | FinalizedEvent | FailedEvent | SigningStartEvent | SigningNoncesGeneratedEvent;
-export interface ArkInfo {
-    pubkey: string;
+export type BatchStartedEvent = {
+    type: SettlementEventType.BatchStarted;
+    id: string;
+    intentIdHashes: string[];
     batchExpiry: bigint;
+};
+export type TreeTxEvent = {
+    type: SettlementEventType.TreeTx;
+    id: string;
+    topic: string[];
+    batchIndex: number;
+    chunk: TxTreeNode;
+};
+export type TreeSignatureEvent = {
+    type: SettlementEventType.TreeSignature;
+    id: string;
+    topic: string[];
+    batchIndex: number;
+    txid: string;
+    signature: string;
+};
+export type SettlementEvent = BatchFinalizationEvent | BatchFinalizedEvent | BatchFailedEvent | TreeSigningStartedEvent | TreeNoncesAggregatedEvent | BatchStartedEvent | TreeTxEvent | TreeSignatureEvent;
+export interface MarketHour {
+    nextStartTime: bigint;
+    nextEndTime: bigint;
+    period: bigint;
+    roundInterval: bigint;
+}
+export interface ArkInfo {
+    signerPubkey: string;
+    vtxoTreeExpiry: bigint;
     unilateralExitDelay: bigint;
     roundInterval: bigint;
     network: string;
     dust: bigint;
-    boardingDescriptorTemplate: string;
-    vtxoDescriptorTemplates: string[];
     forfeitAddress: string;
-    marketHour?: {
-        start: number;
-        end: number;
-    };
+    marketHour?: MarketHour;
+    version: string;
+    utxoMinAmount: bigint;
+    utxoMaxAmount: bigint;
+    vtxoMinAmount: bigint;
+    vtxoMaxAmount: bigint;
+    boardingExitDelay: bigint;
 }
-export interface Round {
-    id: string;
-    start: Date;
-    end: Date;
-    vtxoTree: TxTree;
-    forfeitTxs: string[];
-    connectors: TxTree;
+export interface Intent {
+    signature: string;
+    message: string;
+}
+export interface TxNotification {
+    txid: string;
+    tx: string;
+    spentVtxos: Vtxo[];
+    spendableVtxos: Vtxo[];
+    checkpointTxs?: Record<string, {
+        txid: string;
+        tx: string;
+    }>;
 }
 export interface ArkProvider {
     getInfo(): Promise<ArkInfo>;
-    getRound(txid: string): Promise<Round>;
-    getVirtualCoins(address: string): Promise<{
-        spendableVtxos: VirtualCoin[];
-        spentVtxos: VirtualCoin[];
+    submitTx(signedArkTx: string, checkpointTxs: string[]): Promise<{
+        arkTxid: string;
+        finalArkTx: string;
+        signedCheckpointTxs: string[];
     }>;
-    submitVirtualTx(psbtBase64: string): Promise<string>;
-    subscribeToEvents(callback: (event: ArkEvent) => void): Promise<() => void>;
-    registerInputsForNextRound(inputs: Input[]): Promise<{
-        requestId: string;
-    }>;
-    registerOutputsForNextRound(requestId: string, outputs: Output[], vtxoTreeSigningPublicKeys: string[], signAll?: boolean): Promise<void>;
-    submitTreeNonces(settlementID: string, pubkey: string, nonces: TreeNonces): Promise<void>;
-    submitTreeSignatures(settlementID: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
-    submitSignedForfeitTxs(signedForfeitTxs: string[], signedRoundTx?: string): Promise<void>;
-    ping(paymentID: string): Promise<void>;
-    getEventStream(signal: AbortSignal): AsyncIterableIterator<SettlementEvent>;
-    subscribeForAddress(address: string, abortSignal: AbortSignal): AsyncIterableIterator<{
-        newVtxos: VirtualCoin[];
-        spentVtxos: VirtualCoin[];
+    finalizeTx(arkTxid: string, finalCheckpointTxs: string[]): Promise<void>;
+    registerIntent(intent: Intent): Promise<string>;
+    deleteIntent(intent: Intent): 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>;
+    submitSignedForfeitTxs(signedForfeitTxs: string[], signedCommitmentTx?: string): Promise<void>;
+    getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
+    getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<{
+        commitmentTx?: TxNotification;
+        arkTx?: TxNotification;
     }>;
 }
+/**
+ * REST-based Ark 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 info = await provider.getInfo();
+ * ```
+ */
 export declare class RestArkProvider implements ArkProvider {
     serverUrl: string;
     constructor(serverUrl: string);
     getInfo(): Promise<ArkInfo>;
-    getVirtualCoins(address: string): Promise<{
-        spendableVtxos: VirtualCoin[];
-        spentVtxos: VirtualCoin[];
-    }>;
-    getRound(txid: string): Promise<Round>;
-    submitVirtualTx(psbtBase64: string): Promise<string>;
-    subscribeToEvents(callback: (event: ArkEvent) => void): Promise<() => void>;
-    registerInputsForNextRound(inputs: Input[]): Promise<{
-        requestId: string;
+    submitTx(signedArkTx: string, checkpointTxs: string[]): Promise<{
+        arkTxid: string;
+        finalArkTx: string;
+        signedCheckpointTxs: string[];
     }>;
-    registerOutputsForNextRound(requestId: string, outputs: Output[], cosignersPublicKeys: string[], signingAll?: boolean): Promise<void>;
-    submitTreeNonces(settlementID: string, pubkey: string, nonces: TreeNonces): Promise<void>;
-    submitTreeSignatures(settlementID: string, pubkey: string, signatures: TreePartialSigs): Promise<void>;
-    submitSignedForfeitTxs(signedForfeitTxs: string[], signedRoundTx?: string): Promise<void>;
-    ping(requestId: string): Promise<void>;
-    getEventStream(signal: AbortSignal): AsyncIterableIterator<SettlementEvent>;
-    subscribeForAddress(address: string, abortSignal: AbortSignal): AsyncIterableIterator<{
-        newVtxos: VirtualCoin[];
-        spentVtxos: VirtualCoin[];
+    finalizeTx(arkTxid: string, finalCheckpointTxs: string[]): Promise<void>;
+    registerIntent(intent: Intent): Promise<string>;
+    deleteIntent(intent: Intent): 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>;
+    submitSignedForfeitTxs(signedForfeitTxs: string[], signedCommitmentTx?: string): Promise<void>;
+    getEventStream(signal: AbortSignal, topics: string[]): AsyncIterableIterator<SettlementEvent>;
+    getTransactionsStream(signal: AbortSignal): AsyncIterableIterator<{
+        commitmentTx?: TxNotification;
+        arkTx?: TxNotification;
     }>;
-    private toConnectorsIndex;
-    private toTxTree;
     private parseSettlementEvent;
+    private parseTransactionNotification;
 }
+export declare function isFetchTimeoutError(err: any): boolean;

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

@@ -0,0 +1,186 @@
+import { Outpoint, VirtualCoin } from "../wallet";
+export type PaginationOptions = {
+    pageIndex?: number;
+    pageSize?: number;
+};
+export declare enum IndexerTxType {
+    INDEXER_TX_TYPE_UNSPECIFIED = 0,
+    INDEXER_TX_TYPE_RECEIVED = 1,
+    INDEXER_TX_TYPE_SENT = 2
+}
+export declare enum ChainTxType {
+    UNSPECIFIED = "INDEXER_CHAINED_TX_TYPE_UNSPECIFIED",
+    COMMITMENT = "INDEXER_CHAINED_TX_TYPE_COMMITMENT",
+    ARK = "INDEXER_CHAINED_TX_TYPE_ARK",
+    TREE = "INDEXER_CHAINED_TX_TYPE_TREE",
+    CHECKPOINT = "INDEXER_CHAINED_TX_TYPE_CHECKPOINT"
+}
+export interface PageResponse {
+    current: number;
+    next: number;
+    total: number;
+}
+export interface Batch {
+    totalOutputAmount: string;
+    totalOutputVtxos: number;
+    expiresAt: string;
+    swept: boolean;
+}
+export interface ChainTx {
+    txid: string;
+    expiresAt: string;
+    type: ChainTxType;
+    spends: string[];
+}
+export interface CommitmentTx {
+    startedAt: string;
+    endedAt: string;
+    batches: {
+        [key: string]: Batch;
+    };
+    totalInputAmount: string;
+    totalInputVtxos: number;
+    totalOutputAmount: string;
+    totalOutputVtxos: number;
+}
+export interface Tx {
+    txid: string;
+    children: Record<number, string>;
+}
+export interface TxHistoryRecord {
+    commitmentTxid?: string;
+    virtualTxid?: string;
+    type: IndexerTxType;
+    amount: string;
+    createdAt: string;
+    isSettled: boolean;
+    settledBy: string;
+}
+export interface Vtxo {
+    outpoint: Outpoint;
+    createdAt: string;
+    expiresAt: string | null;
+    amount: string;
+    script: string;
+    isPreconfirmed: boolean;
+    isSwept: boolean;
+    isUnrolled: boolean;
+    isSpent: boolean;
+    spentBy: string | null;
+    commitmentTxids: string[];
+    settledBy?: string;
+    arkTxid?: string;
+}
+export interface VtxoChain {
+    chain: ChainTx[];
+    page?: PageResponse;
+}
+export interface SubscriptionResponse {
+    txid?: string;
+    scripts: string[];
+    newVtxos: VirtualCoin[];
+    spentVtxos: VirtualCoin[];
+    tx?: string;
+    checkpointTxs?: Record<string, {
+        txid: string;
+        tx: string;
+    }>;
+}
+export interface IndexerProvider {
+    getVtxoTree(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
+        vtxoTree: Tx[];
+        page?: PageResponse;
+    }>;
+    getVtxoTreeLeaves(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
+        leaves: Outpoint[];
+        page?: PageResponse;
+    }>;
+    getBatchSweepTransactions(batchOutpoint: Outpoint): Promise<{
+        sweptBy: string[];
+    }>;
+    getCommitmentTx(txid: string): Promise<CommitmentTx>;
+    getCommitmentTxConnectors(txid: string, opts?: PaginationOptions): Promise<{
+        connectors: Tx[];
+        page?: PageResponse;
+    }>;
+    getCommitmentTxForfeitTxs(txid: string, opts?: PaginationOptions): Promise<{
+        txids: string[];
+        page?: PageResponse;
+    }>;
+    getSubscription(subscriptionId: string, abortSignal: AbortSignal): AsyncIterableIterator<SubscriptionResponse>;
+    getVirtualTxs(txids: string[], opts?: PaginationOptions): Promise<{
+        txs: string[];
+        page?: PageResponse;
+    }>;
+    getVtxoChain(vtxoOutpoint: Outpoint, opts?: PaginationOptions): Promise<VtxoChain>;
+    getVtxos(opts?: PaginationOptions & {
+        scripts?: string[];
+        outpoints?: Outpoint[];
+        spendableOnly?: boolean;
+        spentOnly?: boolean;
+        recoverableOnly?: boolean;
+    }): Promise<{
+        vtxos: VirtualCoin[];
+        page?: PageResponse;
+    }>;
+    subscribeForScripts(scripts: string[], subscriptionId?: string): Promise<string>;
+    unsubscribeForScripts(subscriptionId: string, scripts?: string[]): Promise<void>;
+}
+/**
+ * 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 commitmentTx = await provider.getCommitmentTx("6686af8f3be3517880821f62e6c3d749b9d6713736a1d8e229a55daa659446b2");
+ * ```
+ */
+export declare class RestIndexerProvider implements IndexerProvider {
+    serverUrl: string;
+    constructor(serverUrl: string);
+    getVtxoTree(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
+        vtxoTree: Tx[];
+        page?: PageResponse;
+    }>;
+    getVtxoTreeLeaves(batchOutpoint: Outpoint, opts?: PaginationOptions): Promise<{
+        leaves: Outpoint[];
+        page?: PageResponse;
+    }>;
+    getBatchSweepTransactions(batchOutpoint: Outpoint): Promise<{
+        sweptBy: string[];
+    }>;
+    getCommitmentTx(txid: string): Promise<CommitmentTx>;
+    getCommitmentTxConnectors(txid: string, opts?: PaginationOptions): Promise<{
+        connectors: Tx[];
+        page?: PageResponse;
+    }>;
+    getCommitmentTxForfeitTxs(txid: string, opts?: PaginationOptions): Promise<{
+        txids: string[];
+        page?: PageResponse;
+    }>;
+    getSubscription(subscriptionId: string, abortSignal: AbortSignal): AsyncGenerator<{
+        txid: any;
+        scripts: any;
+        newVtxos: any;
+        spentVtxos: any;
+        tx: any;
+        checkpointTxs: any;
+    }, void, unknown>;
+    getVirtualTxs(txids: string[], opts?: PaginationOptions): Promise<{
+        txs: string[];
+        page?: PageResponse;
+    }>;
+    getVtxoChain(vtxoOutpoint: Outpoint, opts?: PaginationOptions): Promise<VtxoChain>;
+    getVtxos(opts?: PaginationOptions & {
+        scripts?: string[];
+        outpoints?: Outpoint[];
+        spendableOnly?: boolean;
+        spentOnly?: boolean;
+        recoverableOnly?: boolean;
+    }): Promise<{
+        vtxos: VirtualCoin[];
+        page?: PageResponse;
+    }>;
+    subscribeForScripts(scripts: string[], subscriptionId?: string): Promise<string>;
+    unsubscribeForScripts(subscriptionId: string, scripts?: string[]): Promise<void>;
+}