@arkade-os/sdk 0.3.13 → 0.4.0-next.0

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

@@ -0,0 +1,128 @@
+import { Identity, ReadonlyIdentity } from ".";
+import { Transaction } from "../utils/transaction";
+import { SignerSession } from "../tree/signingSession";
+/** Use default BIP86 derivation with network selection. */
+export interface NetworkOptions {
+    /** Mainnet (coin type 0) or testnet (coin type 1). */
+    isMainnet: boolean;
+}
+/** Use a custom output descriptor for derivation. */
+export interface DescriptorOptions {
+    /** Custom output descriptor that determines the derivation path. */
+    descriptor: string;
+}
+/** Either default BIP86 derivation (with optional network) or a custom descriptor. */
+export type SeedIdentityOptions = NetworkOptions | DescriptorOptions;
+export type MnemonicOptions = SeedIdentityOptions & {
+    /** Optional BIP39 passphrase for additional seed entropy. */
+    passphrase?: string;
+};
+/**
+ * Seed-based identity derived from a raw seed and an output descriptor.
+ *
+ * This is the recommended identity type for most applications. It uses
+ * standard BIP86 (Taproot) derivation by default and stores an output
+ * descriptor for interoperability with other wallets. The descriptor
+ * format is HD-ready, allowing future support for multiple addresses
+ * and change derivation.
+ *
+ * Prefer this (or {@link MnemonicIdentity}) over `SingleKey` for new
+ * integrations — `SingleKey` exists for backward compatibility with
+ * raw nsec-style keys.
+ *
+ * @example
+ * ```typescript
+ * const seed = mnemonicToSeedSync(mnemonic);
+ *
+ * // Testnet (BIP86 path m/86'/1'/0'/0/0)
+ * const identity = SeedIdentity.fromSeed(seed, { isMainnet: false });
+ *
+ * // Mainnet (BIP86 path m/86'/0'/0'/0/0)
+ * const identity = SeedIdentity.fromSeed(seed, { isMainnet: true });
+ *
+ * // Custom descriptor
+ * const identity = SeedIdentity.fromSeed(seed, { descriptor });
+ * ```
+ */
+export declare class SeedIdentity implements Identity {
+    protected readonly seed: Uint8Array;
+    private readonly derivedKey;
+    readonly descriptor: string;
+    constructor(seed: Uint8Array, descriptor: string);
+    /**
+     * Creates a SeedIdentity from a raw 64-byte seed.
+     *
+     * Pass `{ isMainnet }` for default BIP86 derivation, or
+     * `{ descriptor }` for a custom derivation path.
+     *
+     * @param seed - 64-byte seed (typically from mnemonicToSeedSync)
+     * @param opts - Network selection or custom descriptor.
+     */
+    static fromSeed(seed: Uint8Array, opts: SeedIdentityOptions): SeedIdentity;
+    xOnlyPublicKey(): Promise<Uint8Array>;
+    compressedPublicKey(): Promise<Uint8Array>;
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+    signMessage(message: Uint8Array, signatureType?: "schnorr" | "ecdsa"): Promise<Uint8Array>;
+    signerSession(): SignerSession;
+    /**
+     * Converts to a watch-only identity that cannot sign.
+     */
+    toReadonly(): Promise<ReadonlyDescriptorIdentity>;
+}
+/**
+ * Mnemonic-based identity derived from a BIP39 phrase.
+ *
+ * This is the most user-friendly identity type — recommended for wallet
+ * applications where users manage their own backup phrase. Extends
+ * {@link SeedIdentity} with mnemonic validation and optional passphrase
+ * support.
+ *
+ * @example
+ * ```typescript
+ * const identity = MnemonicIdentity.fromMnemonic(
+ *   'abandon abandon abandon ...',
+ *   { isMainnet: true, passphrase: 'secret' }
+ * );
+ * ```
+ */
+export declare class MnemonicIdentity extends SeedIdentity {
+    private constructor();
+    /**
+     * Creates a MnemonicIdentity from a BIP39 mnemonic phrase.
+     *
+     * Pass `{ isMainnet }` for default BIP86 derivation, or
+     * `{ descriptor }` for a custom derivation path.
+     *
+     * @param phrase - BIP39 mnemonic phrase (12 or 24 words)
+     * @param opts - Network selection or custom descriptor, plus optional passphrase
+     */
+    static fromMnemonic(phrase: string, opts: MnemonicOptions): MnemonicIdentity;
+}
+/**
+ * Watch-only identity from an output descriptor.
+ *
+ * Can derive public keys but cannot sign transactions. Use this for
+ * watch-only wallets or when sharing identity information without
+ * exposing private keys.
+ *
+ * @example
+ * ```typescript
+ * const descriptor = "tr([fingerprint/86'/0'/0']xpub.../0/0)";
+ * const readonly = ReadonlyDescriptorIdentity.fromDescriptor(descriptor);
+ * const pubKey = await readonly.xOnlyPublicKey();
+ * ```
+ */
+export declare class ReadonlyDescriptorIdentity implements ReadonlyIdentity {
+    readonly descriptor: string;
+    private readonly xOnlyPubKey;
+    private readonly compressedPubKey;
+    private constructor();
+    /**
+     * Creates a ReadonlyDescriptorIdentity from an output descriptor.
+     *
+     * @param descriptor - Taproot descriptor: tr([fingerprint/path']xpub.../child/path)
+     */
+    static fromDescriptor(descriptor: string): ReadonlyDescriptorIdentity;
+    xOnlyPublicKey(): Promise<Uint8Array>;
+    compressedPublicKey(): Promise<Uint8Array>;
+}

