@arkade-os/sdk 0.3.0-alpha.6 → 0.3.0-alpha.8

package/dist/esm/wallet/wallet.js

@@ -15,7 +15,7 @@ import { isRecoverable, isSpendable, isSubdust, TxType, } from './index.js';
 import { sha256, sha256x2 } from "@scure/btc-signer/utils.js";
 import { VtxoScript } from '../script/base.js';
 import { CSVMultisigTapscript } from '../script/tapscript.js';
-import { buildOffchainTx } from '../utils/arkTransaction.js';
+import { buildOffchainTx, hasBoardingTxExpired } from '../utils/arkTransaction.js';
 import { ArkNote } from '../arknote/index.js';
 import { BIP322 } from '../bip322/index.js';
 import { RestIndexerProvider } from '../providers/indexer.js';
@@ -23,7 +23,7 @@ import { TxTree } from '../tree/txTree.js';
 import { InMemoryStorageAdapter } from '../storage/inMemory.js';
 import { WalletRepositoryImpl, } from '../repositories/walletRepository.js';
 import { ContractRepositoryImpl, } from '../repositories/contractRepository.js';
-import { extendVirtualCoin } from './serviceWorker/utils.js';
+import { extendVirtualCoin } from './utils.js';
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -31,13 +31,21 @@ import { extendVirtualCoin } from './serviceWorker/utils.js';
  *
  * @example
  * ```typescript
- * // Create a wallet
+ * // Create a wallet with URL configuration
  * const wallet = await Wallet.create({
  *   identity: SingleKey.fromHex('your_private_key'),
  *   arkServerUrl: 'https://ark.example.com',
  *   esploraUrl: 'https://mempool.space/api'
  * });
  *
+ * // Or with custom provider instances (e.g., for Expo/React Native)
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('your_private_key'),
+ *   arkProvider: new ExpoArkProvider('https://ark.example.com'),
+ *   indexerProvider: new ExpoIndexerProvider('https://ark.example.com'),
+ *   esploraUrl: 'https://mempool.space/api'
+ * });
+ *
  * // Get addresses
  * const arkAddress = await wallet.getAddress();
  * const boardingAddress = await wallet.getBoardingAddress();
@@ -71,11 +79,29 @@ export class Wallet {
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
-        const arkProvider = new RestArkProvider(config.arkServerUrl);
-        const indexerProvider = new RestIndexerProvider(config.arkServerUrl);
+        // Use provided arkProvider instance or create a new one from arkServerUrl
+        const arkProvider = config.arkProvider ||
+            (() => {
+                if (!config.arkServerUrl) {
+                    throw new Error("Either arkProvider or arkServerUrl must be provided");
+                }
+                return new RestArkProvider(config.arkServerUrl);
+            })();
+        // Extract arkServerUrl from provider if not explicitly provided
+        const arkServerUrl = config.arkServerUrl || arkProvider.serverUrl;
+        if (!arkServerUrl) {
+            throw new Error("Could not determine arkServerUrl from provider");
+        }
+        // Use provided indexerProvider instance or create a new one
+        // indexerUrl defaults to arkServerUrl if not provided
+        const indexerUrl = config.indexerUrl || arkServerUrl;
+        const indexerProvider = config.indexerProvider || new RestIndexerProvider(indexerUrl);
         const info = await arkProvider.getInfo();
         const network = getNetwork(info.network);
-        const onchainProvider = new EsploraProvider(config.esploraUrl || ESPLORA_URL[info.network]);
+        // Extract esploraUrl from provider if not explicitly provided
+        const esploraUrl = config.esploraUrl || ESPLORA_URL[info.network];
+        // Use provided onchainProvider instance or create a new one
+        const onchainProvider = config.onchainProvider || new EsploraProvider(esploraUrl);
         const exitTimelock = {
             value: info.unilateralExitDelay,
             type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
@@ -99,8 +125,14 @@ export class Wallet {
         // Save tapscripts
         const offchainTapscript = bareVtxoTapscript;
         // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
-        const rawCheckpointExitClosure = hex.decode(info.checkpointExitClosure);
-        const serverUnrollScript = CSVMultisigTapscript.decode(rawCheckpointExitClosure);
+        let serverUnrollScript;
+        try {
+            const raw = hex.decode(info.checkpointExitClosure);
+            serverUnrollScript = CSVMultisigTapscript.decode(raw);
+        }
+        catch (e) {
+            throw new Error("Invalid checkpointExitClosure from server");
+        }
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
         const forfeitAddress = Address(network).decode(info.forfeitAddress);
@@ -171,40 +203,24 @@ export class Wallet {
         // if (cachedVtxos.length) return cachedVtxos;
         // For now, always fetch fresh data from provider and update cache
         // In future, we can add cache invalidation logic based on timestamps
-        const spendableVtxos = await this.getVirtualCoins(filter);
-        const encodedOffchainTapscript = this.offchainTapscript.encode();
-        const forfeit = this.offchainTapscript.forfeit();
-        const exit = this.offchainTapscript.exit();
-        const extendedVtxos = spendableVtxos.map((vtxo) => ({
-            ...vtxo,
-            forfeitTapLeafScript: forfeit,
-            intentTapLeafScript: exit,
-            tapTree: encodedOffchainTapscript,
-        }));
+        const vtxos = await this.getVirtualCoins(filter);
+        const extendedVtxos = vtxos.map((vtxo) => extendVirtualCoin(this, vtxo));
         // Update cache with fresh data
         await this.walletRepository.saveVtxos(address, extendedVtxos);
         return extendedVtxos;
     }
     async getVirtualCoins(filter = { withRecoverable: true, withUnrolled: false }) {
         const scripts = [hex.encode(this.offchainTapscript.pkScript)];
-        const response = await this.indexerProvider.getVtxos({
-            scripts,
-            spendableOnly: true,
-        });
-        const vtxos = response.vtxos;
-        if (filter.withRecoverable) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts,
-                recoverableOnly: true,
-            });
-            vtxos.push(...response.vtxos);
+        const response = await this.indexerProvider.getVtxos({ scripts });
+        const allVtxos = response.vtxos;
+        let vtxos = allVtxos.filter(isSpendable);
+        // all recoverable vtxos are spendable by definition
+        if (!filter.withRecoverable) {
+            vtxos = vtxos.filter((vtxo) => !isRecoverable(vtxo));
         }
         if (filter.withUnrolled) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts,
-                spentOnly: true,
-            });
-            vtxos.push(...response.vtxos.filter((vtxo) => vtxo.isUnrolled));
+            const spentVtxos = allVtxos.filter((vtxo) => !isSpendable(vtxo));
+            vtxos.push(...spentVtxos.filter((vtxo) => vtxo.isUnrolled));
         }
         return vtxos;
     }
@@ -242,10 +258,10 @@ export class Wallet {
         return txs;
     }
     async getBoardingTxs() {
-        const boardingAddress = await this.getBoardingAddress();
-        const txs = await this.onchainProvider.getTransactions(boardingAddress);
         const utxos = [];
         const commitmentsToIgnore = new Set();
+        const boardingAddress = await this.getBoardingAddress();
+        const txs = await this.onchainProvider.getTransactions(boardingAddress);
         for (const tx of txs) {
             for (let i = 0; i < tx.vout.length; i++) {
                 const vout = tx.vout[i];
@@ -386,13 +402,15 @@ export class Wallet {
                 }
             }
         }
-        // if no params are provided, use all boarding and offchain utxos as inputs
+        // if no params are provided, use all non expired boarding utxos and offchain vtxos as inputs
         // and send all to the offchain address
         if (!params) {
             let amount = 0;
-            const boardingUtxos = await this.getBoardingUtxos();
+            const exitScript = CSVMultisigTapscript.decode(hex.decode(this.boardingTapscript.exitScript));
+            const boardingTimelock = exitScript.params.timelock;
+            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !hasBoardingTxExpired(utxo, boardingTimelock));
             amount += boardingUtxos.reduce((sum, input) => sum + input.value, 0);
-            const vtxos = await this.getVtxos();
+            const vtxos = await this.getVtxos({ withRecoverable: true });
             amount += vtxos.reduce((sum, input) => sum + input.value, 0);
             const inputs = [...boardingUtxos, ...vtxos];
             if (inputs.length === 0) {
@@ -602,22 +620,22 @@ export class Wallet {
         let onchainStopFunc;
         let indexerStopFunc;
         if (this.onchainProvider && boardingAddress) {
+            const findVoutOnTx = (tx) => {
+                return tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
+            };
             onchainStopFunc = await this.onchainProvider.watchAddresses([boardingAddress], (txs) => {
+                // find all utxos belonging to our boarding address
                 const coins = txs
+                    // filter txs where address is in output
+                    .filter((tx) => findVoutOnTx(tx) !== -1)
+                    // return utxo as Coin
                     .map((tx) => {
-                    const vout = tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
-                    if (vout === -1) {
-                        console.warn(`No vout found for address ${boardingAddress} in transaction ${tx.txid}`);
-                        return null;
-                    }
-                    return {
-                        txid: tx.txid,
-                        vout,
-                        value: Number(tx.vout[vout].value),
-                        status: tx.status,
-                    };
-                })
-                    .filter((coin) => coin !== null);
+                    const { txid, status } = tx;
+                    const vout = findVoutOnTx(tx);
+                    const value = Number(tx.vout[vout].value);
+                    return { txid, vout, value, status };
+                });
+                // and notify via callback
                 eventCallback({
                     type: "utxo",
                     coins,

package/dist/types/adapters/expo.d.ts

@@ -0,0 +1,4 @@
+export { ExpoArkProvider } from "../providers/expoArk";
+export { ExpoIndexerProvider } from "../providers/expoIndexer";
+export type { ArkProvider } from "../providers/ark";
+export type { IndexerProvider } from "../providers/indexer";

package/dist/types/index.d.ts

@@ -5,7 +5,7 @@ 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 { 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";
@@ -19,17 +19,17 @@ 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 { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType, ArkTapscript, RelativeTimelock } from "./script/tapscript";
-import { buildOffchainTx, ArkTxInput, OffchainTx } from "./utils/arkTransaction";
+import { hasBoardingTxExpired, 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 { 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, };
+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, hasBoardingTxExpired, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, BIP322, TxTree, P2A, Unroll, Transaction, };
+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, Intent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesAggregatedEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, MarketHour, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };

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

@@ -150,7 +150,141 @@ export declare class RestArkProvider implements ArkProvider {
         commitmentTx?: TxNotification;
         arkTx?: TxNotification;
     }>;
-    private parseSettlementEvent;
-    private parseTransactionNotification;
+    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: 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;
+        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/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,26 @@
+import { RestIndexerProvider } 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): AsyncGenerator<{
+        txid: any;
+        scripts: any;
+        newVtxos: any;
+        spentVtxos: any;
+        sweptVtxos: any;
+        tx: any;
+        checkpointTxs: any;
+    }, 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[];
@@ -163,6 +170,7 @@ export declare class RestIndexerProvider implements IndexerProvider {
         scripts: any;
         newVtxos: any;
         spentVtxos: any;
+        sweptVtxos: any;
         tx: any;
         checkpointTxs: any;
     }, void, unknown>;

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

@@ -1,5 +1,6 @@
 import { Transaction } from "@scure/btc-signer/transaction.js";
-import { VirtualCoin } from "../wallet";
+import { ExtendedCoin, VirtualCoin } from "../wallet";
+import { RelativeTimelock } from "../script/tapscript";
 import { EncodedVtxoScript, TapLeafScript } from "../script/base";
 import { CSVMultisigTapscript } from "../script/tapscript";
 import { TransactionOutput } from "@scure/btc-signer/psbt.js";
@@ -25,3 +26,4 @@ export type OffchainTx = {
  * @returns Object containing the virtual transaction and checkpoint transactions
  */
 export declare function buildOffchainTx(inputs: ArkTxInput[], outputs: TransactionOutput[], serverUnrollScript: CSVMultisigTapscript.Type): OffchainTx;
+export declare function hasBoardingTxExpired(coin: ExtendedCoin, boardingTimelock: RelativeTimelock): boolean;

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

@@ -1,4 +1,6 @@
-import { Output, SettlementEvent } from "../providers/ark";
+import { Output, SettlementEvent, ArkProvider } from "../providers/ark";
+import { IndexerProvider } from "../providers/indexer";
+import { OnchainProvider } from "../providers/onchain";
 import { Identity } from "../identity";
 import { RelativeTimelock } from "../script/tapscript";
 import { EncodedVtxoScript, TapLeafScript } from "../script/base";
@@ -7,19 +9,54 @@ import { StorageAdapter } from "../storage";
 /**
  * Configuration options for wallet initialization.
  *
- * Defines the parameters required to create and configure a wallet instance,
- * including identity, server URLs, and optional timelock settings.
- * If optional parameters are not provided, the wallet will fetch them from the
- * Ark server.
+ * Supports two configuration modes:
+ * 1. URL-based: Provide arkServerUrl, indexerUrl (optional), and esploraUrl
+ * 2. Provider-based: Provide arkProvider, indexerProvider, and onchainProvider instances
+ *
+ * At least one of the following must be provided:
+ * - arkServerUrl OR arkProvider
+ *
+ * The wallet will use provided URLs to create default providers if custom provider
+ * instances are not supplied. If optional parameters are not provided, the wallet
+ * will fetch configuration from the Ark server.
+ *
+ * @example
+ * ```typescript
+ * // URL-based configuration
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('...'),
+ *   arkServerUrl: 'https://ark.example.com',
+ *   esploraUrl: 'https://mempool.space/api'
+ * });
+ *
+ * // Provider-based configuration (e.g., for Expo/React Native)
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('...'),
+ *   arkProvider: new ExpoArkProvider('https://ark.example.com'),
+ *   indexerProvider: new ExpoIndexerProvider('https://ark.example.com'),
+ *   onchainProvider: new EsploraProvider('https://mempool.space/api')
+ * });
+ * ```
  */
 export interface WalletConfig {
     identity: Identity;
-    arkServerUrl: string;
+    arkServerUrl?: string;
+    indexerUrl?: string;
     esploraUrl?: string;
     arkServerPublicKey?: string;
     boardingTimelock?: RelativeTimelock;
     exitTimelock?: RelativeTimelock;
     storage?: StorageAdapter;
+    arkProvider?: ArkProvider;
+    indexerProvider?: IndexerProvider;
+    onchainProvider?: OnchainProvider;
+}
+/**
+ * Provider class constructor interface for dependency injection.
+ * Ensures provider classes follow the consistent constructor pattern.
+ */
+export interface ProviderClass<T> {
+    new (serverUrl: string): T;
 }
 export interface WalletBalance {
     boarding: {
@@ -73,6 +110,7 @@ export interface VirtualCoin extends Coin {
     arkTxId?: string;
     createdAt: Date;
     isUnrolled: boolean;
+    isSpent?: boolean;
 }
 export declare enum TxType {
     TxSent = "SENT",

package/dist/types/wallet/serviceWorker/utils.d.ts

@@ -1,4 +1,3 @@
-import { ExtendedVirtualCoin, VirtualCoin, Wallet } from "../..";
 /**
  * setupServiceWorker sets up the service worker.
  * @param path - the path to the service worker script
@@ -8,4 +7,3 @@ import { ExtendedVirtualCoin, VirtualCoin, Wallet } from "../..";
  * ```
  */
 export declare function setupServiceWorker(path: string): Promise<ServiceWorker>;
