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

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

@@ -63,31 +63,56 @@ export type TreeSignatureEvent = {
     signature: string;
 };
 export type SettlementEvent = BatchFinalizationEvent | BatchFinalizedEvent | BatchFailedEvent | TreeSigningStartedEvent | TreeNoncesAggregatedEvent | BatchStartedEvent | TreeTxEvent | TreeSignatureEvent;
-export interface MarketHour {
-    nextStartTime: bigint;
+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 +133,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 +144,7 @@ export interface ArkProvider {
         commitmentTx?: TxNotification;
         arkTx?: TxNotification;
     }>;
+    getPendingTxs(intent: SignedIntent): Promise<PendingTx[]>;
 }
 /**
  * REST-based Ark provider implementation.
@@ -139,8 +165,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 +176,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/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/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/utils.d.ts

@@ -1 +1,19 @@
 export declare function eventSourceIterator(eventSource: EventSource): AsyncGenerator<MessageEvent, void, unknown>;
+/**
+ * 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/script/base.d.ts

@@ -1,4 +1,5 @@
-import { BTC_NETWORK, Bytes } from "@scure/btc-signer/utils.js";
+import { NETWORK } from "@scure/btc-signer";
+import { Bytes } from "@scure/btc-signer/utils.js";
 import { ArkAddress } from "./address";
 import { ConditionCSVMultisigTapscript, CSVMultisigTapscript } from "./tapscript";
 export type TapLeafScript = [
@@ -27,7 +28,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

@@ -5,11 +5,11 @@ export declare const ErrMissingAggregateKey: Error;
 export type TreeNonces = Map<string, Pick<musig2.Nonces, "pubNonce">>;
 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>;
+    setAggregatedNonces(nonces: TreeNonces): Promise<void>;
+    sign(): Promise<TreePartialSigs>;
 }
 export declare class TreeSignerSession implements SignerSession {
     private secretKey;
@@ -21,11 +21,11 @@ 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>;
+    setAggregatedNonces(nonces: TreeNonces): Promise<void>;
+    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>;
 /**

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

@@ -1,9 +1,10 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-import { VirtualCoin } from "../wallet";
+import { Transaction } from "@scure/btc-signer";
+import { Bytes } from "@scure/btc-signer/utils.js";
+import { TransactionOutput } from "@scure/btc-signer/psbt.js";
+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";
-import { Bytes } from "@scure/btc-signer/utils.js";
 export type ArkTxInput = {
     tapLeafScript: TapLeafScript;
     checkpointTapLeafScript?: Bytes;
@@ -25,3 +26,14 @@ 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;
+/**
+ * Verify tapscript signatures on a transaction input
+ * @param tx Transaction to verify
+ * @param inputIndex Index of the input to verify
+ * @param requiredSigners List of required signer pubkeys (hex encoded)
+ * @param excludePubkeys List of pubkeys to exclude from verification (hex encoded, e.g., server key not yet signed)
+ * @param allowedSighashTypes List of allowed sighash types (defaults to [SigHash.DEFAULT])
+ * @throws Error if verification fails
+ */
+export declare function verifyTapscriptSignatures(tx: Transaction, inputIndex: number, requiredSigners: string[], excludePubkeys?: string[], allowedSighashTypes?: number[]): void;

package/dist/types/utils/unknownFields.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";
 /**
  * ArkPsbtFieldKey is the key values for ark psbt fields.
  */

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

@@ -1,25 +1,64 @@
-import { Output, SettlementEvent } from "../providers/ark";
+import { Bytes } from "@scure/btc-signer/utils.js";
+import { ArkProvider, Output, SettlementEvent } from "../providers/ark";
 import { Identity } from "../identity";
 import { RelativeTimelock } from "../script/tapscript";
 import { EncodedVtxoScript, TapLeafScript } from "../script/base";
-import { Bytes } from "@scure/btc-signer/utils.js";
 import { StorageAdapter } from "../storage";
+import { RenewalConfig } from "./vtxo-manager";
+import { IndexerProvider } from "../providers/indexer";
+import { OnchainProvider } from "../providers/onchain";
 /**
  * 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;
+    renewalConfig?: RenewalConfig;
+}
+/**
+ * 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 +112,7 @@ export interface VirtualCoin extends Coin {
     arkTxId?: string;
     createdAt: Date;
     isUnrolled: boolean;
+    isSpent?: boolean;
 }
 export declare enum TxType {
     TxSent = "SENT",

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

@@ -1,9 +1,9 @@
+import { Transaction } from "@scure/btc-signer";
 import { P2TR } from "@scure/btc-signer/payment.js";
 import { Coin, SendBitcoinParams } from ".";
 import { Identity } from "../identity";
 import { Network, NetworkName } from "../networks";
 import { OnchainProvider } from "../providers/onchain";
-import { Transaction } from "@scure/btc-signer/transaction.js";
 import { AnchorBumper } from "../utils/anchor";
 /**
  * Onchain Bitcoin wallet implementation for traditional Bitcoin transactions.

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

@@ -1,4 +1,4 @@
-import { ExtendedVirtualCoin, VirtualCoin, Wallet } from "../..";
+export declare const DEFAULT_DB_NAME = "arkade-service-worker";
 /**
  * setupServiceWorker sets up the service worker.
  * @param path - the path to the service worker script
@@ -8,4 +8,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/serviceWorker/wallet.d.ts

@@ -2,7 +2,6 @@ import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, ArkTransaction
 import { Response } from "./response";
 import { SettlementEvent } from "../../providers/ark";
 import { Identity } from "../../identity";
-import { StorageAdapter } from "../../storage";
 import { WalletRepository } from "../../repositories/walletRepository";
 import { ContractRepository } from "../../repositories/contractRepository";
 export type PrivateKeyIdentity = Identity & {
@@ -44,8 +43,9 @@ interface ServiceWorkerWalletOptions {
     arkServerPublicKey?: string;
     arkServerUrl: string;
     esploraUrl?: string;
+    dbName?: string;
+    dbVersion?: number;
     identity: PrivateKeyIdentity;
-    storage?: StorageAdapter;
 }
 export type ServiceWorkerWalletCreateOptions = ServiceWorkerWalletOptions & {
     serviceWorker: ServiceWorker;

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

@@ -3,6 +3,8 @@
  * it aims to be run in a service worker context
  */
 export declare class Worker {
+    readonly dbName: string;
+    readonly dbVersion: number;
     private readonly messageCallback;
     private wallet;
     private arkProvider;
@@ -10,7 +12,7 @@ export declare class Worker {
     private incomingFundsSubscription;
     private walletRepository;
     private storage;
-    constructor(messageCallback?: (message: ExtendableMessageEvent) => void);
+    constructor(dbName?: string, dbVersion?: number, messageCallback?: (message: ExtendableMessageEvent) => void);
     /**
      * Get spendable vtxos for the current wallet address
      */

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

@@ -1,4 +1,4 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
+import { Transaction } from "@scure/btc-signer";
 import { ChainTx, IndexerProvider } from "../providers/indexer";
 import { AnchorBumper } from "../utils/anchor";
 import { OnchainProvider } from "../providers/onchain";

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;