package/dist/types/index.d.ts

@@ -1,27 +1,29 @@
 import { Transaction } from "./utils/transaction";
 import { SingleKey, ReadonlySingleKey } from "./identity/singleKey";
+import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity } from "./identity/seedIdentity";
+import type { SeedIdentityOptions, MnemonicOptions, NetworkOptions, DescriptorOptions } from "./identity/seedIdentity";
 import { Identity, ReadonlyIdentity } from "./identity";
 import { ArkAddress } from "./script/address";
 import { VHTLC } from "./script/vhtlc";
 import { DefaultVtxo } from "./script/default";
-import { VtxoScript, EncodedVtxoScript, TapLeafScript, TapTreeCoder } from "./script/base";
-import { TxType, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, GetVtxosFilter, TapLeaves, isSpendable, isSubdust, isRecoverable, isExpired } from "./wallet";
+import { DelegateVtxo } from "./script/delegate";
+import { MessageHandler, RequestEnvelope, ResponseEnvelope, MessageBus } from "./worker/messageBus";
+import { VtxoScript, EncodedVtxoScript, TapLeafScript, TapTreeCoder, getSequence } from "./script/base";
+import { TxType, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, GetVtxosFilter, TapLeaves, StorageConfig, isSpendable, isSubdust, isRecoverable, isExpired, Asset, Recipient, IssuanceParams, IssuanceResult, ReissuanceParams, BurnParams, AssetDetails, AssetMetadata, KnownMetadata } from "./wallet";
 import { Batch } from "./wallet/batch";
-import { Wallet, ReadonlyWallet, waitForIncomingFunds, IncomingFunds, getSequence } from "./wallet/wallet";
+import { Wallet, ReadonlyWallet, waitForIncomingFunds, IncomingFunds } from "./wallet/wallet";
 import { TxTree, TxTreeNode } from "./tree/txTree";
 import { SignerSession, TreeNonces, TreePartialSigs } from "./tree/signingSession";
 import { Ramps } from "./wallet/ramps";
 import { isVtxoExpiringSoon, VtxoManager } from "./wallet/vtxo-manager";
 import { ServiceWorkerWallet, ServiceWorkerReadonlyWallet } 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 { setupServiceWorker } from "./worker/browser/utils";
 import { ESPLORA_URL, EsploraProvider, OnchainProvider, ExplorerTransaction } from "./providers/onchain";
 import { RestArkProvider, ArkProvider, SettlementEvent, SettlementEventType, ArkInfo, SignedIntent, Output, TxNotification, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, FeeInfo } from "./providers/ark";
