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

package/dist/cjs/providers/expoIndexer.js

@@ -1,41 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpoIndexerProvider = void 0;
 const indexer_1 = require("./indexer");
 const ark_1 = require("./ark");
+const expoUtils_1 = require("./expoUtils");
 // Helper function to convert Vtxo to VirtualCoin (same as in indexer.ts)
 function convertVtxo(vtxo) {
     return {
@@ -85,95 +53,38 @@ class ExpoIndexerProvider extends indexer_1.RestIndexerProvider {
         // Detect if we're running in React Native/Expo environment
         const isReactNative = typeof navigator !== "undefined" &&
             navigator.product === "ReactNative";
-        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
-        let expoFetch = fetch; // Default to standard fetch
-        try {
-            const expoFetchModule = await Promise.resolve().then(() => __importStar(require("expo/fetch")));
-            // expo/fetch returns a compatible fetch function but with different types
-            expoFetch = expoFetchModule.fetch;
-            console.debug("Using expo/fetch for indexer subscription");
-        }
-        catch (error) {
+        const expoFetch = await (0, expoUtils_1.getExpoFetch)().catch((error) => {
             // In React Native/Expo, expo/fetch is required for proper streaming support
             if (isReactNative) {
                 throw new Error("expo/fetch is unavailable in React Native environment. " +
                     "Please ensure expo/fetch is installed and properly configured. " +
                     "Streaming support may not work with standard fetch in React Native.");
             }
-            // In non-RN environments, fall back to standard fetch but warn about potential streaming issues
-            console.warn("Using standard fetch instead of expo/fetch. " +
-                "Streaming may not be fully supported in some environments.", error);
-        }
+            throw error;
+        });
         const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
         while (!abortSignal.aborted) {
             try {
-                const res = await expoFetch(url, {
-                    headers: {
-                        Accept: "text/event-stream",
-                        "Content-Type": "application/json",
-                    },
-                    signal: abortSignal,
-                });
-                if (!res.ok) {
-                    throw new Error(`Unexpected status ${res.status} when subscribing to address updates`);
-                }
-                // Check if response is the expected content type
-                const contentType = res.headers.get("content-type");
-                if (contentType &&
-                    !contentType.includes("text/event-stream") &&
-                    !contentType.includes("application/json")) {
-                    throw new Error(`Unexpected content-type: ${contentType}. Expected text/event-stream or application/json`);
-                }
-                if (!res.body) {
-                    throw new Error("Response body is null");
-                }
-                const reader = res.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                while (!abortSignal.aborted) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
+                yield* (0, expoUtils_1.sseStreamIterator)(url, abortSignal, expoFetch, { "Content-Type": "application/json" }, (data) => {
+                    // Handle new v8 proto format with heartbeat or event
+                    if (data.heartbeat !== undefined) {
+                        // Skip heartbeat messages
+                        return null;
                     }
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    for (let i = 0; i < lines.length - 1; i++) {
-                        const line = lines[i].trim();
-                        if (!line)
-                            continue;
-                        try {
-                            // Parse SSE format: "data: {json}"
-                            if (line.startsWith("data:")) {
-                                const jsonStr = line.substring(5).trim();
-                                if (!jsonStr)
-                                    continue;
-                                const data = JSON.parse(jsonStr);
-                                // Handle new v8 proto format with heartbeat or event
-                                if (data.heartbeat !== undefined) {
-                                    // Skip heartbeat messages
-                                    continue;
-                                }
-                                // Process event messages
-                                if (data.event) {
-                                    yield {
-                                        txid: data.event.txid,
-                                        scripts: data.event.scripts || [],
-                                        newVtxos: (data.event.newVtxos || []).map(convertVtxo),
-                                        spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
-                                        sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
-                                        tx: data.event.tx,
-                                        checkpointTxs: data.event.checkpointTxs,
-                                    };
-                                }
-                            }
-                        }
-                        catch (parseError) {
-                            console.error("Failed to parse subscription response:", parseError);
-                            throw parseError;
-                        }
+                    // Process event messages
+                    if (data.event) {
+                        return {
+                            txid: data.event.txid,
+                            scripts: data.event.scripts || [],
+                            newVtxos: (data.event.newVtxos || []).map(convertVtxo),
+                            spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
+                            sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
+                            tx: data.event.tx,
+                            checkpointTxs: data.event.checkpointTxs,
+                        };
                     }
-                    buffer = lines[lines.length - 1];
-                }
+                    return null;
+                });
             }
             catch (error) {
                 if (error instanceof Error && error.name === "AbortError") {

package/dist/cjs/providers/expoUtils.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpoFetch = getExpoFetch;
+exports.sseStreamIterator = sseStreamIterator;
+/**
+ * Dynamically imports expo/fetch with fallback to standard fetch.
+ * @returns A fetch function suitable for SSE streaming
+ */
+async function getExpoFetch(options) {
+    const requireExpo = options?.requireExpo ?? false;
+    try {
+        const expoFetchModule = await Promise.resolve().then(() => __importStar(require("expo/fetch")));
+        console.debug("Using expo/fetch for streaming");
+        return expoFetchModule.fetch;
+    }
+    catch (error) {
+        if (requireExpo) {
+            throw new Error("expo/fetch is unavailable in this environment. " +
+                "Please ensure expo/fetch is installed and properly configured.");
+        }
+        console.warn("Using standard fetch instead of expo/fetch. " +
+            "Streaming may not be fully supported in some environments.", error);
+        return fetch;
+    }
+}
+/**
+ * Generic SSE stream processor using fetch API with ReadableStream.
+ * Handles SSE format parsing, buffer management, and abort signals.
+ *
+ * @param url - The SSE endpoint URL
+ * @param abortSignal - Signal to abort the stream
+ * @param fetchFn - Fetch function to use (defaults to standard fetch)
+ * @param headers - Additional headers to send
+ * @param parseData - Function to parse and yield data from SSE events
+ */
+async function* sseStreamIterator(url, abortSignal, fetchFn, headers, parseData) {
+    const fetchController = new AbortController();
+    const cleanup = () => fetchController.abort();
+    abortSignal?.addEventListener("abort", cleanup, { once: true });
+    try {
+        const response = await fetchFn(url, {
+            headers: {
+                Accept: "text/event-stream",
+                ...headers,
+            },
+            signal: fetchController.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Unexpected status ${response.status} when fetching SSE stream`);
+        }
+        if (!response.body) {
+            throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (!abortSignal?.aborted) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            for (let i = 0; i < lines.length - 1; i++) {
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                if (line.startsWith("data:")) {
+                    const jsonStr = line.substring(5).trim();
+                    if (!jsonStr)
+                        continue;
+                    try {
+                        const data = JSON.parse(jsonStr);
+                        const parsed = parseData(data);
+                        if (parsed !== null) {
+                            yield parsed;
+                        }
+                    }
+                    catch (parseError) {
+                        console.error("Failed to parse SSE data:", parseError);
+                        throw parseError;
+                    }
+                }
+            }
+            buffer = lines[lines.length - 1];
+        }
+    }
+    finally {
+        abortSignal?.removeEventListener("abort", cleanup);
+    }
+}

package/dist/cjs/providers/onchain.js

@@ -21,9 +21,10 @@ exports.ESPLORA_URL = {
  * ```
  */
 class EsploraProvider {
-    constructor(baseUrl) {
+    constructor(baseUrl, opts) {
         this.baseUrl = baseUrl;
-        this.polling = false;
+        this.pollingInterval = opts?.pollingInterval ?? 15000;
+        this.forcePolling = opts?.forcePolling ?? false;
     }
     async getCoins(address) {
         const response = await fetch(`${this.baseUrl}/address/${address}/utxo`);
@@ -94,13 +95,9 @@ class EsploraProvider {
         let intervalId = null;
         const wsUrl = this.baseUrl.replace(/^http(s)?:/, "ws$1:") + "/v1/ws";
         const poll = async () => {
-            if (this.polling)
-                return;
-            this.polling = true;
-            // websocket is not reliable, so we will fallback to polling
-            const pollingInterval = 5000; // 5 seconds
-            const getAllTxs = () => {
-                return Promise.all(addresses.map((address) => this.getTransactions(address))).then((txArrays) => txArrays.flat());
+            const getAllTxs = async () => {
+                const txArrays = await Promise.all(addresses.map((address) => this.getTransactions(address)));
+                return txArrays.flat();
             };
             // initial fetch to get existing transactions
             const initialTxs = await getAllTxs();
@@ -125,9 +122,19 @@ class EsploraProvider {
                 catch (error) {
                     console.error("Error in polling mechanism:", error);
                 }
-            }, pollingInterval);
+            }, this.pollingInterval);
         };
         let ws = null;
+        const stopFunc = () => {
+            if (ws)
+                ws.close();
+            if (intervalId)
+                clearInterval(intervalId);
+        };
+        if (this.forcePolling) {
+            await poll();
+            return stopFunc;
+        }
         try {
             ws = new WebSocket(wsUrl);
             ws.addEventListener("open", () => {
@@ -174,13 +181,6 @@ class EsploraProvider {
             // if websocket is not available, fallback to polling
             await poll();
         }
-        const stopFunc = () => {
-            if (ws && ws.readyState === WebSocket.OPEN)
-                ws.close();
-            if (intervalId)
-                clearInterval(intervalId);
-            this.polling = false;
-        };
         return stopFunc;
     }
     async getChainTip() {
@@ -249,8 +249,7 @@ const isExplorerTransaction = (tx) => {
     return (typeof tx.txid === "string" &&
         Array.isArray(tx.vout) &&
         tx.vout.every((vout) => typeof vout.scriptpubkey_address === "string" &&
-            typeof vout.value === "string") &&
+            typeof vout.value === "number") &&
         typeof tx.status === "object" &&
-        typeof tx.status.confirmed === "boolean" &&
-        typeof tx.status.block_time === "number");
+        typeof tx.status.confirmed === "boolean");
 };

package/dist/cjs/repositories/walletRepository.js

@@ -15,7 +15,14 @@ const serializeVtxo = (v) => ({
     tapTree: toHex(v.tapTree),
     forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
     intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
-    extraWitness: v.extraWitness?.map((w) => toHex(w)),
+    extraWitness: v.extraWitness?.map(toHex),
+});
+const serializeUtxo = (u) => ({
+    ...u,
+    tapTree: toHex(u.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
+    extraWitness: u.extraWitness?.map(toHex),
 });
 const deserializeTapLeaf = (t) => {
     const cb = btc_signer_1.TaprootControlBlock.decode(fromHex(t.cb));
@@ -27,13 +34,21 @@ const deserializeVtxo = (o) => ({
     tapTree: fromHex(o.tapTree),
     forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
     intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map((w) => fromHex(w)),
+    extraWitness: o.extraWitness?.map(fromHex),
+});
+const deserializeUtxo = (o) => ({
+    ...o,
+    tapTree: fromHex(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(fromHex),
 });
 class WalletRepositoryImpl {
     constructor(storage) {
         this.storage = storage;
         this.cache = {
             vtxos: new Map(),
+            utxos: new Map(),
             transactions: new Map(),
             walletState: null,
             initialized: new Set(),
@@ -61,18 +76,6 @@ class WalletRepositoryImpl {
             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.slice());
-        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(vtxos.map(serializeVtxo)));
-    }
     async saveVtxos(address, vtxos) {
         const storedVtxos = await this.getVtxos(address);
         for (const vtxo of vtxos) {
@@ -98,6 +101,53 @@ class WalletRepositoryImpl {
         this.cache.vtxos.set(address, []);
         await this.storage.removeItem(`vtxos:${address}`);
     }
+    async getUtxos(address) {
+        const cacheKey = `utxos:${address}`;
+        if (this.cache.utxos.has(address)) {
+            return this.cache.utxos.get(address);
+        }
+        const stored = await this.storage.getItem(cacheKey);
+        if (!stored) {
+            this.cache.utxos.set(address, []);
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(stored);
+            const utxos = parsed.map(deserializeUtxo);
+            this.cache.utxos.set(address, utxos.slice());
+            return utxos.slice();
+        }
+        catch (error) {
+            console.error(`Failed to parse UTXOs for address ${address}:`, error);
+            this.cache.utxos.set(address, []);
+            return [];
+        }
+    }
+    async saveUtxos(address, utxos) {
+        const storedUtxos = await this.getUtxos(address);
+        utxos.forEach((utxo) => {
+            const existing = storedUtxos.findIndex((u) => u.txid === utxo.txid && u.vout === utxo.vout);
+            if (existing !== -1) {
+                storedUtxos[existing] = utxo;
+            }
+            else {
+                storedUtxos.push(utxo);
+            }
+        });
+        this.cache.utxos.set(address, storedUtxos.slice());
+        await this.storage.setItem(`utxos:${address}`, JSON.stringify(storedUtxos.map(serializeUtxo)));
+    }
+    async removeUtxo(address, utxoId) {
+        const utxos = await this.getUtxos(address);
+        const [txid, vout] = utxoId.split(":");
+        const filtered = utxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
+        this.cache.utxos.set(address, filtered.slice());
+        await this.storage.setItem(`utxos:${address}`, JSON.stringify(filtered.map(serializeUtxo)));
+    }
+    async clearUtxos(address) {
+        this.cache.utxos.set(address, []);
+        await this.storage.removeItem(`utxos:${address}`);
+    }
     async getTransactionHistory(address) {
         const cacheKey = `tx:${address}`;
         if (this.cache.transactions.has(address)) {
@@ -119,20 +169,6 @@ class WalletRepositoryImpl {
             return [];
         }
     }
-    async saveTransaction(address, tx) {
-        const transactions = await this.getTransactionHistory(address);
-        const existing = transactions.findIndex((t) => t.key === tx.key);
-        if (existing !== -1) {
-            transactions[existing] = tx;
-        }
-        else {
-            transactions.push(tx);
-        }
-        // Sort by createdAt descending
-        transactions.sort((a, b) => b.createdAt - a.createdAt);
-        this.cache.transactions.set(address, transactions);
-        await this.storage.setItem(`tx:${address}`, JSON.stringify(transactions));
-    }
     async saveTransactions(address, txs) {
         const storedTransactions = await this.getTransactionHistory(address);
         for (const tx of txs) {

package/dist/cjs/script/base.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VtxoScript = void 0;
+exports.VtxoScript = exports.TapTreeCoder = 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 base_1 = require("@scure/base");
 const address_1 = require("./address");
 const tapscript_1 = require("./tapscript");
-const TapTreeCoder = psbt_js_1.PSBTOutput.tapTree[2];
+exports.TapTreeCoder = psbt_js_1.PSBTOutput.tapTree[2];
 function scriptFromTapLeafScript(leaf) {
     return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte
 }
@@ -23,14 +22,23 @@ function scriptFromTapLeafScript(leaf) {
  */
 class VtxoScript {
     static decode(tapTree) {
-        const leaves = TapTreeCoder.decode(tapTree);
+        const leaves = exports.TapTreeCoder.decode(tapTree);
         const scripts = leaves.map((leaf) => leaf.script);
         return new VtxoScript(scripts);
     }
     constructor(scripts) {
         this.scripts = scripts;
-        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);
+        // reverse the scripts if the number of scripts is odd
+        // this is to be compatible with arkd algorithm computing taproot tree from list of tapscripts
+        // the scripts must be reversed only HERE while we compute the tweaked public key
+        // but the original order should be preserved while encoding as taptree
+        // note: .slice().reverse() is used instead of .reverse() to avoid mutating the original array
+        const list = scripts.length % 2 !== 0 ? scripts.slice().reverse() : scripts;
+        const tapTree = (0, btc_signer_1.taprootListToTree)(list.map((script) => ({
+            script,
+            leafVersion: payment_js_1.TAP_LEAF_VERSION,
+        })));
+        const payment = (0, btc_signer_1.p2tr)(btc_signer_1.TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
         if (!payment.tapLeafScript ||
             payment.tapLeafScript.length !== scripts.length) {
             throw new Error("invalid scripts");
@@ -39,7 +47,7 @@ class VtxoScript {
         this.tweakedPublicKey = payment.tweakedPubkey;
     }
     encode() {
-        const tapTree = TapTreeCoder.encode(this.scripts.map((script) => ({
+        const tapTree = exports.TapTreeCoder.encode(this.scripts.map((script) => ({
             depth: 1,
             version: payment_js_1.TAP_LEAF_VERSION,
             script,