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

package/dist/cjs/script/base.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VtxoScript = void 0;
 exports.scriptFromTapLeafScript = scriptFromTapLeafScript;
+const btc_signer_1 = require("@scure/btc-signer");
 const payment_js_1 = require("@scure/btc-signer/payment.js");
+const psbt_js_1 = require("@scure/btc-signer/psbt.js");
 const utils_js_1 = require("@scure/btc-signer/utils.js");
-const address_1 = require("./address");
-const script_js_1 = require("@scure/btc-signer/script.js");
 const base_1 = require("@scure/base");
+const address_1 = require("./address");
 const tapscript_1 = require("./tapscript");
+const TapTreeCoder = psbt_js_1.PSBTOutput.tapTree[2];
 function scriptFromTapLeafScript(leaf) {
     return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte
 }
@@ -21,13 +23,14 @@ function scriptFromTapLeafScript(leaf) {
  */
 class VtxoScript {
     static decode(tapTree) {
-        const leaves = decodeTaprootTree(tapTree);
-        return new VtxoScript(leaves);
+        const leaves = TapTreeCoder.decode(tapTree);
+        const scripts = leaves.map((leaf) => leaf.script);
+        return new VtxoScript(scripts);
     }
     constructor(scripts) {
         this.scripts = scripts;
-        const tapTree = (0, payment_js_1.taprootListToTree)(scripts.map((script) => ({ script, leafVersion: payment_js_1.TAP_LEAF_VERSION })));
-        const payment = (0, payment_js_1.p2tr)(utils_js_1.TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
+        const tapTree = (0, btc_signer_1.taprootListToTree)(scripts.map((script) => ({ script, leafVersion: payment_js_1.TAP_LEAF_VERSION })));
+        const payment = (0, btc_signer_1.p2tr)(utils_js_1.TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
         if (!payment.tapLeafScript ||
             payment.tapLeafScript.length !== scripts.length) {
             throw new Error("invalid scripts");
@@ -36,17 +39,21 @@ class VtxoScript {
         this.tweakedPublicKey = payment.tweakedPubkey;
     }
     encode() {
-        const tapTree = encodeTaprootTree(this.scripts);
+        const tapTree = TapTreeCoder.encode(this.scripts.map((script) => ({
+            depth: 1,
+            version: payment_js_1.TAP_LEAF_VERSION,
+            script,
+        })));
         return tapTree;
     }
     address(prefix, serverPubKey) {
         return new address_1.ArkAddress(serverPubKey, this.tweakedPublicKey, prefix);
     }
     get pkScript() {
-        return script_js_1.Script.encode(["OP_1", this.tweakedPublicKey]);
+        return btc_signer_1.Script.encode(["OP_1", this.tweakedPublicKey]);
     }
     onchainAddress(network) {
-        return (0, payment_js_1.Address)(network).encode({
+        return (0, btc_signer_1.Address)(network).encode({
             type: "tr",
             pubkey: this.tweakedPublicKey,
         });
@@ -80,89 +87,3 @@ class VtxoScript {
     }
 }
 exports.VtxoScript = VtxoScript;
-function decodeTaprootTree(tapTree) {
-    let offset = 0;
-    const scripts = [];
-    // Read number of leaves
-    const [numLeaves, numLeavesSize] = decodeCompactSizeUint(tapTree, offset);
-    offset += numLeavesSize;
-    // Read each leaf
-    for (let i = 0; i < numLeaves; i++) {
-        // Skip depth (1 byte)
-        offset += 1;
-        // Skip leaf version (1 byte)
-        offset += 1;
-        // Read script length
-        const [scriptLength, scriptLengthSize] = decodeCompactSizeUint(tapTree, offset);
-        offset += scriptLengthSize;
-        // Read script content
-        const script = tapTree.slice(offset, offset + scriptLength);
-        scripts.push(script);
-        offset += scriptLength;
-    }
-    return scripts;
-}
-function decodeCompactSizeUint(data, offset) {
-    const firstByte = data[offset];
-    if (firstByte < 0xfd) {
-        return [firstByte, 1];
-    }
-    else if (firstByte === 0xfd) {
-        const value = new DataView(data.buffer).getUint16(offset + 1, true);
-        return [value, 3];
-    }
-    else if (firstByte === 0xfe) {
-        const value = new DataView(data.buffer).getUint32(offset + 1, true);
-        return [value, 5];
-    }
-    else {
-        const value = Number(new DataView(data.buffer).getBigUint64(offset + 1, true));
-        return [value, 9];
-    }
-}
-function encodeTaprootTree(leaves) {
-    const chunks = [];
-    // Write number of leaves as compact size uint
-    chunks.push(encodeCompactSizeUint(leaves.length));
-    for (const tapscript of leaves) {
-        // Write depth (always 1 for now)
-        chunks.push(new Uint8Array([1]));
-        // Write leaf version (0xc0 for tapscript)
-        chunks.push(new Uint8Array([0xc0]));
-        // Write script length and script
-        chunks.push(encodeCompactSizeUint(tapscript.length));
-        chunks.push(tapscript);
-    }
-    // Concatenate all chunks
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return result;
-}
-function encodeCompactSizeUint(value) {
-    if (value < 0xfd) {
-        return new Uint8Array([value]);
-    }
-    else if (value <= 0xffff) {
-        const buffer = new Uint8Array(3);
-        buffer[0] = 0xfd;
-        new DataView(buffer.buffer).setUint16(1, value, true);
-        return buffer;
-    }
-    else if (value <= 0xffffffff) {
-        const buffer = new Uint8Array(5);
-        buffer[0] = 0xfe;
-        new DataView(buffer.buffer).setUint32(1, value, true);
-        return buffer;
-    }
-    else {
-        const buffer = new Uint8Array(9);
-        buffer[0] = 0xff;
-        new DataView(buffer.buffer).setBigUint64(1, BigInt(value), true);
-        return buffer;
-    }
-}

package/dist/cjs/utils/arkTransaction.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildOffchainTx = buildOffchainTx;
+exports.hasBoardingTxExpired = hasBoardingTxExpired;
 const transaction_js_1 = require("@scure/btc-signer/transaction.js");
 const tapscript_1 = require("../script/tapscript");
 const base_1 = require("../script/base");
@@ -106,3 +107,15 @@ const nLocktimeMinSeconds = 500000000n;
 function isSeconds(locktime) {
     return locktime >= nLocktimeMinSeconds;
 }
+function hasBoardingTxExpired(coin, boardingTimelock) {
+    if (!coin.status.block_time)
+        return false;
+    if (boardingTimelock.value === 0n)
+        return true;
+    if (boardingTimelock.type !== "blocks")
+        return false; // TODO: handle get chain tip
+    // validate expiry in terms of seconds
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const blockTime = BigInt(Math.floor(coin.status.block_time));
+    return blockTime + boardingTimelock.value <= now;
+}

package/dist/cjs/wallet/index.js

@@ -10,7 +10,7 @@ var TxType;
     TxType["TxReceived"] = "RECEIVED";
 })(TxType || (exports.TxType = TxType = {}));
 function isSpendable(vtxo) {
-    return vtxo.spentBy === undefined || vtxo.spentBy === "";
+    return !vtxo.isSpent;
 }
 function isRecoverable(vtxo) {
     return vtxo.virtualStatus.state === "swept" && isSpendable(vtxo);

package/dist/cjs/wallet/serviceWorker/utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupServiceWorker = setupServiceWorker;
-exports.extendVirtualCoin = extendVirtualCoin;
 /**
  * setupServiceWorker sets up the service worker.
  * @param path - the path to the service worker script
@@ -48,11 +47,3 @@ async function setupServiceWorker(path) {
         navigator.serviceWorker.addEventListener("error", onError);
     });
 }
-function extendVirtualCoin(wallet, vtxo) {
-    return {
-        ...vtxo,
-        forfeitTapLeafScript: wallet.offchainTapscript.forfeit(),
-        intentTapLeafScript: wallet.offchainTapscript.exit(),
-        tapTree: wallet.offchainTapscript.encode(),
-    };
-}

package/dist/cjs/wallet/serviceWorker/worker.js

@@ -13,7 +13,7 @@ const indexer_1 = require("../../providers/indexer");
 const base_1 = require("@scure/base");
 const indexedDB_1 = require("../../storage/indexedDB");
 const walletRepository_1 = require("../../repositories/walletRepository");
-const utils_1 = require("./utils");
+const utils_1 = require("../utils");
 /**
  * Worker is a class letting to interact with ServiceWorkerWallet from the client
  * it aims to be run in a service worker context
@@ -77,6 +77,8 @@ class Worker {
             this.incomingFundsSubscription();
         // Clear storage - this replaces vtxoRepository.close()
         await this.storage.clear();
+        // Reset in-memory caches by recreating the repository
+        this.walletRepository = new walletRepository_1.WalletRepositoryImpl(this.storage);
         this.wallet = undefined;
         this.arkProvider = undefined;
         this.indexerProvider = undefined;
@@ -105,9 +107,6 @@ class Worker {
         const txs = await this.wallet.getTransactionHistory();
         if (txs)
             await this.walletRepository.saveTransactions(address, txs);
-        // stop previous subscriptions if any
-        if (this.incomingFundsSubscription)
-            this.incomingFundsSubscription();
         // subscribe for incoming funds and notify all clients when new funds arrive
         this.incomingFundsSubscription = await this.wallet.notifyIncomingFunds(async (funds) => {
             if (funds.type === "vtxo") {
@@ -127,7 +126,7 @@ class Worker {
                 // notify all clients about the vtxo update
                 this.sendMessageToAllClients("VTXO_UPDATE", JSON.stringify({ newVtxos, spentVtxos }));
             }
-            if (funds.type === "utxo" && funds.coins.length > 0) {
+            if (funds.type === "utxo") {
                 // notify all clients about the utxo update
                 this.sendMessageToAllClients("UTXO_UPDATE", JSON.stringify(funds.coins));
             }
@@ -358,17 +357,16 @@ class Worker {
             if (!message.filter?.withRecoverable) {
                 if (!this.wallet)
                     throw new Error("Wallet not initialized");
-                // exclude subdust is we don't want recoverable
-                const dustAmount = this.wallet?.dustAmount;
-                vtxos =
-                    dustAmount == null
-                        ? vtxos
-                        : vtxos.filter((v) => !(0, __1.isSubdust)(v, dustAmount));
-            }
-            if (message.filter?.withRecoverable) {
-                // get also swept and spendable vtxos
-                const sweptVtxos = await this.getSweptVtxos();
-                vtxos.push(...sweptVtxos.filter(__1.isSpendable));
+                // exclude subdust and recoverable if we don't want recoverable
+                const notSubdust = (v) => {
+                    const dustAmount = this.wallet?.dustAmount;
+                    return dustAmount == null
+                        ? true
+                        : !(0, __1.isSubdust)(v, dustAmount);
+                };
+                vtxos = vtxos
+                    .filter(notSubdust)
+                    .filter((v) => !(0, __1.isRecoverable)(v));
             }
             event.source?.postMessage(response_1.Response.vtxos(message.id, vtxos));
         }
@@ -529,7 +527,6 @@ class Worker {
     }
     async handleReloadWallet(event) {
         const message = event.data;
-        console.log("RELOAD_WALLET message received", message);
         if (!request_1.Request.isReloadWallet(message)) {
             console.error("Invalid RELOAD_WALLET message format", message);
             event.source?.postMessage(response_1.Response.error(message.id, "Invalid RELOAD_WALLET message format"));

package/dist/cjs/wallet/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendVirtualCoin = extendVirtualCoin;
+function extendVirtualCoin(wallet, vtxo) {
+    return {
+        ...vtxo,
+        forfeitTapLeafScript: wallet.offchainTapscript.forfeit(),
+        intentTapLeafScript: wallet.offchainTapscript.exit(),
+        tapTree: wallet.offchainTapscript.encode(),
+    };
+}

package/dist/cjs/wallet/wallet.js

@@ -60,7 +60,7 @@ const txTree_1 = require("../tree/txTree");
 const inMemory_1 = require("../storage/inMemory");
 const walletRepository_1 = require("../repositories/walletRepository");
 const contractRepository_1 = require("../repositories/contractRepository");
-const utils_1 = require("./serviceWorker/utils");
+const utils_1 = require("./utils");
 /**
  * Main wallet implementation for Bitcoin transactions with Ark protocol support.
  * The wallet does not store any data locally and relies on Ark and onchain
@@ -68,13 +68,21 @@ const utils_1 = require("./serviceWorker/utils");
  *
  * @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();
@@ -108,11 +116,29 @@ class Wallet {
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
-        const arkProvider = new ark_1.RestArkProvider(config.arkServerUrl);
-        const indexerProvider = new indexer_1.RestIndexerProvider(config.arkServerUrl);
+        // Use provided arkProvider instance or create a new one from arkServerUrl
+        const arkProvider = config.arkProvider ||
+            (() => {
+                if (!config.arkServerUrl) {
+                    throw new Error("Either arkProvider or arkServerUrl must be provided");
+                }
+                return new ark_1.RestArkProvider(config.arkServerUrl);
+            })();
+        // Extract arkServerUrl from provider if not explicitly provided
+        const arkServerUrl = config.arkServerUrl || arkProvider.serverUrl;
+        if (!arkServerUrl) {
+            throw new Error("Could not determine arkServerUrl from provider");
+        }
+        // Use provided indexerProvider instance or create a new one
+        // indexerUrl defaults to arkServerUrl if not provided
+        const indexerUrl = config.indexerUrl || arkServerUrl;
+        const indexerProvider = config.indexerProvider || new indexer_1.RestIndexerProvider(indexerUrl);
         const info = await arkProvider.getInfo();
         const network = (0, networks_1.getNetwork)(info.network);
-        const onchainProvider = new onchain_1.EsploraProvider(config.esploraUrl || onchain_1.ESPLORA_URL[info.network]);
+        // Extract esploraUrl from provider if not explicitly provided
+        const esploraUrl = config.esploraUrl || onchain_1.ESPLORA_URL[info.network];
+        // Use provided onchainProvider instance or create a new one
+        const onchainProvider = config.onchainProvider || new onchain_1.EsploraProvider(esploraUrl);
         const exitTimelock = {
             value: info.unilateralExitDelay,
             type: info.unilateralExitDelay < 512n ? "blocks" : "seconds",
@@ -136,8 +162,14 @@ class Wallet {
         // Save tapscripts
         const offchainTapscript = bareVtxoTapscript;
         // the serverUnrollScript is the one used to create output scripts of the checkpoint transactions
-        const rawCheckpointExitClosure = base_1.hex.decode(info.checkpointExitClosure);
-        const serverUnrollScript = tapscript_1.CSVMultisigTapscript.decode(rawCheckpointExitClosure);
+        let serverUnrollScript;
+        try {
+            const raw = base_1.hex.decode(info.checkpointExitClosure);
+            serverUnrollScript = tapscript_1.CSVMultisigTapscript.decode(raw);
+        }
+        catch (e) {
+            throw new Error("Invalid checkpointExitClosure from server");
+        }
         // parse the server forfeit address
         // server is expecting funds to be sent to this address
         const forfeitAddress = (0, payment_js_1.Address)(network).decode(info.forfeitAddress);
@@ -208,40 +240,24 @@ class Wallet {
         // if (cachedVtxos.length) return cachedVtxos;
         // For now, always fetch fresh data from provider and update cache
         // In future, we can add cache invalidation logic based on timestamps
-        const spendableVtxos = await this.getVirtualCoins(filter);
-        const encodedOffchainTapscript = this.offchainTapscript.encode();
-        const forfeit = this.offchainTapscript.forfeit();
-        const exit = this.offchainTapscript.exit();
-        const extendedVtxos = spendableVtxos.map((vtxo) => ({
-            ...vtxo,
-            forfeitTapLeafScript: forfeit,
-            intentTapLeafScript: exit,
-            tapTree: encodedOffchainTapscript,
-        }));
+        const vtxos = await this.getVirtualCoins(filter);
+        const extendedVtxos = vtxos.map((vtxo) => (0, utils_1.extendVirtualCoin)(this, vtxo));
         // Update cache with fresh data
         await this.walletRepository.saveVtxos(address, extendedVtxos);
         return extendedVtxos;
     }
     async getVirtualCoins(filter = { withRecoverable: true, withUnrolled: false }) {
         const scripts = [base_1.hex.encode(this.offchainTapscript.pkScript)];
-        const response = await this.indexerProvider.getVtxos({
-            scripts,
-            spendableOnly: true,
-        });
-        const vtxos = response.vtxos;
-        if (filter.withRecoverable) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts,
-                recoverableOnly: true,
-            });
-            vtxos.push(...response.vtxos);
+        const response = await this.indexerProvider.getVtxos({ scripts });
+        const allVtxos = response.vtxos;
+        let vtxos = allVtxos.filter(_1.isSpendable);
+        // all recoverable vtxos are spendable by definition
+        if (!filter.withRecoverable) {
+            vtxos = vtxos.filter((vtxo) => !(0, _1.isRecoverable)(vtxo));
         }
         if (filter.withUnrolled) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts,
-                spentOnly: true,
-            });
-            vtxos.push(...response.vtxos.filter((vtxo) => vtxo.isUnrolled));
+            const spentVtxos = allVtxos.filter((vtxo) => !(0, _1.isSpendable)(vtxo));
+            vtxos.push(...spentVtxos.filter((vtxo) => vtxo.isUnrolled));
         }
         return vtxos;
     }
@@ -279,10 +295,10 @@ class Wallet {
         return txs;
     }
     async getBoardingTxs() {
-        const boardingAddress = await this.getBoardingAddress();
-        const txs = await this.onchainProvider.getTransactions(boardingAddress);
         const utxos = [];
         const commitmentsToIgnore = new Set();
+        const boardingAddress = await this.getBoardingAddress();
+        const txs = await this.onchainProvider.getTransactions(boardingAddress);
         for (const tx of txs) {
             for (let i = 0; i < tx.vout.length; i++) {
                 const vout = tx.vout[i];
@@ -423,13 +439,15 @@ class Wallet {
                 }
             }
         }
-        // if no params are provided, use all boarding and offchain utxos as inputs
+        // if no params are provided, use all non expired boarding utxos and offchain vtxos as inputs
         // and send all to the offchain address
         if (!params) {
             let amount = 0;
-            const boardingUtxos = await this.getBoardingUtxos();
+            const exitScript = tapscript_1.CSVMultisigTapscript.decode(base_1.hex.decode(this.boardingTapscript.exitScript));
+            const boardingTimelock = exitScript.params.timelock;
+            const boardingUtxos = (await this.getBoardingUtxos()).filter((utxo) => !(0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock));
             amount += boardingUtxos.reduce((sum, input) => sum + input.value, 0);
-            const vtxos = await this.getVtxos();
+            const vtxos = await this.getVtxos({ withRecoverable: true });
             amount += vtxos.reduce((sum, input) => sum + input.value, 0);
             const inputs = [...boardingUtxos, ...vtxos];
             if (inputs.length === 0) {
@@ -639,22 +657,22 @@ class Wallet {
         let onchainStopFunc;
         let indexerStopFunc;
         if (this.onchainProvider && boardingAddress) {
+            const findVoutOnTx = (tx) => {
+                return tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
+            };
             onchainStopFunc = await this.onchainProvider.watchAddresses([boardingAddress], (txs) => {
+                // find all utxos belonging to our boarding address
                 const coins = txs
+                    // filter txs where address is in output
+                    .filter((tx) => findVoutOnTx(tx) !== -1)
+                    // return utxo as Coin
                     .map((tx) => {
-                    const vout = tx.vout.findIndex((v) => v.scriptpubkey_address === boardingAddress);
-                    if (vout === -1) {
-                        console.warn(`No vout found for address ${boardingAddress} in transaction ${tx.txid}`);
-                        return null;
-                    }
-                    return {
-                        txid: tx.txid,
-                        vout,
-                        value: Number(tx.vout[vout].value),
-                        status: tx.status,
-                    };
-                })
-                    .filter((coin) => coin !== null);
+                    const { txid, status } = tx;
+                    const vout = findVoutOnTx(tx);
+                    const value = Number(tx.vout[vout].value);
+                    return { txid, vout, value, status };
+                });
+                // and notify via callback
                 eventCallback({
                     type: "utxo",
                     coins,

package/dist/esm/adapters/expo.js

@@ -0,0 +1,3 @@
+// Expo adapter for React Native/Expo environments
+export { ExpoArkProvider } from '../providers/expoArk.js';
+export { ExpoIndexerProvider } from '../providers/expoIndexer.js';

package/dist/esm/index.js

@@ -17,7 +17,7 @@ import { Response } from './wallet/serviceWorker/response.js';
 import { ESPLORA_URL, EsploraProvider, } from './providers/onchain.js';
 import { RestArkProvider, SettlementEventType, } from './providers/ark.js';
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from './script/tapscript.js';
-import { buildOffchainTx, } from './utils/arkTransaction.js';
+import { hasBoardingTxExpired, 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';
@@ -43,7 +43,7 @@ decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTa
 // Ark PSBT fields
 ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, 
 // Utils
-buildOffchainTx, waitForIncomingFunds, 
+buildOffchainTx, waitForIncomingFunds, hasBoardingTxExpired, 
 // Arknote
 ArkNote, 
 // Network