+import { DelegatorProvider, DelegateInfo, DelegateOptions, RestDelegatorProvider } from "./providers/delegator";
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, TapscriptType, ArkTapscript, RelativeTimelock } from "./script/tapscript";
-import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, ArkTxInput, OffchainTx, combineTapscriptSigs } from "./utils/arkTransaction";
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, ArkTxInput, OffchainTx, combineTapscriptSigs, isValidArkAddress } from "./utils/arkTransaction";
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry } from "./utils/unknownFields";
 import { Intent } from "./intent";
 import { ArkNote } from "./arknote";
@@ -31,11 +33,18 @@ 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";
 import { ArkError, maybeArkError } from "./providers/errors";
 import { validateVtxoTxGraph, validateConnectorsTxGraph } from "./tree/validation";
 import { buildForfeitTx } from "./forfeit";
+import { IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, WalletRepository, ContractRepository } from "./repositories";
+import type { MigrationStatus } from "./repositories";
+import { DelegatorManagerImpl, DelegatorManager } from "./wallet/delegator";
 export * from "./arkfee";
-export { Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, OnchainWallet, Ramps, VtxoManager, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, Worker, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, Request, Response, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, ArkNote, networks, WalletRepositoryImpl, ContractRepositoryImpl, Intent, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, };
-export type { Identity, ReadonlyIdentity, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, Recipient, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, IndexerProvider, PageResponse, BatchInfo, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, FeeInfo, ArkInfo, SignedIntent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, };
+export * as asset from "./asset";
+import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract } from "./contracts";
+import type { Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams } from "./contracts";
+import { IContractManager } from "./contracts/contractManager";
+import { closeDatabase, openDatabase } from "./db/manager";
+import { WalletMessageHandler } from "./wallet/serviceWorker/wallet-message-handler";
+export { Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, MessageBus, WalletMessageHandler, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, ArkNote, networks, closeDatabase, openDatabase, IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, Intent, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };
+export type { Identity, ReadonlyIdentity, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, SeedIdentityOptions, MnemonicOptions, NetworkOptions, DescriptorOptions, IndexerProvider, PageResponse, BatchInfo, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, FeeInfo, ArkInfo, SignedIntent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Asset, Recipient, IssuanceParams, IssuanceResult, ReissuanceParams, BurnParams, AssetDetails, AssetMetadata, KnownMetadata, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, StorageConfig, Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, IContractManager, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams, MessageHandler, RequestEnvelope, ResponseEnvelope, DelegatorManager, DelegatorProvider, DelegateInfo, DelegateOptions, WalletRepository, ContractRepository, MigrationStatus, };

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

@@ -1,5 +1,6 @@
 import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt.js";
 import { Transaction } from "../utils/transaction";
+import { ExtendedCoin } from "../wallet";
 /**
  * Intent proof implementation for Bitcoin message signing.
  *
@@ -37,7 +38,7 @@ export declare namespace Intent {
      * @param outputs - Optional array of transaction outputs
      * @returns An unsigned Intent proof transaction
      */
