@arkade-os/sdk 0.4.8 → 0.4.10

package/dist/cjs/wallet/vtxo-manager.js

@@ -157,7 +157,12 @@ class VtxoManager {
         this.knownBoardingUtxos = new Set();
         this.sweptBoardingUtxos = new Set();
         this.pollInProgress = false;
+        this.disposed = false;
         this.consecutivePollFailures = 0;
+        // Guards against renewal feedback loop: when renewVtxos() settles, the
+        // server emits new VTXOs → vtxo_received → renewVtxos() again → infinite loop.
+        this.renewalInProgress = false;
+        this.lastRenewalTimestamp = 0;
         // Normalize: prefer settlementConfig, fall back to renewalConfig, default to enabled
         if (settlementConfig !== undefined) {
             this.settlementConfig = settlementConfig;
@@ -341,32 +346,43 @@ class VtxoManager {
      * ```
      */
     async renewVtxos(eventCallback) {
-        // Get all VTXOs (including recoverable ones)
-        // Use default threshold to bypass settlementConfig gate (manual API should always work)
-        const vtxos = await this.getExpiringVtxos(this.settlementConfig !== false &&
-            this.settlementConfig?.vtxoThreshold !== undefined
-            ? this.settlementConfig.vtxoThreshold * 1000
-            : exports.DEFAULT_RENEWAL_CONFIG.thresholdMs);
-        if (vtxos.length === 0) {
-            throw new Error("No VTXOs available to renew");
-        }
-        const totalAmount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
-        // Get dust amount from wallet
-        const dustAmount = getDustAmount(this.wallet);
-        // Check if total amount is above dust threshold
-        if (BigInt(totalAmount) < dustAmount) {
-            throw new Error(`Total amount ${totalAmount} is below dust threshold ${dustAmount}`);
+        if (this.renewalInProgress) {
+            throw new Error("Renewal already in progress");
+        }
+        this.renewalInProgress = true;
+        try {
+            // Get all VTXOs (including recoverable ones)
+            // Use default threshold to bypass settlementConfig gate (manual API should always work)
+            const vtxos = await this.getExpiringVtxos(this.settlementConfig !== false &&
+                this.settlementConfig?.vtxoThreshold !== undefined
+                ? this.settlementConfig.vtxoThreshold * 1000
+                : exports.DEFAULT_RENEWAL_CONFIG.thresholdMs);
+            if (vtxos.length === 0) {
+                throw new Error("No VTXOs available to renew");
+            }
+            const totalAmount = vtxos.reduce((sum, vtxo) => sum + vtxo.value, 0);
+            // Get dust amount from wallet
+            const dustAmount = getDustAmount(this.wallet);
+            // Check if total amount is above dust threshold
+            if (BigInt(totalAmount) < dustAmount) {
+                throw new Error(`Total amount ${totalAmount} is below dust threshold ${dustAmount}`);
+            }
+            const arkAddress = await this.wallet.getAddress();
+            const txid = await this.wallet.settle({
+                inputs: vtxos,
+                outputs: [
+                    {
+                        address: arkAddress,
+                        amount: BigInt(totalAmount),
+                    },
+                ],
+            }, eventCallback);
+            this.lastRenewalTimestamp = Date.now();
+            return txid;
+        }
+        finally {
+            this.renewalInProgress = false;
         }
-        const arkAddress = await this.wallet.getAddress();
-        return this.wallet.settle({
-            inputs: vtxos,
-            outputs: [
-                {
-                    address: arkAddress,
-                    amount: BigInt(totalAmount),
-                },
-            ],
-        }, eventCallback);
     }
     // ========== Boarding UTXO Sweep Methods ==========
     /**
@@ -534,7 +550,11 @@ class VtxoManager {
         }
         // Start polling for boarding UTXOs independently of contract manager
         // SSE setup. Use a short delay to let the wallet finish construction.
-        setTimeout(() => this.startBoardingUtxoPoll(), 1000);
+        this.startupPollTimeoutId = setTimeout(() => {
+            if (this.disposed)
+                return;
+            this.startBoardingUtxoPoll();
+        }, 1000);
         try {
             const [delegatorManager, contractManager, destination] = await Promise.all([
                 this.wallet.getDelegatorManager(),
@@ -545,28 +565,33 @@ class VtxoManager {
                 if (event.type !== "vtxo_received") {
                     return;
                 }
-                this.renewVtxos().catch((e) => {
-                    if (e instanceof Error) {
-                        if (e.message.includes("No VTXOs available to renew")) {
-                            // Not an error, just no VTXO eligible for renewal.
-                            return;
+                const msSinceLastRenewal = Date.now() - this.lastRenewalTimestamp;
+                const shouldRenew = !this.renewalInProgress &&
+                    msSinceLastRenewal >= VtxoManager.RENEWAL_COOLDOWN_MS;
+                if (shouldRenew) {
+                    this.renewVtxos().catch((e) => {
+                        if (e instanceof Error) {
+                            if (e.message.includes("No VTXOs available to renew")) {
+                                // Not an error, just no VTXO eligible for renewal.
+                                return;
+                            }
+                            if (e.message.includes("is below dust threshold")) {
+                                // Not an error, just below dust threshold.
+                                // As more VTXOs are received, the threshold will be raised.
+                                return;
+                            }
+                            if (e.message.includes("VTXO_ALREADY_REGISTERED") ||
+                                e.message.includes("duplicated input")) {
+                                // VTXO is already being used in a concurrent
+                                // user-initiated operation. Skip silently — the
+                                // wallet's tx lock serializes these, but the
+                                // renewal will retry on the next cycle.
+                                return;
+                            }
                         }
-                        if (e.message.includes("is below dust threshold")) {
-                            // Not an error, just below dust threshold.
-                            // As more VTXOs are received, the threshold will be raised.
-                            return;
-                        }
-                        if (e.message.includes("VTXO_ALREADY_REGISTERED") ||
-                            e.message.includes("duplicated input")) {
-                            // VTXO is already being used in a concurrent
-                            // user-initiated operation. Skip silently — the
-                            // wallet's tx lock serializes these, but the
-                            // renewal will retry on the next cycle.
-                            return;
-                        }
-                    }
-                    console.error("Error renewing VTXOs:", e);
-                });
+                        console.error("Error renewing VTXOs:", e);
+                    });
+                }
                 delegatorManager
                     ?.delegate(event.vtxos, destination)
                     .catch((e) => {
@@ -606,7 +631,7 @@ class VtxoManager {
         this.pollBoardingUtxos();
     }
     schedulePoll() {
-        if (this.settlementConfig === false)
+        if (this.disposed || this.settlementConfig === false)
             return;
         const delay = this.getNextPollDelay();
         this.pollTimeoutId = setTimeout(() => this.pollBoardingUtxos(), delay);
@@ -680,8 +705,8 @@ class VtxoManager {
             const expired = boardingUtxos.filter((utxo) => (0, arkTransaction_1.hasBoardingTxExpired)(utxo, boardingTimelock, chainTipHeight));
             expiredSet = new Set(expired.map((u) => `${u.txid}:${u.vout}`));
         }
-        catch {
-            return;
+        catch (e) {
+            throw e instanceof Error ? e : new Error(String(e));
         }
         const unsettledUtxos = boardingUtxos.filter((u) => !this.knownBoardingUtxos.has(`${u.txid}:${u.vout}`) &&
             !expiredSet.has(`${u.txid}:${u.vout}`));
@@ -703,6 +728,11 @@ class VtxoManager {
     }
     async dispose() {
         this.disposePromise ?? (this.disposePromise = (async () => {
+            this.disposed = true;
+            if (this.startupPollTimeoutId) {
+                clearTimeout(this.startupPollTimeoutId);
+                this.startupPollTimeoutId = undefined;
+            }
             if (this.pollTimeoutId) {
                 clearTimeout(this.pollTimeoutId);
                 this.pollTimeoutId = undefined;
@@ -719,3 +749,4 @@ class VtxoManager {
 }
 exports.VtxoManager = VtxoManager;
 VtxoManager.MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minutes
+VtxoManager.RENEWAL_COOLDOWN_MS = 30000; // 30 seconds

package/dist/cjs/wallet/wallet.js

@@ -278,27 +278,33 @@ class ReadonlyWallet {
         const scriptMap = await this.getScriptMap();
         const f = filter ?? { withRecoverable: true, withUnrolled: false };
         const allExtended = [];
-        // Query each script separately so we can extend VTXOs with the correct tapscript
-        for (const [scriptHex, vtxoScript] of scriptMap) {
-            const response = await this.indexerProvider.getVtxos({
-                scripts: [scriptHex],
-            });
-            let vtxos = response.vtxos.filter(_1.isSpendable);
-            if (!f.withRecoverable) {
-                vtxos = vtxos.filter((vtxo) => !(0, _1.isRecoverable)(vtxo) && !(0, _1.isExpired)(vtxo));
-            }
-            if (f.withUnrolled) {
-                const spentVtxos = response.vtxos.filter((vtxo) => !(0, _1.isSpendable)(vtxo));
-                vtxos.push(...spentVtxos.filter((vtxo) => vtxo.isUnrolled));
+        // Batch all scripts into a single indexer call
+        const allScripts = [...scriptMap.keys()];
+        const response = await this.indexerProvider.getVtxos({
+            scripts: allScripts,
+        });
+        for (const vtxo of response.vtxos) {
+            const vtxoScript = vtxo.script
+                ? scriptMap.get(vtxo.script)
+                : undefined;
+            if (!vtxoScript)
+                continue;
+            if ((0, _1.isSpendable)(vtxo)) {
+                if (!f.withRecoverable &&
+                    ((0, _1.isRecoverable)(vtxo) || (0, _1.isExpired)(vtxo))) {
+                    continue;
+                }
             }
-            for (const vtxo of vtxos) {
-                allExtended.push({
-                    ...vtxo,
-                    forfeitTapLeafScript: vtxoScript.forfeit(),
-                    intentTapLeafScript: vtxoScript.forfeit(),
-                    tapTree: vtxoScript.encode(),
-                });
+            else {
+                if (!f.withUnrolled || !vtxo.isUnrolled)
+                    continue;
             }
+            allExtended.push({
+                ...vtxo,
+                forfeitTapLeafScript: vtxoScript.forfeit(),
+                intentTapLeafScript: vtxoScript.forfeit(),
+                tapTree: vtxoScript.encode(),
+            });
         }
         // Update cache with fresh data
         await this.walletRepository.saveVtxos(address, allExtended);
@@ -310,7 +316,7 @@ class ReadonlyWallet {
         const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
         const getTxCreatedAt = (txid) => this.indexerProvider
             .getVtxos({ outpoints: [{ txid, vout: 0 }] })
-            .then((res) => res.vtxos[0]?.createdAt.getTime() || 0);
+            .then((res) => res.vtxos[0]?.createdAt.getTime());
         return (0, transactionHistory_1.buildTransactionHistory)(response.vtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
     }
     async getBoardingTxs() {
@@ -1344,23 +1350,29 @@ class Wallet extends ReadonlyWallet {
     async finalizePendingTxs(vtxos) {
         const MAX_INPUTS_PER_INTENT = 20;
         if (!vtxos || vtxos.length === 0) {
-            // Query per-script so each VTXO is extended with the correct tapscript
+            // Batch all scripts into a single indexer call
             const scriptMap = await this.getScriptMap();
             const allExtended = [];
-            for (const [scriptHex, vtxoScript] of scriptMap) {
-                const { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
-                    scripts: [scriptHex],
-                });
-                const pending = fetchedVtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
-                    vtxo.virtualStatus.state !== "settled");
-                for (const vtxo of pending) {
-                    allExtended.push({
-                        ...vtxo,
-                        forfeitTapLeafScript: vtxoScript.forfeit(),
-                        intentTapLeafScript: vtxoScript.forfeit(),
-                        tapTree: vtxoScript.encode(),
-                    });
+            const allScripts = [...scriptMap.keys()];
+            const { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
+                scripts: allScripts,
+            });
+            for (const vtxo of fetchedVtxos) {
+                const vtxoScript = vtxo.script
+                    ? scriptMap.get(vtxo.script)
+                    : undefined;
+                if (!vtxoScript)
+                    continue;
+                if (vtxo.virtualStatus.state === "swept" ||
+                    vtxo.virtualStatus.state === "settled") {
+                    continue;
                 }
+                allExtended.push({
+                    ...vtxo,
+                    forfeitTapLeafScript: vtxoScript.forfeit(),
+                    intentTapLeafScript: vtxoScript.forfeit(),
+                    tapTree: vtxoScript.encode(),
+                });
             }
             if (allExtended.length === 0) {
                 return { finalized: [], pending: [] };

package/dist/cjs/worker/errors.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceWorkerTimeoutError = exports.MessageBusNotInitializedError = void 0;
+exports.ServiceWorkerTimeoutError = exports.MessageBusNotInitializedError = exports.MESSAGE_BUS_NOT_INITIALIZED = void 0;
+exports.MESSAGE_BUS_NOT_INITIALIZED = "MessageBus not initialized";
 class MessageBusNotInitializedError extends Error {
     constructor() {
-        super("MessageBus not initialized");
-        this.name = "MessageBusNotInitializedError";
+        super(exports.MESSAGE_BUS_NOT_INITIALIZED);
     }
 }
 exports.MessageBusNotInitializedError = MessageBusNotInitializedError;
 class ServiceWorkerTimeoutError extends Error {
     constructor(detail) {
         super(detail);
-        this.name = "ServiceWorkerTimeoutError";
     }
 }
 exports.ServiceWorkerTimeoutError = ServiceWorkerTimeoutError;

package/dist/cjs/worker/messageBus.js

@@ -152,8 +152,12 @@ class MessageBus {
                 identity,
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
+                indexerUrl: config.indexerUrl,
+                esploraUrl: config.esploraUrl,
                 storage,
                 delegatorProvider,
+                settlementConfig: config.settlementConfig,
+                watcherConfig: config.watcherConfig,
             });
             return { wallet, arkProvider, readonlyWallet: wallet };
         }
@@ -163,8 +167,11 @@ class MessageBus {
                 identity,
                 arkServerUrl: config.arkServer.url,
                 arkServerPublicKey: config.arkServer.publicKey,
+                indexerUrl: config.indexerUrl,
+                esploraUrl: config.esploraUrl,
                 storage,
                 delegatorProvider,
+                watcherConfig: config.watcherConfig,
             });
             return { readonlyWallet, arkProvider };
         }

package/dist/esm/contracts/contractManager.js

@@ -71,9 +71,10 @@ export class ContractManager {
         }
         // Load persisted contracts
         const contracts = await this.config.contractRepository.getContracts();
-        // fetch latest VTXOs for all contracts, ensure cache is up to date
+        // fetch all VTXOs (including spent/swept) for all contracts,
+        // so the repository has full history for transaction history and balance
         // TODO: what if the user has 1k contracts?
-        await this.getVtxosForContracts(contracts);
+        await this.fetchContractVxosFromIndexer(contracts, true);
         // add all contracts to the watcher
         const now = Date.now();
         for (const contract of contracts) {
@@ -136,8 +137,8 @@ export class ContractManager {
         };
         // Persist
         await this.config.contractRepository.saveContract(contract);
-        // ensure we have the latest VTXOs for this contract
-        await this.getVtxosForContracts([contract]);
+        // fetch all VTXOs (including spent/swept) for this contract
+        await this.fetchContractVxosFromIndexer([contract], true);
         // Add to watcher
         await this.watcher.addContract(contract);
         return contract;
@@ -302,6 +303,14 @@ export class ContractManager {
             this.eventCallbacks.delete(callback);
         };
     }
+    /**
+     * Force a full VTXO refresh from the indexer for all contracts.
+     * Populates the wallet repository with complete VTXO history.
+     */
+    async refreshVtxos() {
+        const contracts = await this.config.contractRepository.getContracts();
+        await this.fetchContractVxosFromIndexer(contracts, true);
+    }
     /**
      * Check if currently watching.
      */
@@ -331,11 +340,13 @@ export class ContractManager {
             case "vtxo_spent":
                 await this.fetchContractVxosFromIndexer([event.contract], true);
                 break;
-            case "connection_reset":
-                // Refetch all VTXOs for all active contracts
+            case "connection_reset": {
+                // Refetch all VTXOs (including spent/swept) for all active
+                // contracts so the repo stays consistent with bootstrap state
                 const activeWatchedContracts = this.watcher.getActiveContracts();
-                await this.fetchContractVxosFromIndexer(activeWatchedContracts, false);
+                await this.fetchContractVxosFromIndexer(activeWatchedContracts, true);
                 break;
+            }
             case "contract_expired":
                 // just update DB
                 await this.config.contractRepository.saveContract(event.contract);
@@ -362,11 +373,48 @@ export class ContractManager {
         return result;
     }
     async fetchContractVtxosBulk(contracts, includeSpent) {
-        const result = new Map();
-        await Promise.all(contracts.map(async (contract) => {
+        if (contracts.length === 0) {
+            return new Map();
+        }
+        // For a single contract, use the paginated path directly.
+        if (contracts.length === 1) {
+            const contract = contracts[0];
             const vtxos = await this.fetchContractVtxosPaginated(contract, includeSpent);
-            result.set(contract.script, vtxos);
-        }));
+            return new Map([[contract.script, vtxos]]);
+        }
+        // For multiple contracts, batch all scripts into a single indexer call
+        // per page to minimise round-trips.  Results are keyed by script so we
+        // can distribute them back to the correct contract afterwards.
+        const scriptToContract = new Map(contracts.map((c) => [c.script, c]));
+        const result = new Map(contracts.map((c) => [c.script, []]));
+        const scripts = contracts.map((c) => c.script);
+        const pageSize = 100;
+        const opts = includeSpent ? {} : { spendableOnly: true };
+        let pageIndex = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const { vtxos, page } = await this.config.indexerProvider.getVtxos({
+                scripts,
+                ...opts,
+                pageIndex,
+                pageSize,
+            });
+            for (const vtxo of vtxos) {
+                // Match the VTXO back to its contract via the script field
+                // populated by the indexer.
+                if (!vtxo.script)
+                    continue;
+                const contract = scriptToContract.get(vtxo.script);
+                if (!contract)
+                    continue;
+                result.get(contract.script).push({
+                    ...extendVtxoFromContract(vtxo, contract),
+                    contractScript: contract.script,
+                });
+            }
+            hasMore = page ? vtxos.length === pageSize : false;
+            pageIndex++;
+        }
         return result;
     }
     async fetchContractVtxosPaginated(contract, includeSpent) {

package/dist/esm/contracts/contractWatcher.js

@@ -410,8 +410,27 @@ export class ContractWatcher {
             }
             return;
         }
-        this.subscriptionId =
-            await this.config.indexerProvider.subscribeForScripts(scriptsToWatch, this.subscriptionId);
+        try {
+            this.subscriptionId =
+                await this.config.indexerProvider.subscribeForScripts(scriptsToWatch, this.subscriptionId);
+        }
+        catch (error) {
+            // If we sent a stale subscription ID that the server no longer
+            // recognises, clear it and retry to create a fresh subscription.
+            // The server currently returns HTTP 500 with a JSON body whose
+            // message field looks like "subscription <uuid> not found".
+            // All other errors (network failures, parse errors, etc.) are rethrown.
+            const isStale = error instanceof Error &&
+                /subscription\s+\S+\s+not\s+found/i.test(error.message);
+            if (this.subscriptionId && isStale) {
+                this.subscriptionId = undefined;
+                this.subscriptionId =
+                    await this.config.indexerProvider.subscribeForScripts(scriptsToWatch);
+            }
+            else {
+                throw error;
+            }
+        }
     }
     /**
      * Main listening loop for subscription events.

package/dist/esm/index.js

@@ -40,7 +40,7 @@ export * as asset from './extension/asset/index.js';
 import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from './contracts/index.js';
 import { closeDatabase, openDatabase } from './repositories/indexedDB/manager.js';
 import { WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, } from './wallet/serviceWorker/wallet-message-handler.js';
-import { MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from './worker/errors.js';
+import { MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from './worker/errors.js';
 export { 
 // Wallets
 Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, 
@@ -51,7 +51,7 @@ ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC,
 // Enums
 TxType, IndexerTxType, ChainTxType, SettlementEventType, 
 // Service Worker
-setupServiceWorker, MessageBus, WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, MessageBusNotInitializedError, ServiceWorkerTimeoutError, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, 
+setupServiceWorker, MessageBus, WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, 
 // Tapscript
 decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, 
 // Ark PSBT fields

package/dist/esm/providers/expoIndexer.js

@@ -28,6 +28,7 @@ function convertVtxo(vtxo) {
         createdAt: new Date(Number(vtxo.createdAt) * 1000),
         isUnrolled: vtxo.isUnrolled,
         isSpent: vtxo.isSpent,
+        script: vtxo.script,
         assets: vtxo.assets?.map((a) => ({
             assetId: a.assetId,
             amount: Number(a.amount),

package/dist/esm/providers/indexer.js

@@ -402,6 +402,7 @@ function convertVtxo(vtxo) {
         createdAt: new Date(Number(vtxo.createdAt) * 1000),
         isUnrolled: vtxo.isUnrolled,
         isSpent: vtxo.isSpent,
+        script: vtxo.script,
         assets: vtxo.assets?.map((a) => ({
             assetId: a.assetId,
             amount: Number(a.amount),

package/dist/esm/utils/arkTransaction.js

@@ -8,6 +8,7 @@ import { P2A } from './anchor.js';
 import { setArkPsbtField, VtxoTaprootTree } from './unknownFields.js';
 import { Transaction } from './transaction.js';
 import { ArkAddress } from '../script/address.js';
+import { Extension } from '../extension/index.js';
 /**
  * Builds an offchain transaction with checkpoint transactions.
  *
@@ -21,16 +22,26 @@ import { ArkAddress } from '../script/address.js';
  * @returns Object containing the virtual transaction and checkpoint transactions
  */
 export function buildOffchainTx(inputs, outputs, serverUnrollScript) {
-    let hasOpReturn = false;
+    // TODO: use arkd /info
+    const MAX_OP_RETURN = 2;
+    let countOpReturn = 0;
+    let hasExtensionOutput = false;
     for (const [index, output] of outputs.entries()) {
         if (!output.script)
             throw new Error(`missing output script ${index}`);
-        const isOpReturn = Script.decode(output.script)[0] === "RETURN";
-        if (!isOpReturn)
+        const isExtension = Extension.isExtension(output.script);
+        const isOpReturn = isExtension || Script.decode(output.script)[0] === "RETURN";
+        if (isOpReturn) {
+            countOpReturn++;
+        }
+        if (!isExtension)
             continue;
-        if (hasOpReturn)
-            throw new Error("multiple OP_RETURN outputs");
-        hasOpReturn = true;
+        if (hasExtensionOutput)
+            throw new Error("multiple extension outputs");
+        hasExtensionOutput = true;
+    }
+    if (countOpReturn > MAX_OP_RETURN) {
+        throw new Error(`too many OP_RETURN outputs: ${countOpReturn} > ${MAX_OP_RETURN}`);
     }
     const checkpoints = inputs.map((input) => buildCheckpointTx(input, serverUnrollScript));
     const arkTx = buildVirtualTx(checkpoints.map((c) => c.input), outputs);

package/dist/esm/utils/transactionHistory.js

@@ -115,7 +115,8 @@ export async function buildTransactionHistory(vtxos, allBoardingTxs, commitments
                     txAmount = spentAmount;
                     // TODO: fetch the vtxo with /v1/indexer/vtxos?outpoints=<vtxo.arkTxid:0> to know when the tx was made
                     txTime = getTxCreatedAt
-                        ? await getTxCreatedAt(vtxo.arkTxId)
+                        ? ((await getTxCreatedAt(vtxo.arkTxId)) ??
+                            vtxo.createdAt.getTime() + 1)
                         : vtxo.createdAt.getTime() + 1;
                 }
                 const assets = subtractAssets(allSpent, changes);