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

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

package/dist/esm/providers/expoArk.js

@@ -0,0 +1,200 @@
+import { RestArkProvider, isFetchTimeoutError, } from './ark.js';
+/**
+ * Expo-compatible Ark provider implementation using expo/fetch for SSE support.
+ * This provider works specifically in React Native/Expo environments where
+ * standard EventSource is not available but expo/fetch provides SSE capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { ExpoArkProvider } from '@arkade-os/sdk/providers/expo';
+ *
+ * const provider = new ExpoArkProvider('https://ark.example.com');
+ * const info = await provider.getInfo();
+ * ```
+ */
+export class ExpoArkProvider extends RestArkProvider {
+    constructor(serverUrl) {
+        super(serverUrl);
+    }
+    async *getEventStream(signal, topics) {
+        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
+        let expoFetch = fetch; // Default to standard fetch
+        try {
+            const expoFetchModule = await import("expo/fetch");
+            // expo/fetch returns a compatible fetch function but with different types
+            expoFetch = expoFetchModule.fetch;
+            console.debug("Using expo/fetch for SSE");
+        }
+        catch (error) {
+            // Fall back to standard fetch if expo/fetch is not available
+            console.warn("Using standard fetch instead of expo/fetch. " +
+                "Streaming may not be fully supported in some environments.", error);
+        }
+        const url = `${this.serverUrl}/v1/batch/events`;
+        const queryParams = topics.length > 0
+            ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
+            : "";
+        while (!signal?.aborted) {
+            // Create a new AbortController for this specific fetch attempt
+            // to prevent accumulating listeners on the parent signal
+            const fetchController = new AbortController();
+            const cleanup = () => fetchController.abort();
+            signal?.addEventListener("abort", cleanup, { once: true });
+            try {
+                const response = await expoFetch(url + queryParams, {
+                    headers: {
+                        Accept: "text/event-stream",
+                    },
+                    signal: fetchController.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`Unexpected status ${response.status} when fetching event stream`);
+                }
+                if (!response.body) {
+                    throw new Error("Response body is null");
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (!signal?.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    // Append new data to buffer and split by newlines
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    // Process all complete lines
+                    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 different response structures
+                                // v8 mesh API might wrap in {result: ...} or send directly
+                                const eventData = data.result || data;
+                                // Skip heartbeat messages
+                                if (eventData.heartbeat !== undefined) {
+                                    continue;
+                                }
+                                const event = this.parseSettlementEvent(eventData);
+                                if (event) {
+                                    yield event;
+                                }
+                            }
+                        }
+                        catch (err) {
+                            console.error("Failed to parse event:", line);
+                            console.error("Parse error:", err);
+                            throw err;
+                        }
+                    }
+                    // Keep the last partial line in the buffer
+                    buffer = lines[lines.length - 1];
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    break;
+                }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by expo/fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Event stream error:", error);
+                throw error;
+            }
+            finally {
+                // Clean up the abort listener
+                signal?.removeEventListener("abort", cleanup);
+            }
+        }
+    }
+    async *getTransactionsStream(signal) {
+        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
+        let expoFetch = fetch; // Default to standard fetch
+        try {
+            const expoFetchModule = await import("expo/fetch");
+            // expo/fetch returns a compatible fetch function but with different types
+            expoFetch = expoFetchModule.fetch;
+            console.debug("Using expo/fetch for transaction stream");
+        }
+        catch (error) {
+            // Fall back to standard fetch if expo/fetch is not available
+            console.warn("Using standard fetch instead of expo/fetch. " +
+                "Streaming may not be fully supported in some environments.", error);
+        }
+        const url = `${this.serverUrl}/v1/txs`;
+        while (!signal?.aborted) {
+            // Create a new AbortController for this specific fetch attempt
+            // to prevent accumulating listeners on the parent signal
+            const fetchController = new AbortController();
+            const cleanup = () => fetchController.abort();
+            signal?.addEventListener("abort", cleanup, { once: true });
+            try {
+                const response = await expoFetch(url, {
+                    headers: {
+                        Accept: "text/event-stream",
+                    },
+                    signal: fetchController.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`Unexpected status ${response.status} when fetching transaction stream`);
+                }
+                if (!response.body) {
+                    throw new Error("Response body is null");
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (!signal?.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    // Append new data to buffer and split by newlines
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    // Process all complete lines
+                    for (let i = 0; i < lines.length - 1; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
+                        const data = JSON.parse(line);
+                        const txNotification = this.parseTransactionNotification(data.result);
+                        if (txNotification) {
+                            yield txNotification;
+                        }
+                    }
+                    // Keep the last partial line in the buffer
+                    buffer = lines[lines.length - 1];
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    break;
+                }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by expo/fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Address subscription error:", error);
+                throw error;
+            }
+            finally {
+                // Clean up the abort listener
+                signal?.removeEventListener("abort", cleanup);
+            }
+        }
+    }
+}

package/dist/esm/providers/expoIndexer.js

@@ -0,0 +1,157 @@
+import { RestIndexerProvider } from './indexer.js';
+import { isFetchTimeoutError } from './ark.js';
+// Helper function to convert Vtxo to VirtualCoin (same as in indexer.ts)
+function convertVtxo(vtxo) {
+    return {
+        txid: vtxo.outpoint.txid,
+        vout: vtxo.outpoint.vout,
+        value: Number(vtxo.amount),
+        status: {
+            confirmed: !vtxo.isSwept && !vtxo.isPreconfirmed,
+        },
+        virtualStatus: {
+            state: vtxo.isSwept
+                ? "swept"
+                : vtxo.isPreconfirmed
+                    ? "preconfirmed"
+                    : "settled",
+            commitmentTxIds: vtxo.commitmentTxids,
+            batchExpiry: vtxo.expiresAt
+                ? Number(vtxo.expiresAt) * 1000
+                : undefined,
+        },
+        spentBy: vtxo.spentBy ?? "",
+        settledBy: vtxo.settledBy,
+        arkTxId: vtxo.arkTxid,
+        createdAt: new Date(Number(vtxo.createdAt) * 1000),
+        isUnrolled: vtxo.isUnrolled,
+        isSpent: vtxo.isSpent,
+    };
+}
+/**
+ * Expo-compatible Indexer provider implementation using expo/fetch for streaming support.
+ * This provider works specifically in React Native/Expo environments where
+ * standard fetch streaming may not work properly but expo/fetch provides streaming capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo';
+ *
+ * const provider = new ExpoIndexerProvider('https://indexer.example.com');
+ * const vtxos = await provider.getVtxos({ scripts: ['script1'] });
+ * ```
+ */
+export class ExpoIndexerProvider extends RestIndexerProvider {
+    constructor(serverUrl) {
+        super(serverUrl);
+    }
+    async *getSubscription(subscriptionId, abortSignal) {
+        // 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 import("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) {
+            // 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);
+        }
+        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;
+                    }
+                    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;
+                        }
+                    }
+                    buffer = lines[lines.length - 1];
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    break;
+                }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by expo/fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Subscription error:", error);
+                throw error;
+            }
+        }
+    }
+}