-    function create(message: string | Message, inputs: TransactionInput[], outputs?: TransactionOutput[]): Proof;
+    function create(message: string | Message, ins: (TransactionInput | ExtendedCoin)[], outputs?: TransactionOutput[]): Proof;
     function fee(proof: Proof): number;
     type RegisterMessage = {
         type: "register";

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

@@ -15,7 +15,8 @@ export declare enum SettlementEventType {
     TreeSigningStarted = "tree_signing_started",
     TreeNonces = "tree_nonces",
     TreeTx = "tree_tx",
-    TreeSignature = "tree_signature"
+    TreeSignature = "tree_signature",
+    StreamStarted = "stream_started"
 }
 export type BatchFinalizationEvent = {
     type: SettlementEventType.BatchFinalization;
@@ -66,7 +67,11 @@ export type TreeSignatureEvent = {
     txid: string;
     signature: string;
 };
-export type SettlementEvent = BatchFinalizationEvent | BatchFinalizedEvent | BatchFailedEvent | TreeSigningStartedEvent | TreeNoncesEvent | BatchStartedEvent | TreeTxEvent | TreeSignatureEvent;
+export type StreamStartedEvent = {
+    type: SettlementEventType.StreamStarted;
+    id: string;
+};
+export type SettlementEvent = BatchFinalizationEvent | BatchFinalizedEvent | BatchFailedEvent | TreeSigningStartedEvent | TreeNoncesEvent | BatchStartedEvent | TreeTxEvent | TreeSignatureEvent | StreamStartedEvent;
 export interface ScheduledSession {
     duration: bigint;
     fees: FeeInfo;
@@ -229,6 +234,9 @@ declare namespace ProtoTypes {
         txid: string;
         signature: string;
     }
+    interface StreamStartedEvent {
+        id: string;
+    }
     interface Heartbeat {
     }
     export interface VtxoData {
@@ -259,6 +267,7 @@ declare namespace ProtoTypes {
         treeNonces?: TreeNoncesEvent;
         treeTx?: TreeTxEvent;
         treeSignature?: TreeSignatureEvent;
+        streamStarted?: StreamStartedEvent;
         heartbeat?: Heartbeat;
     }
     export interface GetTransactionsStreamResponse {

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

@@ -0,0 +1,29 @@
+import { Intent } from "../intent";
+import { SignedIntent } from "./ark";
+export interface DelegateInfo {
+    pubkey: string;
+    fee: string;
+    delegatorAddress: string;
+}
+export interface DelegateOptions {
+    rejectReplace?: boolean;
+}
+export interface DelegatorProvider {
+    delegate(intent: SignedIntent<Intent.RegisterMessage>, forfeitTxs: string[], options?: DelegateOptions): Promise<void>;
+    getDelegateInfo(): Promise<DelegateInfo>;
+}
+/**
+ * REST-based Delegator provider implementation.
+ * @example
+ * ```typescript
+ * const provider = new RestDelegatorProvider('https://delegator.example.com');
+ * const info = await provider.getDelegateInfo();
+ * await provider.delegate(intent, forfeitTxs);
+ * ```
+ */
+export declare class RestDelegatorProvider implements DelegatorProvider {
+    url: string;
+    constructor(url: string);
+    delegate(intent: SignedIntent<Intent.RegisterMessage>, forfeitTxs: string[], options?: DelegateOptions): Promise<void>;
+    getDelegateInfo(): Promise<DelegateInfo>;
+}

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

@@ -1,4 +1,4 @@
-import { Outpoint, VirtualCoin } from "../wallet";
+import { AssetDetails, Outpoint, VirtualCoin } from "../wallet";
 export type PaginationOptions = {
     pageIndex?: number;
     pageSize?: number;
@@ -16,8 +16,11 @@ export declare enum ChainTxType {
     CHECKPOINT = "INDEXER_CHAINED_TX_TYPE_CHECKPOINT"
 }
 export interface PageResponse {
+    /** Current page index **/
     current: number;
+    /** Next page index **/
     next: number;
+    /** Total pages given the page-size used in the query **/
     total: number;
 }
 export interface BatchInfo {
@@ -56,6 +59,10 @@ export interface TxHistoryRecord {
     isSettled: boolean;
     settledBy: string;
 }
+export interface VtxoAsset {
+    assetId: string;
+    amount: string;
+}
 export interface Vtxo {
     outpoint: Outpoint;
     createdAt: string;
@@ -70,6 +77,7 @@ export interface Vtxo {
     commitmentTxids: string[];
     settledBy?: string;
     arkTxid?: string;
+    assets?: VtxoAsset[];
 }
 export interface VtxoChain {
     chain: ChainTx[];
@@ -130,6 +138,7 @@ export interface IndexerProvider {
         vtxos: VirtualCoin[];
         page?: PageResponse;
     }>;
+    getAssetDetails(assetId: string): Promise<AssetDetails>;
     subscribeForScripts(scripts: string[], subscriptionId?: string): Promise<string>;
     unsubscribeForScripts(subscriptionId: string, scripts?: string[]): Promise<void>;
 }
@@ -181,6 +190,7 @@ export declare class RestIndexerProvider implements IndexerProvider {
         vtxos: VirtualCoin[];
         page?: PageResponse;
     }>;
+    getAssetDetails(assetId: string): Promise<AssetDetails>;
     subscribeForScripts(scripts: string[], subscriptionId?: string): Promise<string>;
     unsubscribeForScripts(subscriptionId: string, scripts?: string[]): Promise<void>;
 }

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

@@ -1,21 +1,32 @@
-import { StorageAdapter } from "../storage";
-export interface ContractRepository {
-    getContractData<T>(contractId: string, key: string): Promise<T | null>;
-    setContractData<T>(contractId: string, key: string, data: T): Promise<void>;
-    deleteContractData(contractId: string, key: string): Promise<void>;
-    clearContractData(): Promise<void>;
-    getContractCollection<T>(contractType: string): Promise<ReadonlyArray<T>>;
-    saveToContractCollection<T, K extends keyof T>(contractType: string, item: T, idField: K): Promise<void>;
-    removeFromContractCollection<T, K extends keyof T>(contractType: string, id: T[K], idField: K): Promise<void>;
+import { Contract, ContractState } from "../contracts/types";
+/**
+ * Filter options for querying contracts.
+ */
+export interface ContractFilter {
+    /** Filter by script(s) */
+    script?: string | string[];
+    /** Filter by state(s) */
+    state?: ContractState | ContractState[];
+    /** Filter by contract type(s) */
+    type?: string | string[];
 }
-export declare class ContractRepositoryImpl implements ContractRepository {
-    private storage;
-    constructor(storage: StorageAdapter);
-    getContractData<T>(contractId: string, key: string): Promise<T | null>;
-    setContractData<T>(contractId: string, key: string, data: T): Promise<void>;
-    deleteContractData(contractId: string, key: string): Promise<void>;
-    getContractCollection<T>(contractType: string): Promise<ReadonlyArray<T>>;
-    saveToContractCollection<T, K extends keyof T>(contractType: string, item: T, idField: K): Promise<void>;
-    removeFromContractCollection<T, K extends keyof T>(contractType: string, id: T[K], idField: K): Promise<void>;
-    clearContractData(): Promise<void>;
+export interface ContractRepository extends AsyncDisposable {
+    readonly version: 1;
+    /**
+     * Clear all data from storage.
+     */
+    clear(): Promise<void>;
+    /**
+     * Get contracts with optional filter.
+     * Returns all contracts if no filter provided.
+     */
+    getContracts(filter?: ContractFilter): Promise<Contract[]>;
+    /**
+     * Save or update a contract.
+     */
+    saveContract(contract: Contract): Promise<void>;
+    /**
+     * Delete a contract by script.
+     */
+    deleteContract(script: string): Promise<void>;
 }

package/dist/types/repositories/inMemory/contractRepository.d.ts

@@ -0,0 +1,17 @@
+import { ContractFilter, ContractRepository } from "../contractRepository";
+import { Contract } from "../../contracts";
+/**
+ * In-memory implementation of ContractRepository.
+ * Data is ephemeral and scoped to the instance.
+ */
+export declare class InMemoryContractRepository implements ContractRepository {
+    readonly version: 1;
+    private readonly contractData;
+    private readonly collections;
+    private readonly contractsByScript;
+    clear(): Promise<void>;
+    getContracts(filter?: ContractFilter): Promise<Contract[]>;
+    saveContract(contract: Contract): Promise<void>;
+    deleteContract(script: string): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

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

@@ -0,0 +1,26 @@
+import { ArkTransaction, ExtendedCoin, ExtendedVirtualCoin } from "../../wallet";
+import { WalletRepository, WalletState } from "../walletRepository";
+/**
+ * In-memory implementation of WalletRepository.
+ * Data is ephemeral and scoped to the instance.
+ */
+export declare class InMemoryWalletRepository implements WalletRepository {
+    readonly version: 1;
+    private readonly vtxosByAddress;
+    private readonly utxosByAddress;
+    private readonly txsByAddress;
+    private walletState;
+    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
+    deleteVtxos(address: string): Promise<void>;
+    getUtxos(address: string): Promise<ExtendedCoin[]>;
+    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    deleteUtxos(address: string): Promise<void>;
+    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
+    saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
+    deleteTransactions(address: string): Promise<void>;
+    getWalletState(): Promise<WalletState | null>;
+    saveWalletState(state: WalletState): Promise<void>;
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

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

@@ -1,2 +1,9 @@
 export * from "./walletRepository";
 export * from "./contractRepository";
+export * from "./inMemory/walletRepository";
+export * from "./inMemory/contractRepository";
+export * from "./indexedDB/contractRepository";
+export * from "./indexedDB/walletRepository";
+export { MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, type MigrationStatus, } from "./migrations/fromStorageAdapter";
+export { WalletRepositoryImpl } from "./migrations/walletRepositoryImpl";
+export { ContractRepositoryImpl } from "./migrations/contractRepositoryImpl";

package/dist/types/repositories/indexedDB/contractRepository.d.ts

@@ -0,0 +1,21 @@
+import { Contract } from "../../contracts";
+import { ContractFilter, ContractRepository } from "../contractRepository";
+/**
+ * IndexedDB-based implementation of ContractRepository.
+ *
+ * Data is stored as JSON strings in key/value stores.
+ */
+export declare class IndexedDBContractRepository implements ContractRepository {
+    private readonly dbName;
+    readonly version: 1;
+    private db;
+    constructor(dbName?: string);
+    clear(): Promise<void>;
+    getContracts(filter?: ContractFilter): Promise<Contract[]>;
+    saveContract(contract: Contract): Promise<void>;
+    deleteContract(script: string): Promise<void>;
+    private getContractsByIndexValues;
+    private applyContractFilter;
+    private getDB;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/types/repositories/indexedDB/db.d.ts

@@ -0,0 +1,56 @@
+import { TapLeafScript } from "../../script/base";
+import { ExtendedCoin, ExtendedVirtualCoin } from "../../wallet";
+import { DB_VERSION, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, STORE_TRANSACTIONS, STORE_UTXOS, STORE_VTXOS, STORE_WALLET_STATE } from "./schema";
+export { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, DB_VERSION, };
+export type SerializedVtxo = ReturnType<typeof serializeVtxo>;
+export type SerializedUtxo = ReturnType<typeof serializeUtxo>;
+export declare const serializeTapLeaf: ([cb, s]: TapLeafScript) => {
+    cb: string;
+    s: string;
+};
+export declare const serializeVtxo: (v: ExtendedVirtualCoin) => {
+    tapTree: string;
+    forfeitTapLeafScript: {
+        cb: string;
+        s: string;
+    };
+    intentTapLeafScript: {
+        cb: string;
+        s: string;
+    };
+    extraWitness: string[] | undefined;
+    virtualStatus: import("../../wallet").VirtualStatus;
+    spentBy?: string;
+    settledBy?: string;
+    arkTxId?: string;
+    createdAt: Date;
+    isUnrolled: boolean;
+    isSpent?: boolean;
+    assets?: import("../../wallet").Asset[];
+    value: number;
+    status: import("../../wallet").Status;
+    txid: string;
+    vout: number;
+};
+export declare const serializeUtxo: (u: ExtendedCoin) => {
+    tapTree: string;
+    forfeitTapLeafScript: {
+        cb: string;
+        s: string;
+    };
+    intentTapLeafScript: {
+        cb: string;
+        s: string;
+    };
+    extraWitness: string[] | undefined;
+    value: number;
+    status: import("../../wallet").Status;
+    txid: string;
+    vout: number;
+};
+export declare const deserializeTapLeaf: (t: {
+    cb: string;
+    s: string;
+}) => TapLeafScript;
+export declare const deserializeVtxo: (o: SerializedVtxo) => ExtendedVirtualCoin;
+export declare const deserializeUtxo: (o: SerializedUtxo) => ExtendedCoin;

package/dist/types/repositories/indexedDB/schema.d.ts

@@ -0,0 +1,8 @@
+export declare const STORE_VTXOS = "vtxos";
+export declare const STORE_UTXOS = "utxos";
+export declare const STORE_TRANSACTIONS = "transactions";
+export declare const STORE_WALLET_STATE = "walletState";
+export declare const STORE_CONTRACTS = "contracts";
+export declare const LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
+export declare const DB_VERSION = 2;
+export declare function initDatabase(db: IDBDatabase): void;

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

@@ -0,0 +1,25 @@
+import { ExtendedCoin, ExtendedVirtualCoin, ArkTransaction } from "../../wallet";
+import { WalletRepository, WalletState } from "../walletRepository";
+/**
+ * IndexedDB-based implementation of WalletRepository.
+ */
+export declare class IndexedDBWalletRepository implements WalletRepository {
+    private readonly dbName;
+    readonly version: 1;
+    private db;
+    constructor(dbName?: string);
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
+    deleteVtxos(address: string): Promise<void>;
+    getUtxos(address: string): Promise<ExtendedCoin[]>;
+    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    deleteUtxos(address: string): Promise<void>;
+    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
+    saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
+    deleteTransactions(address: string): Promise<void>;
+    getWalletState(): Promise<WalletState | null>;
+    saveWalletState(state: WalletState): Promise<void>;
+    private getDB;
+}

package/dist/types/repositories/indexedDB/websqlAdapter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * WebSQL adapter over expo-sqlite.
+ *
+ * Bridges the WebSQL API surface that indexeddbshim expects to the
+ * synchronous expo-sqlite driver.  Only the subset actually called by
+ * the shim is implemented:
+ *
+ *   openDatabase(name, version, displayName, estimatedSize) → WebSQLDatabase
+ *   db.transaction(cb, errCb?, successCb?)
+ *   tx.executeSql(sql, args?, successCb?, errorCb?)
+ *   resultSet = { insertId, rowsAffected, rows: { length, item(i) } }
+ */
+import { type SQLiteDatabase } from "expo-sqlite";
+export interface SQLResultSetRowList {
+    length: number;
+    item(index: number): any;
+}
+export interface SQLResultSet {
+    insertId: number;
+    rowsAffected: number;
+    rows: SQLResultSetRowList;
+}
+export interface SQLError {
+    code: number;
+    message: string;
+}
+type ExecuteSqlSuccessCb = (tx: WebSQLTransaction, resultSet: SQLResultSet) => void;
+type ExecuteSqlErrorCb = (tx: WebSQLTransaction, error: SQLError) => boolean | void;
+interface QueuedStatement {
+    sql: string;
+    args: any[];
+    successCb?: ExecuteSqlSuccessCb;
+    errorCb?: ExecuteSqlErrorCb;
+}
+export declare class WebSQLTransaction {
+    /** @internal */
+    _queue: QueuedStatement[];
+    executeSql(sql: string, args?: any[], successCb?: ExecuteSqlSuccessCb, errorCb?: ExecuteSqlErrorCb): void;
+}
+export declare class WebSQLDatabase {
+    /** @internal */
+    _db: SQLiteDatabase;
+    version: string;
+    constructor(db: SQLiteDatabase, version: string);
+    transaction(callback: (tx: WebSQLTransaction) => void, errorCb?: (error: SQLError) => void, successCb?: () => void): void;
+    readTransaction(callback: (tx: WebSQLTransaction) => void, errorCb?: (error: SQLError) => void, successCb?: () => void): void;
+}
+export declare function openDatabase(name: string, version: string, _displayName: string, _estimatedSize: number, _creationCallback?: (db: WebSQLDatabase) => void): WebSQLDatabase;
+export {};

package/dist/types/repositories/migrations/contractRepositoryImpl.d.ts

@@ -0,0 +1,24 @@
+import { StorageAdapter } from "../../storage";
+import { ContractFilter, ContractRepository } from "../contractRepository";
+import { Contract } from "../../contracts/types";
+export declare const getContractStorageKey: (id: string, key: string) => string;
+export declare const getCollectionStorageKey: (type: string) => string;
+/**
+ * @deprecated This is only to be used in migration from storage V1
+ */
+export declare class ContractRepositoryImpl implements ContractRepository {
+    readonly version: 1;
+    private storage;
+    constructor(storage: StorageAdapter);
+    getContractData<T>(contractId: string, key: string): Promise<T | null>;
+    setContractData<T>(contractId: string, key: string, data: T): Promise<void>;
+    deleteContractData(contractId: string, key: string): Promise<void>;
+    getContractCollection<T>(contractType: string): Promise<ReadonlyArray<T>>;
+    saveToContractCollection<T, K extends keyof T>(contractType: string, item: T, idField: K): Promise<void>;
+    removeFromContractCollection<T, K extends keyof T>(contractType: string, id: T[K], idField: K): Promise<void>;
+    getContracts(_?: ContractFilter): Promise<Contract[]>;
+    saveContract(_: Contract): Promise<void>;
+    deleteContract(_: string): Promise<void>;
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}