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

package/dist/cjs/providers/ark.js

@@ -4,6 +4,7 @@ exports.RestArkProvider = exports.SettlementEventType = void 0;
 exports.isFetchTimeoutError = isFetchTimeoutError;
 const base_1 = require("@scure/base");
 const utils_1 = require("./utils");
+const errors_1 = require("./errors");
 var SettlementEventType;
 (function (SettlementEventType) {
     SettlementEventType["BatchStarted"] = "batch_started";
@@ -11,7 +12,7 @@ var SettlementEventType;
     SettlementEventType["BatchFinalized"] = "batch_finalized";
     SettlementEventType["BatchFailed"] = "batch_failed";
     SettlementEventType["TreeSigningStarted"] = "tree_signing_started";
-    SettlementEventType["TreeNoncesAggregated"] = "tree_nonces_aggregated";
+    SettlementEventType["TreeNonces"] = "tree_nonces";
     SettlementEventType["TreeTx"] = "tree_tx";
     SettlementEventType["TreeSignature"] = "tree_signature";
 })(SettlementEventType || (exports.SettlementEventType = SettlementEventType = {}));
@@ -32,29 +33,41 @@ class RestArkProvider {
         const url = `${this.serverUrl}/v1/info`;
         const response = await fetch(url);
         if (!response.ok) {
-            throw new Error(`Failed to get server info: ${response.statusText}`);
+            const errorText = await response.text();
+            handleError(errorText, `Failed to get server info: ${response.statusText}`);
         }
         const fromServer = await response.json();
         return {
-            ...fromServer,
-            vtxoTreeExpiry: BigInt(fromServer.vtxoTreeExpiry ?? 0),
-            unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
-            roundInterval: BigInt(fromServer.roundInterval ?? 0),
-            dust: BigInt(fromServer.dust ?? 0),
-            utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
-            utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
-            vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
-            vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
             boardingExitDelay: BigInt(fromServer.boardingExitDelay ?? 0),
-            checkpointExitClosure: fromServer.checkpointTapscript ?? "",
-            marketHour: "marketHour" in fromServer && fromServer.marketHour != null
+            checkpointTapscript: fromServer.checkpointTapscript ?? "",
+            deprecatedSigners: fromServer.deprecatedSigners?.map((signer) => ({
+                cutoffDate: BigInt(signer.cutoffDate ?? 0),
+                pubkey: signer.pubkey ?? "",
+            })) ?? [],
+            digest: fromServer.digest ?? "",
+            dust: BigInt(fromServer.dust ?? 0),
+            fees: fromServer.fees,
+            forfeitAddress: fromServer.forfeitAddress ?? "",
+            forfeitPubkey: fromServer.forfeitPubkey ?? "",
+            network: fromServer.network ?? "",
+            scheduledSession: "scheduledSession" in fromServer &&
+                fromServer.scheduledSession != null
                 ? {
-                    nextStartTime: BigInt(fromServer.marketHour.nextStartTime ?? 0),
-                    nextEndTime: BigInt(fromServer.marketHour.nextEndTime ?? 0),
-                    period: BigInt(fromServer.marketHour.period ?? 0),
-                    roundInterval: BigInt(fromServer.marketHour.roundInterval ?? 0),
+                    duration: BigInt(fromServer.scheduledSession.duration ?? 0),
+                    nextStartTime: BigInt(fromServer.scheduledSession.nextStartTime ?? 0),
+                    nextEndTime: BigInt(fromServer.scheduledSession.nextEndTime ?? 0),
+                    period: BigInt(fromServer.scheduledSession.period ?? 0),
                 }
                 : undefined,
+            serviceStatus: fromServer.serviceStatus ?? {},
+            sessionDuration: BigInt(fromServer.sessionDuration ?? 0),
+            signerPubkey: fromServer.signerPubkey ?? "",
+            unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
+            utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
+            utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
+            version: fromServer.version ?? "",
+            vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
+            vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
         };
     }
     async submitTx(signedArkTx, checkpointTxs) {
@@ -65,22 +78,13 @@ class RestArkProvider {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                signedArkTx: signedArkTx,
-                checkpointTxs: checkpointTxs,
+                signedArkTx,
+                checkpointTxs,
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            try {
-                const grpcError = JSON.parse(errorText);
-                // gRPC errors usually have a message and code field
-                throw new Error(`Failed to submit virtual transaction: ${grpcError.message || grpcError.error || errorText}`);
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            }
-            catch (_) {
-                // If JSON parse fails, use the raw error text
-                throw new Error(`Failed to submit virtual transaction: ${errorText}`);
-            }
+            handleError(errorText, `Failed to submit virtual transaction: ${errorText}`);
         }
         const data = await response.json();
         return {
@@ -103,7 +107,7 @@ class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to finalize offchain transaction: ${errorText}`);
+            handleError(errorText, `Failed to finalize offchain transaction: ${errorText}`);
         }
     }
     async registerIntent(intent) {
@@ -115,14 +119,14 @@ class RestArkProvider {
             },
             body: JSON.stringify({
                 intent: {
-                    signature: intent.signature,
+                    proof: intent.proof,
                     message: intent.message,
                 },
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to register intent: ${errorText}`);
+            handleError(errorText, `Failed to register intent: ${errorText}`);
         }
         const data = await response.json();
         return data.intentId;
