@arkade-os/sdk 0.2.3 → 0.3.0-alpha.1

package/dist/cjs/wallet/wallet.js

@@ -37,9 +37,9 @@ exports.Wallet = void 0;
 exports.waitForIncomingFunds = waitForIncomingFunds;
 const base_1 = require("@scure/base");
 const bip68 = __importStar(require("bip68"));
-const payment_1 = require("@scure/btc-signer/payment");
-const btc_signer_1 = require("@scure/btc-signer");
-const psbt_1 = require("@scure/btc-signer/psbt");
+const payment_js_1 = require("@scure/btc-signer/payment.js");
+const transaction_js_1 = require("@scure/btc-signer/transaction.js");
+const psbt_js_1 = require("@scure/btc-signer/psbt.js");
 const transactionHistory_1 = require("../utils/transactionHistory");
 const address_1 = require("../script/address");
 const default_1 = require("../script/default");
@@ -49,7 +49,7 @@ const ark_1 = require("../providers/ark");
 const forfeit_1 = require("../forfeit");
 const validation_1 = require("../tree/validation");
 const _1 = require(".");
-const utils_1 = require("@scure/btc-signer/utils");
+const utils_js_1 = require("@scure/btc-signer/utils.js");
 const base_2 = require("../script/base");
 const tapscript_1 = require("../script/tapscript");
 const arkTransaction_1 = require("../utils/arkTransaction");
@@ -57,6 +57,9 @@ const arknote_1 = require("../arknote");
 const bip322_1 = require("../bip322");
 const indexer_1 = require("../providers/indexer");
 const txTree_1 = require("../tree/txTree");
