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

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

@@ -1,12 +1,11 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-import { VirtualCoin } from "../wallet";
+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";
+import { Transaction } from "./transaction";
 export type ArkTxInput = {
     tapLeafScript: TapLeafScript;
-    checkpointTapLeafScript?: Bytes;
 } & EncodedVtxoScript & Pick<VirtualCoin, "txid" | "vout" | "value">;
 export type OffchainTx = {
     arkTx: Transaction;
@@ -25,3 +24,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/transaction.d.ts

@@ -0,0 +1,13 @@
+import { Transaction as BtcSignerTransaction } from "@scure/btc-signer";
+import { TxOpts } from "@scure/btc-signer/transaction";
+import { Bytes } from "@scure/btc-signer/utils";
+/**
+ * Transaction is a wrapper around the @scure/btc-signer Transaction class.
+ * It adds the Ark protocol specific options to the transaction.
+ */
+export declare class Transaction extends BtcSignerTransaction {
+    static ARK_TX_OPTS: TxOpts;
+    constructor(opts?: TxOpts);
+    static fromPSBT(psbt_: Bytes, opts?: TxOpts): Transaction;
+    static fromRaw(raw: Bytes, opts?: TxOpts): Transaction;
+}

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.
  */
@@ -11,9 +11,9 @@ export declare enum ArkPsbtFieldKey {
 }
 /**
  * ArkPsbtFieldKeyType is the type of the ark psbt field key.
- * Every ark psbt field has key type 255.
+ * Every ark psbt field has key type 222.
  */
-export declare const ArkPsbtFieldKeyType = 255;
+export declare const ArkPsbtFieldKeyType = 222;
 /**
  * ArkPsbtFieldCoder is the coder for the ark psbt fields.
  * each type has its own coder.

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

@@ -3,8 +3,8 @@ 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";
+import { Transaction } from "../utils/transaction";
 /**
  * Onchain Bitcoin wallet implementation for traditional Bitcoin transactions.
  *

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

@@ -1,10 +1,11 @@
-import { WalletBalance, VirtualCoin, ArkTransaction, IWallet } from "..";
+import { WalletBalance, VirtualCoin, ArkTransaction, IWallet, Coin } from "..";
+import { ExtendedVirtualCoin } from "../..";
 import { SettlementEvent } from "../../providers/ark";
 /**
  * Response is the namespace that contains the response types for the service worker.
  */
 export declare namespace Response {
-    type Type = "WALLET_INITIALIZED" | "WALLET_RELOADED" | "SETTLE_EVENT" | "SETTLE_SUCCESS" | "ADDRESS" | "BOARDING_ADDRESS" | "BALANCE" | "VTXOS" | "VIRTUAL_COINS" | "BOARDING_UTXOS" | "SEND_BITCOIN_SUCCESS" | "TRANSACTION_HISTORY" | "WALLET_STATUS" | "ERROR" | "CLEAR_RESPONSE";
+    type Type = "WALLET_INITIALIZED" | "WALLET_RELOADED" | "SETTLE_EVENT" | "SETTLE_SUCCESS" | "ADDRESS" | "BOARDING_ADDRESS" | "BALANCE" | "VTXOS" | "VIRTUAL_COINS" | "BOARDING_UTXOS" | "SEND_BITCOIN_SUCCESS" | "TRANSACTION_HISTORY" | "WALLET_STATUS" | "ERROR" | "CLEAR_RESPONSE" | "VTXO_UPDATE" | "UTXO_UPDATE";
     interface Base {
         type: Type;
         success: boolean;
@@ -106,4 +107,17 @@ export declare namespace Response {
     }
     function isWalletReloaded(response: Base): response is WalletReloaded;
     function walletReloaded(id: string, success: boolean): WalletReloaded;
+    interface VtxoUpdate extends Base {
+        type: "VTXO_UPDATE";
+        spentVtxos: ExtendedVirtualCoin[];
+        newVtxos: ExtendedVirtualCoin[];
+    }
+    function isVtxoUpdate(response: Base): response is VtxoUpdate;
+    function vtxoUpdate(newVtxos: ExtendedVirtualCoin[], spentVtxos: ExtendedVirtualCoin[]): VtxoUpdate;
+    interface UtxoUpdate extends Base {
+        type: "UTXO_UPDATE";
+        coins: Coin[];
+    }
+    function isUtxoUpdate(response: Base): response is UtxoUpdate;
+    function utxoUpdate(coins: Coin[]): UtxoUpdate;
 }

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
      */
@@ -23,6 +25,10 @@ export declare class Worker {
      * Get all vtxos categorized by type
      */
     private getAllVtxos;
+    /**
+     * Get all boarding utxos from wallet repository
+     */
+    private getAllBoardingUtxos;
     start(withServiceWorkerUpdate?: boolean): Promise<void>;
     clear(): Promise<void>;
     reload(): Promise<void>;

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

@@ -1,9 +1,9 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
 import { ChainTx, IndexerProvider } from "../providers/indexer";
 import { AnchorBumper } from "../utils/anchor";
 import { OnchainProvider } from "../providers/onchain";
 import { Outpoint } from ".";
 import { Wallet } from "./wallet";
+import { Transaction } from "../utils/transaction";
 export declare namespace Unroll {
     enum StepType {
         UNROLL = 0,

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

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

package/dist/types/wallet/vtxo-manager.d.ts

@@ -0,0 +1,179 @@
+import { ExtendedVirtualCoin, IWallet } from ".";
+import { SettlementEvent } from "../providers/ark";
+/**
+ * Configuration options for automatic VTXO renewal
+ */
+export interface RenewalConfig {
+    /**
+     * Enable automatic renewal monitoring
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Percentage of expiry time to use as threshold (0-100)
+     * E.g., 10 means renew when 10% of time until expiry remains
+     * @default 10
+     */
+    thresholdPercentage?: number;
+}
+/**
+ * Default renewal configuration values
+ */
+export declare const DEFAULT_RENEWAL_CONFIG: Required<Omit<RenewalConfig, "enabled">>;
+/**
+ * Check if a VTXO is expiring soon based on threshold
+ *
+ * @param vtxo - The virtual coin to check
+ * @param thresholdMs - Threshold in milliseconds from now
+ * @returns true if VTXO expires within threshold, false otherwise
+ */
+export declare function isVtxoExpiringSoon(vtxo: ExtendedVirtualCoin, percentage: number): boolean;
+/**
+ * Filter VTXOs that are expiring soon or are recoverable/subdust
+ *
+ * @param vtxos - Array of virtual coins to check
+ * @param thresholdMs - Threshold in milliseconds from now
+ * @param dustAmount - Dust threshold amount in satoshis
+ * @returns Array of VTXOs expiring within threshold
+ */
+export declare function getExpiringAndRecoverableVtxos(vtxos: ExtendedVirtualCoin[], percentage: number, dustAmount: bigint): ExtendedVirtualCoin[];
+/**
+ * VtxoManager is a unified class for managing VTXO lifecycle operations including
+ * recovery of swept/expired VTXOs and renewal to prevent expiration.
+ *
+ * Key Features:
+ * - **Recovery**: Reclaim swept or expired VTXOs back to the wallet
+ * - **Renewal**: Refresh VTXO expiration time before they expire
+ * - **Smart subdust handling**: Automatically includes subdust VTXOs when economically viable
+ * - **Expiry monitoring**: Check for VTXOs that are expiring soon
+ *
+ * VTXOs become recoverable when:
+ * - The Ark server sweeps them (virtualStatus.state === "swept") and they remain spendable
+ * - They are preconfirmed subdust (to consolidate small amounts without locking liquidity on settled VTXOs)
+ *
+ * @example
+ * ```typescript
+ * // Initialize with renewal config
+ * const manager = new VtxoManager(wallet, {
+ *   enabled: true,
+ *   thresholdPercentage: 10
+ * });
+ *
+ * // Check recoverable balance
+ * const balance = await manager.getRecoverableBalance();
+ * if (balance.recoverable > 0n) {
+ *   console.log(`Can recover ${balance.recoverable} sats`);
+ *   const txid = await manager.recoverVtxos();
+ * }
+ *
+ * // Check for expiring VTXOs
+ * const expiring = await manager.getExpiringVtxos();
+ * if (expiring.length > 0) {
+ *   console.log(`${expiring.length} VTXOs expiring soon`);
+ *   const txid = await manager.renewVtxos();
+ * }
+ * ```
+ */
+export declare class VtxoManager {
+    readonly wallet: IWallet;
+    readonly renewalConfig?: RenewalConfig | undefined;
+    constructor(wallet: IWallet, renewalConfig?: RenewalConfig | undefined);
+    /**
+     * Recover swept/expired VTXOs by settling them back to the wallet's Ark address.
+     *
+     * This method:
+     * 1. Fetches all VTXOs (including recoverable ones)
+     * 2. Filters for swept but still spendable VTXOs and preconfirmed subdust
+     * 3. Includes subdust VTXOs if the total value >= dust threshold
+     * 4. Settles everything back to the wallet's Ark address
+     *
+     * Note: Settled VTXOs with long expiry are NOT recovered to avoid locking liquidity unnecessarily.
+     * Only preconfirmed subdust is recovered to consolidate small amounts.
+     *
+     * @param eventCallback - Optional callback to receive settlement events
+     * @returns Settlement transaction ID
+     * @throws Error if no recoverable VTXOs found
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     *
+     * // Simple recovery
+     * const txid = await manager.recoverVtxos();
+     *
+     * // With event callback
+     * const txid = await manager.recoverVtxos((event) => {
+     *   console.log('Settlement event:', event.type);
+     * });
+     * ```
+     */
+    recoverVtxos(eventCallback?: (event: SettlementEvent) => void): Promise<string>;
+    /**
+     * Get information about recoverable balance without executing recovery.
+     *
+     * Useful for displaying to users before they decide to recover funds.
+     *
+     * @returns Object containing recoverable amounts and subdust information
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     * const balance = await manager.getRecoverableBalance();
+     *
+     * if (balance.recoverable > 0n) {
+     *   console.log(`You can recover ${balance.recoverable} sats`);
+     *   if (balance.includesSubdust) {
+     *     console.log(`This includes ${balance.subdust} sats from subdust VTXOs`);
+     *   }
+     * }
+     * ```
+     */
+    getRecoverableBalance(): Promise<{
+        recoverable: bigint;
+        subdust: bigint;
+        includesSubdust: boolean;
+        vtxoCount: number;
+    }>;
+    /**
+     * Get VTXOs that are expiring soon based on renewal configuration
+     *
+     * @param thresholdPercentage - Optional override for threshold percentage (0-100)
+     * @returns Array of expiring VTXOs, empty array if renewal is disabled or no VTXOs expiring
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet, { enabled: true, thresholdPercentage: 10 });
+     * const expiringVtxos = await manager.getExpiringVtxos();
+     * if (expiringVtxos.length > 0) {
+     *   console.log(`${expiringVtxos.length} VTXOs expiring soon`);
+     * }
+     * ```
+     */
+    getExpiringVtxos(thresholdPercentage?: number): Promise<ExtendedVirtualCoin[]>;
+    /**
+     * Renew expiring VTXOs by settling them back to the wallet's address
+     *
+     * This method collects all expiring spendable VTXOs (including recoverable ones) and settles
+     * them back to the wallet, effectively refreshing their expiration time. This is the
+     * primary way to prevent VTXOs from expiring.
+     *
+     * @param eventCallback - Optional callback for settlement events
+     * @returns Settlement transaction ID
+     * @throws Error if no VTXOs available to renew
+     * @throws Error if total amount is below dust threshold
+     *
+     * @example
+     * ```typescript
+     * const manager = new VtxoManager(wallet);
+     *
+     * // Simple renewal
+     * const txid = await manager.renewVtxos();
+     *
+     * // With event callback
+     * const txid = await manager.renewVtxos((event) => {
+     *   console.log('Settlement event:', event.type);
+     * });
+     * ```
+     */
+    renewVtxos(eventCallback?: (event: SettlementEvent) => void): Promise<string>;
+}

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

@@ -1,3 +1,4 @@
+import { Bytes } from "@scure/btc-signer/utils.js";
 import { ArkAddress } from "../script/address";
 import { DefaultVtxo } from "../script/default";
 import { Network, NetworkName } from "../networks";
@@ -5,7 +6,6 @@ import { OnchainProvider } from "../providers/onchain";
 import { SettlementEvent, ArkProvider } from "../providers/ark";
 import { Identity } from "../identity";
 import { ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter, IWallet, SendBitcoinParams, SettleParams, WalletBalance, WalletConfig } from ".";
-import { Bytes } from "@scure/btc-signer/utils.js";
 import { CSVMultisigTapscript } from "../script/tapscript";
 import { IndexerProvider } from "../providers/indexer";
 import { WalletRepository } from "../repositories/walletRepository";
@@ -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();
@@ -55,10 +63,15 @@ export declare class Wallet implements IWallet {
     readonly boardingTapscript: DefaultVtxo.Script;
     readonly serverUnrollScript: CSVMultisigTapscript.Type;
     readonly forfeitOutputScript: Bytes;
+    readonly forfeitPubkey: Bytes;
     readonly dustAmount: bigint;
     static MIN_FEE_RATE: number;
     readonly walletRepository: WalletRepository;
     readonly contractRepository: ContractRepository;
+    readonly renewalConfig: Required<Omit<WalletConfig["renewalConfig"], "enabled">> & {
+        enabled: boolean;
+        thresholdPercentage: number;
+    };
     private constructor();
     static create(config: WalletConfig): Promise<Wallet>;
     get arkAddress(): ArkAddress;
@@ -78,12 +91,11 @@ export declare class Wallet implements IWallet {
     notifyIncomingFunds(eventCallback: (coins: IncomingFunds) => void): Promise<() => void>;
     private handleBatchStartedEvent;
     private handleSettlementSigningEvent;
-    private handleSettlementSigningNoncesGeneratedEvent;
+    private handleSettlementTreeNoncesEvent;
     private handleSettlementFinalizationEvent;
     private makeRegisterIntentSignature;
     private makeDeleteIntentSignature;
-    private prepareBIP322Inputs;
-    private makeBIP322Signature;
+    private prepareIntentProofInputs;
 }
 /**
  * Wait for incoming funds to the wallet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.3.0-alpha.7",
+  "version": "0.3.0",
   "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",
@@ -48,7 +54,6 @@
   },
   "dependencies": {
     "@noble/curves": "2.0.0",
-    "@noble/hashes": "2.0.0",
     "@noble/secp256k1": "3.0.0",
     "@scure/base": "2.0.0",
     "@scure/btc-signer": "2.0.1",
@@ -58,6 +63,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 +84,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 +107,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",

package/dist/cjs/bip322/errors.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrMissingWitnessUtxo = exports.ErrMissingData = exports.ErrMissingInputs = exports.BIP322Error = void 0;
-class BIP322Error extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "BIP322Error";
-    }
-}
-exports.BIP322Error = BIP322Error;
-exports.ErrMissingInputs = new BIP322Error("missing inputs");
-exports.ErrMissingData = new BIP322Error("missing data");
-exports.ErrMissingWitnessUtxo = new BIP322Error("missing witness utxo");

package/dist/esm/bip322/errors.js

@@ -1,9 +0,0 @@
-export class BIP322Error extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "BIP322Error";
-    }
-}
-export const ErrMissingInputs = new BIP322Error("missing inputs");
-export const ErrMissingData = new BIP322Error("missing data");
-export const ErrMissingWitnessUtxo = new BIP322Error("missing witness utxo");

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

@@ -1,6 +0,0 @@
-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

@@ -1,57 +0,0 @@
-import { Transaction } from "@scure/btc-signer/transaction.js";
-import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt.js";
-/**
- * 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;