@@ -136,14 +140,14 @@ class RestArkProvider {
             },
             body: JSON.stringify({
                 proof: {
-                    signature: intent.signature,
+                    proof: intent.proof,
                     message: intent.message,
                 },
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to delete intent: ${errorText}`);
+            handleError(errorText, `Failed to delete intent: ${errorText}`);
         }
     }
     async confirmRegistration(intentId) {
@@ -159,7 +163,7 @@ class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to confirm registration: ${errorText}`);
+            handleError(errorText, `Failed to confirm registration: ${errorText}`);
         }
     }
     async submitTreeNonces(batchId, pubkey, nonces) {
@@ -177,7 +181,7 @@ class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to submit tree nonces: ${errorText}`);
+            handleError(errorText, `Failed to submit tree nonces: ${errorText}`);
         }
     }
     async submitTreeSignatures(batchId, pubkey, signatures) {
@@ -195,7 +199,7 @@ class RestArkProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to submit tree signatures: ${errorText}`);
+            handleError(errorText, `Failed to submit tree signatures: ${errorText}`);
         }
     }
     async submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx) {
@@ -211,7 +215,8 @@ class RestArkProvider {
             }),
         });
         if (!response.ok) {
-            throw new Error(`Failed to submit forfeit transactions: ${response.statusText}`);
+            const errorText = await response.text();
+            handleError(errorText, `Failed to submit forfeit transactions: ${response.statusText}`);
         }
     }
     async *getEventStream(signal, topics) {
@@ -309,6 +314,22 @@ class RestArkProvider {
             }
         }
     }
