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

package/README.md

@@ -288,6 +288,55 @@ const wallet = await Wallet.create({
 })
 ```
 
+### Using with Expo/React Native
+
+For React Native and Expo applications where standard EventSource and fetch streaming may not work properly, use the Expo-compatible providers:
+
+```typescript
+import { Wallet, SingleKey } from '@arkade-os/sdk'
+import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo'
+
+const identity = SingleKey.fromHex('your_private_key_hex')
+
+const wallet = await Wallet.create({
+  identity: identity,
+  esploraUrl: 'https://mutinynet.com/api',
+  arkProvider: new ExpoArkProvider('https://mutinynet.arkade.sh'), // For settlement events and transactions streaming
+  indexerProvider: new ExpoIndexerProvider('https://mutinynet.arkade.sh'), // For address subscriptions and VTXO updates
+})
+
+// use expo/fetch for streaming support (SSE)
+// All other wallet functionality remains the same
+const balance = await wallet.getBalance()
+const address = await wallet.getAddress()
+```
+
+Both ExpoArkProvider and ExpoIndexerProvider are available as adapters following the SDK's modular architecture pattern. This keeps the main SDK bundle clean while providing opt-in functionality for specific environments:
+
+- **ExpoArkProvider**: Handles settlement events and transaction streaming using expo/fetch for Server-Sent Events
+- **ExpoIndexerProvider**: Handles address subscriptions and VTXO updates using expo/fetch for JSON streaming
+
+#### Crypto Polyfill Requirement
+
+Install `expo-crypto` and polyfill `crypto.getRandomValues()` at the top of your app entry point:
+
+```bash
+npx expo install expo-crypto
+```
+
+```typescript
+// App.tsx or index.js - MUST be first import
+import * as Crypto from 'expo-crypto';
+if (!global.crypto) global.crypto = {} as any;
+global.crypto.getRandomValues = Crypto.getRandomValues;
+
+// Now import the SDK
+import { Wallet, SingleKey } from '@arkade-os/sdk';
+import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo';
+```
+
+This is required for MuSig2 settlements and cryptographic operations.
+
 ### Repository Pattern
 
 Access low-level data management through repositories:
@@ -311,6 +360,8 @@ await wallet.contractRepository.saveToContractCollection(
 const swaps = await wallet.contractRepository.getContractCollection('swaps')
 ```
 
+_For complete API documentation, visit our [TypeScript documentation](https://arkade-os.github.io/ts-sdk/)._
+
 ## Development
 
 ### Requirements

package/dist/cjs/adapters/expo.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoIndexerProvider = exports.ExpoArkProvider = void 0;
+// Expo adapter for React Native/Expo environments
+var expoArk_1 = require("../providers/expoArk");
+Object.defineProperty(exports, "ExpoArkProvider", { enumerable: true, get: function () { return expoArk_1.ExpoArkProvider; } });
+var expoIndexer_1 = require("../providers/expoIndexer");
+Object.defineProperty(exports, "ExpoIndexerProvider", { enumerable: true, get: function () { return expoIndexer_1.ExpoIndexerProvider; } });

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.Unroll = exports.P2A = exports.TxTree = exports.BIP322 = exports.ContractRepositoryImpl = exports.WalletRepositoryImpl = exports.networks = exports.ArkNote = exports.waitForIncomingFunds = exports.buildOffchainTx = exports.ConditionWitness = exports.VtxoTaprootTree = exports.VtxoTreeExpiry = exports.CosignerPublicKey = exports.getArkPsbtFields = exports.setArkPsbtField = exports.ArkPsbtFieldKeyType = exports.ArkPsbtFieldKey = exports.CLTVMultisigTapscript = exports.ConditionMultisigTapscript = exports.ConditionCSVMultisigTapscript = exports.CSVMultisigTapscript = exports.MultisigTapscript = exports.decodeTapscript = exports.Response = exports.Request = exports.ServiceWorkerWallet = exports.Worker = exports.setupServiceWorker = exports.SettlementEventType = exports.ChainTxType = exports.IndexerTxType = exports.TxType = exports.VHTLC = exports.VtxoScript = exports.DefaultVtxo = exports.ArkAddress = exports.RestIndexerProvider = exports.RestArkProvider = exports.EsploraProvider = exports.ESPLORA_URL = exports.Ramps = exports.OnchainWallet = exports.SingleKey = exports.Wallet = void 0;
+exports.Transaction = exports.Unroll = exports.P2A = exports.TxTree = exports.BIP322 = exports.ContractRepositoryImpl = exports.WalletRepositoryImpl = exports.networks = exports.ArkNote = exports.hasBoardingTxExpired = exports.waitForIncomingFunds = exports.buildOffchainTx = exports.ConditionWitness = exports.VtxoTaprootTree = exports.VtxoTreeExpiry = exports.CosignerPublicKey = exports.getArkPsbtFields = exports.setArkPsbtField = exports.ArkPsbtFieldKeyType = exports.ArkPsbtFieldKey = exports.CLTVMultisigTapscript = exports.ConditionMultisigTapscript = exports.ConditionCSVMultisigTapscript = exports.CSVMultisigTapscript = exports.MultisigTapscript = exports.decodeTapscript = exports.Response = exports.Request = exports.ServiceWorkerWallet = exports.Worker = exports.setupServiceWorker = exports.SettlementEventType = exports.ChainTxType = exports.IndexerTxType = exports.TxType = exports.VHTLC = exports.VtxoScript = exports.DefaultVtxo = exports.ArkAddress = exports.RestIndexerProvider = exports.RestArkProvider = exports.EsploraProvider = exports.ESPLORA_URL = exports.Ramps = exports.OnchainWallet = exports.SingleKey = exports.Wallet = void 0;
 const transaction_js_1 = require("@scure/btc-signer/transaction.js");
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_js_1.Transaction; } });
 const singleKey_1 = require("./identity/singleKey");