+const inMemory_1 = require("../storage/inMemory");
+const walletRepository_1 = require("../repositories/walletRepository");
+const contractRepository_1 = require("../repositories/contractRepository");
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -83,7 +86,7 @@ const txTree_1 = require("../tree/txTree");
  * ```
  */
 class Wallet {
-    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, dustAmount) {
+    constructor(identity, network, networkName, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, dustAmount, walletRepository, contractRepository) {
         this.identity = identity;
         this.network = network;
         this.networkName = networkName;
@@ -96,9 +99,11 @@ class Wallet {
         this.serverUnrollScript = serverUnrollScript;
         this.forfeitOutputScript = forfeitOutputScript;
         this.dustAmount = dustAmount;
+        this.walletRepository = walletRepository;
+        this.contractRepository = contractRepository;
     }
     static async create(config) {
-        const pubkey = config.identity.xOnlyPublicKey();
+        const pubkey = await config.identity.xOnlyPublicKey();
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
@@ -136,9 +141,13 @@ class Wallet {
         });
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
-        const forfeitAddress = (0, payment_1.Address)(network).decode(info.forfeitAddress);
-        const forfeitOutputScript = payment_1.OutScript.encode(forfeitAddress);
-        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, info.dust);
+        const forfeitAddress = (0, payment_js_1.Address)(network).decode(info.forfeitAddress);
+        const forfeitOutputScript = payment_js_1.OutScript.encode(forfeitAddress);
+        // Set up storage and repositories
+        const storage = config.storage || new inMemory_1.InMemoryStorageAdapter();
+        const walletRepository = new walletRepository_1.WalletRepositoryImpl(storage);
+        const contractRepository = new contractRepository_1.ContractRepositoryImpl(storage);
+        return new Wallet(config.identity, network, info.network, onchainProvider, arkProvider, indexerProvider, serverPubKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, info.dust, walletRepository, contractRepository);
     }
     get arkAddress() {
         return this.offchainTapscript.address(this.network.hrp, this.arkServerPublicKey);
@@ -194,16 +203,24 @@ class Wallet {
         };
     }
     async getVtxos(filter) {
+        const address = await this.getAddress();
+        // Try to get from cache first
+        const cachedVtxos = await this.walletRepository.getVtxos(address);
+        // 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();
-        return spendableVtxos.map((vtxo) => ({
+        const extendedVtxos = spendableVtxos.map((vtxo) => ({
             ...vtxo,
             forfeitTapLeafScript: forfeit,
             intentTapLeafScript: exit,
             tapTree: encodedOffchainTapscript,
         }));
+        // Update cache with fresh data
+        await this.walletRepository.saveVtxos(address, extendedVtxos);
+        return extendedVtxos;
     }
     async getVirtualCoins(filter = { withRecoverable: true, withUnrolled: false }) {
         const scripts = [base_1.hex.encode(this.offchainTapscript.pkScript)];
@@ -385,7 +402,7 @@ class Wallet {
         // TODO persist final virtual tx and checkpoints to repository
         // sign the checkpoints
         const finalCheckpoints = await Promise.all(signedCheckpointTxs.map(async (c) => {
-            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(c));
+            const tx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(c));
             const signedCheckpoint = await this.identity.sign(tx);
             return base_1.base64.encode(signedCheckpoint.toPSBT());
         }));
@@ -441,8 +458,8 @@ class Wallet {
             }
             catch {
                 // onchain
-                const addr = (0, payment_1.Address)(this.network).decode(output.address);
-                script = payment_1.OutScript.encode(addr);
+                const addr = (0, payment_js_1.Address)(this.network).decode(output.address);
+                script = payment_js_1.OutScript.encode(addr);
                 onchainOutputIndexes.push(index);
             }
             outputs.push({
@@ -680,7 +697,7 @@ class Wallet {
     }
     async handleBatchStartedEvent(event, intentId, serverPubKey, forfeitOutputScript) {
         const utf8IntentId = new TextEncoder().encode(intentId);
-        const intentIdHash = (0, utils_1.sha256)(utf8IntentId);
+        const intentIdHash = (0, utils_js_1.sha256)(utf8IntentId);
         const intentIdHashStr = base_1.hex.encode(new Uint8Array(intentIdHash));
         let skip = true;
         // check if our intent ID hash matches any in the event
@@ -703,7 +720,7 @@ class Wallet {
             },
             pubkeys: [serverPubKey],
         }).script;
-        const sweepTapTreeRoot = (0, payment_1.tapLeafHash)(sweepTapscript);
+        const sweepTapTreeRoot = (0, payment_js_1.tapLeafHash)(sweepTapscript);
         return {
             roundId: event.id,
             sweepTapTreeRoot,
@@ -714,7 +731,7 @@ class Wallet {
     // validates the vtxo tree, creates a signing session and generates the musig2 nonces
     async handleSettlementSigningEvent(event, sweepTapTreeRoot, session, vtxoGraph) {
         // validate the unsigned vtxo tree
-        const commitmentTx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
+        const commitmentTx = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(event.unsignedCommitmentTx));
         (0, validation_1.validateVtxoTxGraph)(vtxoGraph, commitmentTx, sweepTapTreeRoot);
         // TODO check if our registered outputs are in the vtxo tree
         const sharedOutput = commitmentTx.getOutput(0);
@@ -733,7 +750,7 @@ class Wallet {
         // the signed forfeits transactions to submit
         const signedForfeits = [];
         const vtxos = await this.getVirtualCoins();
-        let settlementPsbt = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(event.commitmentTx));
+        let settlementPsbt = transaction_js_1.Transaction.fromPSBT(base_1.base64.decode(event.commitmentTx));
         let hasBoardingUtxos = false;
         let connectorIndex = 0;
         const connectorsLeaves = connectorsGraph?.leaves() || [];
@@ -775,7 +792,7 @@ class Wallet {
                 throw new Error("not enough connectors received");
             }
             const connectorLeaf = connectorsLeaves[connectorIndex];
-            const connectorTxId = base_1.hex.encode((0, utils_1.sha256x2)(connectorLeaf.toBytes(true)).reverse());
+            const connectorTxId = base_1.hex.encode((0, utils_js_1.sha256x2)(connectorLeaf.toBytes(true)).reverse());
             const connectorOutput = connectorLeaf.getOutput(0);
             if (!connectorOutput) {
                 throw new Error("connector output not found");
@@ -794,7 +811,7 @@ class Wallet {
                         amount: BigInt(vtxo.value),
                         script: base_2.VtxoScript.decode(input.tapTree).pkScript,
                     },
-                    sighashType: btc_signer_1.SigHash.DEFAULT,
+                    sighashType: transaction_js_1.SigHash.DEFAULT,
                     tapLeafScript: [input.forfeitTapLeafScript],
                 },
                 {
@@ -900,7 +917,7 @@ function finalizeWithExtraWitnesses(inputExtraWitnesses) {
                     tx.updateInput(i, {
                         finalScriptWitness: [
                             script,
-                            psbt_1.TaprootControlBlock.encode(cb),
+                            psbt_js_1.TaprootControlBlock.encode(cb),
                         ],
                     });
                 }

package/dist/esm/adapters/asyncStorage.js

@@ -0,0 +1 @@
+export { AsyncStorageAdapter } from '../storage/asyncStorage.js';

package/dist/esm/adapters/fileSystem.js

@@ -0,0 +1 @@
+export { FileSystemStorageAdapter } from '../storage/fileSystem.js';

package/dist/esm/adapters/indexedDB.js

@@ -0,0 +1 @@
+export { IndexedDBStorageAdapter } from '../storage/indexedDB.js';

package/dist/esm/adapters/localStorage.js

@@ -0,0 +1 @@
+export { LocalStorageAdapter } from '../storage/localStorage.js';

package/dist/esm/arknote/index.js

@@ -1,7 +1,7 @@
 import { base58, hex } from "@scure/base";
 import { VtxoScript } from '../script/base.js';
-import { sha256 } from "@scure/btc-signer/utils";
-import { Script } from "@scure/btc-signer";
+import { sha256 } from "@scure/btc-signer/utils.js";
+import { Script } from "@scure/btc-signer/script.js";
 /**
  * ArkNotes are special virtual coins in the Ark protocol that can be created
  * and spent without requiring any transactions. The server mints them, and they

package/dist/esm/bip322/index.js

@@ -1,6 +1,8 @@
-import { OP, Transaction, Script, SigHash } from "@scure/btc-signer";
+import { OP } from "@scure/btc-signer/script.js";
+import { Transaction, SigHash } from "@scure/btc-signer/transaction.js";
+import { Script } from "@scure/btc-signer/script.js";
 import { ErrMissingData, ErrMissingInputs, ErrMissingWitnessUtxo, } from './errors.js';
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 import { base64 } from "@scure/base";
 /**
  * BIP-322 signature implementation for Bitcoin message signing.

package/dist/esm/forfeit.js

@@ -1,4 +1,4 @@
-import { Transaction } from "@scure/btc-signer";
+import { Transaction } from "@scure/btc-signer/transaction.js";
 import { P2A } from './utils/anchor.js';
 export function buildForfeitTx(inputs, forfeitPkScript, txLocktime) {
     const tx = new Transaction({

package/dist/esm/identity/index.js

@@ -1 +1 @@
-export {};
+export * from './singleKey.js';

package/dist/esm/identity/singleKey.js

@@ -1,7 +1,8 @@
-import { pubSchnorr, randomPrivateKeyBytes } from "@scure/btc-signer/utils";
+import { pubSchnorr, randomPrivateKeyBytes, sha256, } from "@scure/btc-signer/utils.js";
 import { hex } from "@scure/base";
-import { SigHash } from "@scure/btc-signer";
+import { SigHash } from "@scure/btc-signer/transaction.js";
 import { TreeSignerSession } from '../tree/signingSession.js';
+import { schnorr } from "@noble/secp256k1";
 const ZERO_32 = new Uint8Array(32).fill(0);
 const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
 /**
@@ -15,6 +16,9 @@ const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
  * // Create from raw bytes
  * const key = SingleKey.fromPrivateKey(privateKeyBytes);
  *
+ * // Create random key
+ * const randomKey = SingleKey.fromRandomBytes();
+ *
  * // Sign a transaction
  * const signedTx = await key.sign(transaction);
  * ```