+    async getPendingTxs(intent) {
+        const url = `${this.serverUrl}/v1/tx/pending`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ intent }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            handleError(errorText, `Failed to get pending transactions: ${errorText}`);
+        }
+        const data = await response.json();
+        return data.pendingTxs;
+    }
     parseSettlementEvent(data) {
         // Check for BatchStarted event
         if (data.batchStarted) {
@@ -354,10 +375,16 @@ class RestArkProvider {
         }
         // Check for TreeNoncesAggregated event
         if (data.treeNoncesAggregated) {
+            // skip treeNoncesAggregated event, deprecated
+            return null;
+        }
+        if (data.treeNonces) {
             return {
-                type: SettlementEventType.TreeNoncesAggregated,
-                id: data.treeNoncesAggregated.id,
-                treeNonces: decodeMusig2Nonces(data.treeNoncesAggregated.treeNonces),
+                type: SettlementEventType.TreeNonces,
+                id: data.treeNonces.id,
+                topic: data.treeNonces.topic,
+                txid: data.treeNonces.txid,
+                nonces: decodeMusig2Nonces(data.treeNonces.nonces), // pubkey -> public nonce
             };
         }
         // Check for TreeTx event
@@ -431,17 +458,16 @@ function encodeMusig2Nonces(nonces) {
     for (const [txid, nonce] of nonces) {
         noncesObject[txid] = base_1.hex.encode(nonce.pubNonce);
     }
-    return JSON.stringify(noncesObject);
+    return noncesObject;
 }
 function encodeMusig2Signatures(signatures) {
     const sigObject = {};
     for (const [txid, sig] of signatures) {
         sigObject[txid] = base_1.hex.encode(sig.encode());
     }
-    return JSON.stringify(sigObject);
+    return sigObject;
 }
-function decodeMusig2Nonces(str) {
-    const noncesObject = JSON.parse(str);
+function decodeMusig2Nonces(noncesObject) {
     return new Map(Object.entries(noncesObject).map(([txid, nonce]) => {
         if (typeof nonce !== "string") {
             throw new Error("invalid nonce");
@@ -483,3 +509,8 @@ function mapVtxo(vtxo) {
         arkTxid: vtxo.arkTxid,
     };
 }
+function handleError(errorText, defaultMessage) {
+    const error = new Error(errorText);
+    const arkError = (0, errors_1.maybeArkError)(error);
+    throw arkError ?? new Error(defaultMessage);
+}

package/dist/cjs/providers/errors.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkError = void 0;
+exports.maybeArkError = maybeArkError;
+class ArkError extends Error {
+    constructor(code, message, name, metadata) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.name = name;
+        this.metadata = metadata;
+    }
+}
+exports.ArkError = ArkError;
+/**
+ * Try to convert an error to an ArkError class, returning undefined if the error is not an ArkError
+ * @param error - The error to parse
+ * @returns The parsed ArkError, or undefined if the error is not an ArkError
+ */
+function maybeArkError(error) {
+    try {
+        if (!(error instanceof Error))
+            return undefined;
+        const decoded = JSON.parse(error.message);
+        if (!("details" in decoded))
+            return undefined;
+        if (!Array.isArray(decoded.details))
+            return undefined;
+        // search for a valid details object with the correct type
+        for (const details of decoded.details) {
+            if (!("@type" in details))
+                continue;
+            const type = details["@type"];
+            if (type !== "type.googleapis.com/ark.v1.ErrorDetails")
+                continue;
+            if (!("code" in details))
+                continue;
+            const code = details.code;
+            if (!("message" in details))
+                continue;
+            const message = details.message;
+            if (!("name" in details))
+                continue;
+            const name = details.name;
+            let metadata;
+            if ("metadata" in details && isMetadata(details.metadata)) {
+                metadata = details.metadata;
+            }
+            return new ArkError(code, message, name, metadata);
+        }
+        return undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function isMetadata(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/cjs/providers/expoArk.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpoArkProvider = void 0;
+const ark_1 = require("./ark");
+const expoUtils_1 = require("./expoUtils");
+/**
+ * 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) {
+        const expoFetch = await (0, expoUtils_1.getExpoFetch)();
+        const url = `${this.serverUrl}/v1/batch/events`;
+        const queryParams = topics.length > 0
+            ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
+            : "";
+        while (!signal?.aborted) {
+            try {
+                yield* (0, expoUtils_1.sseStreamIterator)(url + queryParams, signal, expoFetch, {}, (data) => {
+                    // 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) {
+                        return null;
+                    }
+                    return this.parseSettlementEvent(eventData);
+                });
+            }
+            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;
+            }
+        }
+    }
+    async *getTransactionsStream(signal) {
+        const expoFetch = await (0, expoUtils_1.getExpoFetch)();
+        const url = `${this.serverUrl}/v1/txs`;
+        while (!signal?.aborted) {
+            try {
+                yield* (0, expoUtils_1.sseStreamIterator)(url, signal, expoFetch, {}, (data) => {
+                    return this.parseTransactionNotification(data.result);
+                });
+            }
+            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("Transaction stream error:", error);
+                throw error;
+            }
+        }
+    }
+}
+exports.ExpoArkProvider = ExpoArkProvider;

package/dist/cjs/providers/expoIndexer.js

@@ -0,0 +1,105 @@
+"use strict";
+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 {
+        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";
+        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.");
+            }
+            throw error;
+        });
+        const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
+        while (!abortSignal.aborted) {
+            try {
+                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;
+                    }
+                    // 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,
+                        };
+                    }
+                    return null;
+                });
+            }
+            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/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/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