@@ -48,6 +48,7 @@ Object.defineProperty(exports, "CSVMultisigTapscript", { enumerable: true, get:
 Object.defineProperty(exports, "decodeTapscript", { enumerable: true, get: function () { return tapscript_1.decodeTapscript; } });
 Object.defineProperty(exports, "MultisigTapscript", { enumerable: true, get: function () { return tapscript_1.MultisigTapscript; } });
 const arkTransaction_1 = require("./utils/arkTransaction");
+Object.defineProperty(exports, "hasBoardingTxExpired", { enumerable: true, get: function () { return arkTransaction_1.hasBoardingTxExpired; } });
 Object.defineProperty(exports, "buildOffchainTx", { enumerable: true, get: function () { return arkTransaction_1.buildOffchainTx; } });
 const unknownFields_1 = require("./utils/unknownFields");
 Object.defineProperty(exports, "VtxoTaprootTree", { enumerable: true, get: function () { return unknownFields_1.VtxoTaprootTree; } });

package/dist/cjs/providers/expoArk.js

@@ -0,0 +1,237 @@
+"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.ExpoArkProvider = void 0;
+const ark_1 = require("./ark");
+/**
+ * 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();
+ * ```
+ */
+class ExpoArkProvider extends ark_1.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 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 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 ((0, ark_1.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 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 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 ((0, ark_1.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);
+            }
+        }
+    }
+}
+exports.ExpoArkProvider = ExpoArkProvider;

package/dist/cjs/providers/expoIndexer.js

@@ -0,0 +1,194 @@
+"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");
+// 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'] });
+ * ```
+ */
+class ExpoIndexerProvider extends indexer_1.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 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) {
+            // 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 ((0, ark_1.isFetchTimeoutError)(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
+                console.error("Subscription error:", error);
+                throw error;
+            }
+        }
+    }
+}
+exports.ExpoIndexerProvider = ExpoIndexerProvider;

package/dist/cjs/providers/indexer.js

@@ -176,6 +176,7 @@ class RestIndexerProvider {
                                     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,
                                 };
@@ -329,7 +330,7 @@ class RestIndexerProvider {
         });
         if (!res.ok) {
             const errorText = await res.text();
-            throw new Error(`Failed to unsubscribe to scripts: ${errorText}`);
+            console.warn(`Failed to unsubscribe to scripts: ${errorText}`);
         }
     }
 }
@@ -358,6 +359,7 @@ function convertVtxo(vtxo) {
         arkTxId: vtxo.arkTxid,
         createdAt: new Date(Number(vtxo.createdAt) * 1000),
         isUnrolled: vtxo.isUnrolled,
+        isSpent: vtxo.isSpent,
     };
 }
 // Unexported namespace for type guards only