@@ -29,6 +33,17 @@ export class SingleKey {
     static fromHex(privateKeyHex) {
         return new SingleKey(hex.decode(privateKeyHex));
     }
+    static fromRandomBytes() {
+        return new SingleKey(randomPrivateKeyBytes());
+    }
+    /**
+     * Export the private key as a hex string.
+     *
+     * @returns The private key as a hex string
+     */
+    toHex() {
+        return hex.encode(this.key);
+    }
     async sign(tx, inputIndexes) {
         const txCpy = tx.clone();
         if (!inputIndexes) {
@@ -56,9 +71,13 @@ export class SingleKey {
         return txCpy;
     }
     xOnlyPublicKey() {
-        return pubSchnorr(this.key);
+        return Promise.resolve(pubSchnorr(this.key));
     }
     signerSession() {
         return TreeSignerSession.random();
     }
+    async signMessage(message) {
+        const msgBytes = new TextEncoder().encode(message);
+        return schnorr.sign(sha256(msgBytes), this.key);
+    }
 }

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { Transaction } from "@scure/btc-signer";
+import { Transaction } from "@scure/btc-signer/transaction.js";
 import { SingleKey } from './identity/singleKey.js';
 import { ArkAddress } from './script/address.js';
 import { VHTLC } from './script/vhtlc.js';
@@ -21,11 +21,12 @@ import { buildOffchainTx, } from './utils/arkTransaction.js';
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
 import { BIP322 } from './bip322/index.js';
 import { ArkNote } from './arknote/index.js';
-import { IndexedDBVtxoRepository } from './wallet/serviceWorker/db/vtxo/idb.js';
 import { networks } from './networks.js';
 import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
 import { P2A } from './utils/anchor.js';
 import { Unroll } from './wallet/unroll.js';
+import { WalletRepositoryImpl } from './repositories/walletRepository.js';
+import { ContractRepositoryImpl } from './repositories/contractRepository.js';
 export { 
 // Wallets
 Wallet, SingleKey, OnchainWallet, Ramps, 
@@ -47,8 +48,8 @@ buildOffchainTx, waitForIncomingFunds,
 ArkNote, 
 // Network
 networks, 
-// Database
-IndexedDBVtxoRepository, 
+// Repositories
+WalletRepositoryImpl, ContractRepositoryImpl, 
 // BIP322
 BIP322, 
 // TxTree

package/dist/esm/musig2/keys.js

@@ -1,5 +1,5 @@
-import * as musig from "@scure/btc-signer/musig2";
-import { schnorr } from "@noble/curves/secp256k1";
+import * as musig from "@scure/btc-signer/musig2.js";
+import { schnorr } from "@noble/curves/secp256k1.js";
 // Aggregates multiple public keys according to the MuSig2 algorithm
 export function aggregateKeys(publicKeys, sort, options = {}) {
     if (sort) {
@@ -8,14 +8,14 @@ export function aggregateKeys(publicKeys, sort, options = {}) {
     const { aggPublicKey: preTweakedKey } = musig.keyAggregate(publicKeys);
     if (!options.taprootTweak) {
         return {
-            preTweakedKey: preTweakedKey.toRawBytes(true),
-            finalKey: preTweakedKey.toRawBytes(true),
+            preTweakedKey: preTweakedKey.toBytes(true),
+            finalKey: preTweakedKey.toBytes(true),
         };
     }
-    const tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.toRawBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
+    const tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.toBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
     const { aggPublicKey: finalKey } = musig.keyAggregate(publicKeys, [tweakBytes], [true]);
     return {
-        preTweakedKey: preTweakedKey.toRawBytes(true),
-        finalKey: finalKey.toRawBytes(true),
+        preTweakedKey: preTweakedKey.toBytes(true),
+        finalKey: finalKey.toBytes(true),
     };
 }

package/dist/esm/musig2/nonces.js

@@ -1,4 +1,4 @@
-import * as musig from "@scure/btc-signer/musig2";
+import * as musig from "@scure/btc-signer/musig2.js";
 /**
  * Generates a pair of public and secret nonces for MuSig2 signing
  */

package/dist/esm/musig2/sign.js

@@ -1,8 +1,8 @@
-import * as musig from "@scure/btc-signer/musig2";
-import { bytesToNumberBE } from "@noble/curves/abstract/utils";
-import { CURVE } from "@noble/secp256k1";
+import * as musig from "@scure/btc-signer/musig2.js";
+import { bytesToNumberBE } from "@noble/curves/utils.js";
+import { Point } from "@noble/secp256k1";
 import { aggregateKeys } from './keys.js';
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 // Add this error type for decode failures
 export class PartialSignatureError extends Error {
     constructor(message) {
@@ -40,7 +40,7 @@ export class PartialSig {
         }
         // Verify s is less than curve order
         const s = bytesToNumberBE(bytes);
-        if (s >= CURVE.n) {
+        if (s >= Point.CURVE().n) {
             throw new PartialSignatureError("s value overflows curve order");
         }
         // For decode we don't have R, so we'll need to compute it later

package/dist/esm/networks.js

@@ -1,4 +1,4 @@
-import { NETWORK, TEST_NETWORK } from "@scure/btc-signer";
+import { NETWORK, TEST_NETWORK } from "@scure/btc-signer/utils.js";
 export const getNetwork = (network) => {
     return networks[network];
 };

package/dist/esm/repositories/contractRepository.js

@@ -0,0 +1,126 @@
+export class ContractRepositoryImpl {
+    constructor(storage) {
+        this.cache = new Map();
+        this.storage = storage;
+    }
+    async getContractData(contractId, key) {
+        const storageKey = `contract:${contractId}:${key}`;
+        const cached = this.cache.get(storageKey);
+        if (cached !== undefined)
+            return cached;
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored)
+            return null;
+        try {
+            const data = JSON.parse(stored);
+            this.cache.set(storageKey, data);
+            return data;
+        }
+        catch (error) {
+            console.error(`Failed to parse contract data for ${contractId}:${key}:`, error);
+            return null;
+        }
+    }
+    async setContractData(contractId, key, data) {
+        const storageKey = `contract:${contractId}:${key}`;
+        try {
+            // First persist to storage, only update cache if successful
+            await this.storage.setItem(storageKey, JSON.stringify(data));
+            this.cache.set(storageKey, data);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async deleteContractData(contractId, key) {
+        const storageKey = `contract:${contractId}:${key}`;
+        try {
+            // First remove from persistent storage, only delete from cache if successful
+            await this.storage.removeItem(storageKey);
+            this.cache.delete(storageKey);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async getContractCollection(contractType) {
+        const storageKey = `collection:${contractType}`;
+        const cached = this.cache.get(storageKey);
+        if (cached !== undefined)
+            return cached;
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored) {
+            this.cache.set(storageKey, []);
+            return [];
+        }
+        try {
+            const collection = JSON.parse(stored);
+            this.cache.set(storageKey, collection);
+            return collection;
+        }
+        catch (error) {
+            console.error(`Failed to parse contract collection ${contractType}:`, error);
+            this.cache.set(storageKey, []);
+            return [];
+        }
+    }
+    async saveToContractCollection(contractType, item, idField) {
+        const collection = await this.getContractCollection(contractType);
+        // Validate that the item has the required id field
+        const itemId = item[idField];
+        if (itemId === undefined || itemId === null) {
+            throw new Error(`Item is missing required field '${String(idField)}'`);
+        }
+        // Find existing item index without mutating the original collection
+        const existingIndex = collection.findIndex((i) => i[idField] === itemId);
+        // Build new collection without mutating the cached one
+        let newCollection;
+        if (existingIndex !== -1) {
+            // Replace existing item
+            newCollection = [
+                ...collection.slice(0, existingIndex),
+                item,
+                ...collection.slice(existingIndex + 1),
+            ];
+        }
+        else {
+            // Add new item
+            newCollection = [...collection, item];
+        }
+        const storageKey = `collection:${contractType}`;
+        try {
+            // First persist to storage, only update cache if successful
+            await this.storage.setItem(storageKey, JSON.stringify(newCollection));
+            this.cache.set(storageKey, newCollection);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to persist contract collection ${contractType}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async removeFromContractCollection(contractType, id, idField) {
+        // Validate input parameters
+        if (id === undefined || id === null) {
+            throw new Error(`Invalid id provided for removal: ${String(id)}`);
+        }
+        const collection = await this.getContractCollection(contractType);
+        // Build new collection without the specified item
+        const filtered = collection.filter((item) => item[idField] !== id);
+        const storageKey = `collection:${contractType}`;
+        try {
+            // First persist to storage, only update cache if successful
+            await this.storage.setItem(storageKey, JSON.stringify(filtered));
+            this.cache.set(storageKey, filtered);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+}

package/dist/esm/repositories/index.js

@@ -0,0 +1,2 @@
+export * from './walletRepository.js';
+export * from './contractRepository.js';

package/dist/esm/repositories/walletRepository.js

@@ -0,0 +1,132 @@
+export class WalletRepositoryImpl {
+    constructor(storage) {
+        this.storage = storage;
+        this.cache = {
+            vtxos: new Map(),
+            transactions: new Map(),
+            walletState: null,
+            initialized: new Set(),
+        };
+    }
+    async getVtxos(address) {
+        const cacheKey = `vtxos:${address}`;
+        if (this.cache.vtxos.has(address)) {
+            return this.cache.vtxos.get(address);
+        }
+        const stored = await this.storage.getItem(cacheKey);
+        if (!stored) {
+            this.cache.vtxos.set(address, []);
+            return [];
+        }
+        try {
+            const vtxos = JSON.parse(stored);
+            this.cache.vtxos.set(address, vtxos);
+            return vtxos.slice();
+        }
+        catch (error) {
+            console.error(`Failed to parse VTXOs for address ${address}:`, error);
+            this.cache.vtxos.set(address, []);
+            return [];
+        }
+    }
+    async saveVtxo(address, vtxo) {
+        const vtxos = await this.getVtxos(address);
+        const existing = vtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
+        if (existing !== -1) {
+            vtxos[existing] = vtxo;
+        }
+        else {
+            vtxos.push(vtxo);
+        }
+        this.cache.vtxos.set(address, vtxos);
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(vtxos));
+    }
+    async saveVtxos(address, vtxos) {
+        const storedVtxos = await this.getVtxos(address);
+        for (const vtxo of vtxos) {
+            const existing = storedVtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
+            if (existing !== -1) {
+                storedVtxos[existing] = vtxo;
+            }
+            else {
+                storedVtxos.push(vtxo);
+            }
+        }
+        this.cache.vtxos.set(address, storedVtxos);
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(storedVtxos));
+    }
+    async removeVtxo(address, vtxoId) {
+        const vtxos = await this.getVtxos(address);
+        const [txid, vout] = vtxoId.split(":");
+        const filtered = vtxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout)));
+        this.cache.vtxos.set(address, filtered);
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(filtered));
+    }
+    async clearVtxos(address) {
+        this.cache.vtxos.set(address, []);
+        await this.storage.removeItem(`vtxos:${address}`);
+    }
+    async getTransactionHistory(address) {
+        const cacheKey = `tx:${address}`;
+        if (this.cache.transactions.has(address)) {
+            return this.cache.transactions.get(address);
+        }
+        const stored = await this.storage.getItem(cacheKey);
+        if (!stored) {
+            this.cache.transactions.set(address, []);
+            return [];
+        }
+        try {
+            const transactions = JSON.parse(stored);
+            this.cache.transactions.set(address, transactions);
+            return transactions.slice();
+        }
+        catch (error) {
+            console.error(`Failed to parse transactions for address ${address}:`, error);
+            this.cache.transactions.set(address, []);
+            return [];
+        }
+    }
+    async saveTransaction(address, tx) {
+        const transactions = await this.getTransactionHistory(address);
+        const existing = transactions.findIndex((t) => t.id === tx.id);
+        if (existing !== -1) {
+            transactions[existing] = tx;
+        }
+        else {
+            transactions.push(tx);
+            // Sort by timestamp descending
+            transactions.sort((a, b) => b.timestamp - a.timestamp);
+        }
+        this.cache.transactions.set(address, transactions);
+        await this.storage.setItem(`tx:${address}`, JSON.stringify(transactions));
+    }
+    async getWalletState() {
+        if (this.cache.walletState !== null ||
+            this.cache.initialized.has("walletState")) {
+            return this.cache.walletState;
+        }
+        const stored = await this.storage.getItem("wallet:state");
+        if (!stored) {
+            this.cache.walletState = null;
+            this.cache.initialized.add("walletState");
+            return null;
+        }
+        try {
+            const state = JSON.parse(stored);
+            this.cache.walletState = state;
+            this.cache.initialized.add("walletState");
+            return state;
+        }
+        catch (error) {
+            console.error("Failed to parse wallet state:", error);
+            this.cache.walletState = null;
+            this.cache.initialized.add("walletState");
+            return null;
+        }
+    }
+    async saveWalletState(state) {
+        this.cache.walletState = state;
+        await this.storage.setItem("wallet:state", JSON.stringify(state));
+    }
+}

package/dist/esm/script/address.js

@@ -1,5 +1,5 @@
 import { bech32m } from "@scure/base";
-import { Script } from "@scure/btc-signer";
+import { Script } from "@scure/btc-signer/script.js";
 /**
  * ArkAddress allows to create and decode bech32m encoded ark address.
  * An ark address is composed of:

package/dist/esm/script/base.js

@@ -1,7 +1,7 @@
-import { Address, p2tr, TAP_LEAF_VERSION, taprootListToTree, } from "@scure/btc-signer/payment";
-import { TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer/utils";
+import { Address, p2tr, TAP_LEAF_VERSION, taprootListToTree, } from "@scure/btc-signer/payment.js";
+import { TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer/utils.js";
 import { ArkAddress } from './address.js';
-import { Script } from "@scure/btc-signer";
+import { Script } from "@scure/btc-signer/script.js";
 import { hex } from "@scure/base";
 import { ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from './tapscript.js';
 export function scriptFromTapLeafScript(leaf) {