-export declare function extendVirtualCoin(wallet: Wallet, vtxo: VirtualCoin): ExtendedVirtualCoin;

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

@@ -0,0 +1,2 @@
+import type { ExtendedVirtualCoin, VirtualCoin, Wallet } from "..";
+export declare function extendVirtualCoin(wallet: Wallet, vtxo: VirtualCoin): ExtendedVirtualCoin;

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

@@ -25,13 +25,21 @@ export type IncomingFunds = {
  *
  * @example
  * ```typescript
- * // Create a wallet
+ * // Create a wallet with URL configuration
  * const wallet = await Wallet.create({
  *   identity: SingleKey.fromHex('your_private_key'),
  *   arkServerUrl: 'https://ark.example.com',
  *   esploraUrl: 'https://mempool.space/api'
  * });
  *
+ * // Or with custom provider instances (e.g., for Expo/React Native)
+ * const wallet = await Wallet.create({
+ *   identity: SingleKey.fromHex('your_private_key'),
+ *   arkProvider: new ExpoArkProvider('https://ark.example.com'),
+ *   indexerProvider: new ExpoIndexerProvider('https://ark.example.com'),
+ *   esploraUrl: 'https://mempool.space/api'
+ * });
+ *
  * // Get addresses
  * const arkAddress = await wallet.getAddress();
  * const boardingAddress = await wallet.getBoardingAddress();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.3.0-alpha.6",
+  "version": "0.3.0-alpha.8",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -14,6 +14,12 @@
       "require": "./dist/cjs/index.js",
       "default": "./dist/esm/index.js"
     },
+    "./adapters/expo": {
+      "types": "./dist/types/adapters/expo.d.ts",
+      "import": "./dist/esm/adapters/expo.js",
+      "require": "./dist/cjs/adapters/expo.js",
+      "default": "./dist/esm/adapters/expo.js"
+    },
     "./adapters/localStorage": {
       "types": "./dist/types/adapters/localStorage.d.ts",
       "import": "./dist/esm/adapters/localStorage.js",
@@ -58,6 +64,7 @@
     "@types/node": "24.3.1",
     "@vitest/coverage-v8": "3.2.4",
     "esbuild": "^0.25.9",
+    "expo": "~52.0.47",
     "eventsource": "4.0.0",
     "glob": "11.0.3",
     "husky": "9.1.7",
@@ -78,7 +85,7 @@
   "author": "Ark Labs",
   "license": "MIT",
   "engines": {
-    "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
     "build": "rimraf dist && pnpm run build:esm && node scripts/add-extensions.js && pnpm run build:cjs && pnpm run build:types && node scripts/generate-package-files.js",
@@ -101,6 +108,8 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:sw": "pnpm run build:browser && node test/serviceWorker/serve.js",
+    "expo:web:install": "cd examples/expo-demo && pnpm install",
+    "expo:web": "cd examples/expo-demo && pnpm start",
     "format": "prettier --write src test examples",
     "lint": "prettier --check src test examples",
     "audit": "pnpm audit",