@arkade-os/sdk 0.4.24 → 0.4.25

package/dist/cjs/wallet/wallet.js

@@ -1873,7 +1873,6 @@ class Wallet extends ReadonlyWallet {
                 arr.push(v);
                 spentByScript.set(v.script, arr);
             }
-            const byAddress = new Map();
             for (const [script, vtxos] of spentByScript) {
                 // User-initiated send path: a wrong-script row here means the
                 // wallet is about to record ownership against the wrong
@@ -1883,18 +1882,11 @@ class Wallet extends ReadonlyWallet {
                 if (!targetAddr) {
                     throw new Error(`Wallet.updateDbAfterOffchainTx: no contract owns script ${script}`);
                 }
-                const bucket = byAddress.get(targetAddr) ?? [];
-                bucket.push(...vtxos);
-                byAddress.set(targetAddr, bucket);
+                await (0, vtxoOwnership_1.saveVtxosForContract)(this.walletRepository, { script, address: targetAddr }, vtxos);
             }
             // Change is always primary-script by construction.
             if (changeVtxo) {
-                const bucket = byAddress.get(primaryAddr) ?? [];
-                bucket.push(changeVtxo);
-                byAddress.set(primaryAddr, bucket);
-            }
-            for (const [addr, vtxos] of byAddress) {
-                await this.walletRepository.saveVtxos(addr, vtxos);
+                await (0, vtxoOwnership_1.saveVtxosForContract)(this.walletRepository, { script: changeVtxo.script, address: primaryAddr }, [changeVtxo]);
             }
             await this.walletRepository.saveTransactions(primaryAddr, [
                 {
@@ -1957,7 +1949,6 @@ class Wallet extends ReadonlyWallet {
                 // alongside the rest.
                 const contracts = await cm.getContracts();
                 const addrByScript = new Map(contracts.map((c) => [c.script, c.address]));
-                const byAddress = new Map();
                 const byScript = new Map();
                 for (const v of spentVtxos) {
                     if (!v.script) {
@@ -1975,12 +1966,7 @@ class Wallet extends ReadonlyWallet {
                     if (!targetAddr) {
                         throw new Error(`Wallet.updateDbAfterSettle: no contract owns script ${script}`);
                     }
-                    const bucket = byAddress.get(targetAddr) ?? [];
-                    bucket.push(...vtxos);
-                    byAddress.set(targetAddr, bucket);
-                }
-                for (const [bucketAddr, vtxos] of byAddress) {
-                    await this.walletRepository.saveVtxos(bucketAddr, vtxos);
+                    await (0, vtxoOwnership_1.saveVtxosForContract)(this.walletRepository, { script, address: targetAddr }, vtxos);
                 }
             }
             if (boardingUtxoToRemove.size > 0) {

package/dist/cjs/worker/expo/processors/contractPollProcessor.js

@@ -48,7 +48,7 @@ exports.contractPollProcessor = {
             // before persisting; the loop must keep going for the remaining
             // contracts even when one row is rejected.
             const filtered = (0, vtxoOwnership_1.warnAndFilterVtxosForScript)(allVtxos, contract.script, "contractPollProcessor");
-            await walletRepository.saveVtxos(contract.address, filtered);
+            await (0, vtxoOwnership_1.saveVtxosForContract)(walletRepository, contract, filtered);
             vtxosSaved += filtered.length;
             contractsProcessed++;
         }

package/dist/esm/contracts/contractManager.js

@@ -3,7 +3,7 @@ import { ContractWatcher } from './contractWatcher.js';
 import { contractHandlers } from './handlers/index.js';
 import { extendVirtualCoinForContract } from '../wallet/utils.js';
 import { advanceSyncCursor, computeSyncWindow, cursorCutoff, getSyncCursor, } from '../utils/syncCursors.js';
-import { filterVtxosForScript, warnAndFilterVtxosForScript, } from './vtxoOwnership.js';
+import { getVtxosForContract, saveVtxosForContract, warnAndFilterVtxosForScript, } from './vtxoOwnership.js';
 const DEFAULT_PAGE_SIZE = 500;
 /**
  * Central manager for contract lifecycle and operations.
@@ -370,6 +370,46 @@ export class ContractManager {
                 : undefined,
         });
     }
+    async refreshOutpoints(outpoints) {
+        if (outpoints.length === 0)
+            return;
+        const { vtxos } = await this.config.indexerProvider.getVtxos({
+            outpoints,
+        });
+        if (vtxos.length === 0)
+            return;
+        // Filter to outputs whose script we own. Map them to their owning
+        // contract so we can write through to the right per-address entry
+        // in the wallet repository.
+        const scripts = Array.from(new Set(vtxos.map((v) => v.script)));
+        const contracts = await this.config.contractRepository.getContracts({
+            script: scripts,
+        });
+        const scriptToContract = new Map(contracts.map((c) => [c.script, c]));
+        const owned = vtxos.filter((v) => scriptToContract.has(v.script));
+        if (owned.length === 0)
+            return;
+        const annotated = await this.annotateVtxos(owned);
+        const byAddress = new Map();
+        for (const vtxo of annotated) {
+            const contract = scriptToContract.get(vtxo.script);
+            if (!contract)
+                continue;
+            const address = contract.address;
+            const arr = byAddress.get(address) ?? [];
+            arr.push(vtxo);
+            byAddress.set(address, arr);
+        }
+        for (const [address, addressVtxos] of byAddress) {
+            const contract = contracts.find((c) => c.address === address);
+            if (contract) {
+                await saveVtxosForContract(this.config.walletRepository, contract, addressVtxos);
+            }
+            else {
+                await this.config.walletRepository.saveVtxos(address, addressVtxos);
+            }
+        }
+    }
     /**
      * Check if currently watching.
      */
@@ -410,13 +450,9 @@ export class ContractManager {
         this.emitEvent(event);
     }
     async getVtxosForContracts(contracts) {
-        const res = await Promise.all(contracts.map(({ script, address }) => this.config.walletRepository.getVtxos(address).then((vtxos) => 
-        // Address buckets may carry legacy duplicate rows from
-        // other contracts that once shared the same address —
-        // gate by script so the wrong-script row never wins.
-        filterVtxosForScript(vtxos, script).map((vtxo) => ({
+        const res = await Promise.all(contracts.map((contract) => getVtxosForContract(this.config.walletRepository, contract).then((vtxos) => vtxos.map((vtxo) => ({
             ...vtxo,
-            contractScript: script,
+            contractScript: contract.script,
         })))));
         return res.flat();
     }
@@ -489,7 +525,7 @@ export class ContractManager {
             const filtered = warnAndFilterVtxosForScript(contractVtxos, contract.script, "ContractManager.reconcilePendingFrontier");
             if (filtered.length === 0)
                 continue;
-            await this.config.walletRepository.saveVtxos(addr, filtered);
+            await saveVtxosForContract(this.config.walletRepository, contract, filtered);
         }
     }
     async fetchContractVxosFromIndexer(contracts, pageSize, syncWindow) {
@@ -502,7 +538,7 @@ export class ContractManager {
                 const filtered = warnAndFilterVtxosForScript(vtxos, contract.script, "ContractManager.fetchContractVxosFromIndexer");
                 if (filtered.length === 0)
                     continue;
-                await this.config.walletRepository.saveVtxos(contract.address, filtered);
+                await saveVtxosForContract(this.config.walletRepository, contract, filtered);
             }
         }
         return result;

package/dist/esm/contracts/contractWatcher.js

@@ -1,6 +1,6 @@
 import { extendVirtualCoinForContract } from '../wallet/utils.js';
 import { isEventSourceError } from '../providers/utils.js';
-import { filterVtxosForScript } from './vtxoOwnership.js';
+import { getVtxosForContract } from './vtxoOwnership.js';
 /**
  * Watches multiple contracts for virtual output state changes with resilient connection handling.
  *
@@ -91,7 +91,7 @@ export class ContractWatcher {
             // Apply the same script gate used by getContractVtxos so a legacy
             // wrong-script row in the address bucket can't seed the baseline
             // and then look "spent" on the first poll.
-            const cached = filterVtxosForScript(await this.config.walletRepository.getVtxos(state.contract.address), state.contract.script);
+            const cached = await getVtxosForContract(this.config.walletRepository, state.contract);
             for (const vtxo of cached) {
                 if (vtxo.isSpent)
                     continue;
@@ -173,7 +173,7 @@ export class ContractWatcher {
             // Use contract address as cache key. Legacy address buckets
             // can contain rows from other contracts; gate by script before
             // converting so a wrong-script row never reaches the watcher.
-            const cached = filterVtxosForScript(await repo.getVtxos(state.contract.address), state.contract.script);
+            const cached = await getVtxosForContract(repo, state.contract);
             if (cached.length > 0) {
                 // Convert to ContractVtxo with contractScript
                 const contractVtxos = cached.map((v) => ({

package/dist/esm/contracts/vtxoOwnership.js

@@ -51,3 +51,19 @@ export function validateVtxosForScript(vtxos, script, context) {
         .join(", ");
     throw new Error(`${context}: refusing to persist ${mismatches.length} VTXO(s) whose script does not match ${script}: ${detail}`);
 }
+/**
+ * Tier 2 dispatch helpers: route to script-scoped repository methods when
+ * available, falling back to Tier 1 address-based filtering otherwise.
+ */
+export async function getVtxosForContract(repo, contract) {
+    return repo.getVtxosForScript
+        ? repo.getVtxosForScript(contract.script)
+        : filterVtxosForScript(await repo.getVtxos(contract.address), contract.script);
+}
+export async function saveVtxosForContract(repo, contract, vtxos) {
+    if (repo.saveVtxosForScript) {
+        return repo.saveVtxosForScript({ script: contract.script, address: contract.address }, vtxos);
+    }
+    validateVtxosForScript(vtxos, contract.script, "saveVtxosForContract");
+    return repo.saveVtxos(contract.address, vtxos);
+}

package/dist/esm/repositories/inMemory/walletRepository.js

@@ -1,3 +1,4 @@
+import { isVtxoForScript } from '../../contracts/vtxoOwnership.js';
 /**
  * In-memory implementation of WalletRepository.
  * Data is ephemeral and scoped to the instance.
@@ -21,6 +22,40 @@ export class InMemoryWalletRepository {
     async deleteVtxos(address) {
         this.vtxosByAddress.delete(address);
     }
+    async getVtxosForScript(script) {
+        const allMatches = [];
+        for (const bucket of this.vtxosByAddress.values()) {
+            for (const vtxo of bucket) {
+                if (isVtxoForScript(vtxo, script)) {
+                    allMatches.push(vtxo);
+                }
+            }
+        }
+        // Dedup by outpoint (last-write-wins across address buckets)
+        return mergeByKey([], allMatches, (item) => `${item.txid}:${item.vout}`);
+    }
+    async saveVtxosForScript(key, vtxos) {
+        if (!key.address) {
+            throw new Error("InMemoryWalletRepository requires an address");
+        }
+        for (const vtxo of vtxos) {
+            if (!isVtxoForScript(vtxo, key.script)) {
+                throw new Error(`VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`);
+            }
+        }
+        return this.saveVtxos(key.address, vtxos);
+    }
+    async deleteVtxosForScript(script) {
+        for (const [address, bucket] of this.vtxosByAddress.entries()) {
+            const next = bucket.filter((v) => !isVtxoForScript(v, script));
+            if (next.length === 0) {
+                this.vtxosByAddress.delete(address);
+            }
+            else {
+                this.vtxosByAddress.set(address, next);
+            }
+        }
+    }
     async getUtxos(address) {
         return this.utxosByAddress.get(address) ?? [];
     }

package/dist/esm/repositories/indexedDB/walletRepository.js

@@ -3,6 +3,7 @@ import { closeDatabase, openDatabase } from './manager.js';
 import { initDatabase } from './schema.js';
 import { scriptFromArkAddress } from '../scriptFromAddress.js';
 import { DEFAULT_DB_NAME } from '../../worker/browser/utils.js';
+import { isVtxoForScript } from '../../contracts/vtxoOwnership.js';
 /**
  * IndexedDB-based implementation of WalletRepository.
  */
@@ -141,6 +142,85 @@ export class IndexedDBWalletRepository {
             throw error;
         }
     }
+    async getVtxosForScript(script) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_VTXOS], "readonly");
+                const store = transaction.objectStore(STORE_VTXOS);
+                const index = store.index("script");
+                const request = index.getAll(script);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const results = request.result || [];
+                    try {
+                        // Defensive filter: only rows whose script matches.
+                        const matching = results.filter((r) => r.script === script);
+                        // Dedup same outpoint rows across address buckets.
+                        // Work on raw rows so the address field is available
+                        // for the canonicality tiebreaker.
+                        const byOutpoint = new Map();
+                        for (const row of matching) {
+                            const outpoint = `${row.txid}:${row.vout}`;
+                            const existing = byOutpoint.get(outpoint);
+                            if (!existing) {
+                                byOutpoint.set(outpoint, row);
+                                continue;
+                            }
+                            if (shouldReplaceVtxo(existing, row)) {
+                                byOutpoint.set(outpoint, row);
+                            }
+                        }
+                        resolve(Array.from(byOutpoint.values()).map(deserializeVtxoWithBackfill));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to get VTXOs for script ${script}:`, error);
+            throw error;
+        }
+    }
+    async saveVtxosForScript(key, vtxos) {
+        if (!key.address) {
+            throw new Error("IndexedDBWalletRepository requires an address");
+        }
+        for (const vtxo of vtxos) {
+            if (!isVtxoForScript(vtxo, key.script)) {
+                throw new Error(`VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`);
+            }
+        }
+        return this.saveVtxos(key.address, vtxos);
+    }
+    async deleteVtxosForScript(script) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([STORE_VTXOS], "readwrite");
+                const store = transaction.objectStore(STORE_VTXOS);
+                const index = store.index("script");
+                const request = index.openCursor(IDBKeyRange.only(script));
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        cursor.delete();
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to clear VTXOs for script ${script}:`, error);
+            throw error;
+        }
+    }
     async getUtxos(address) {
         try {
             const db = await this.getDB();
@@ -351,3 +431,40 @@ function deserializeVtxoWithBackfill(o) {
     }
     return deserializeVtxo(o);
 }
+function isCanonicalRow(row) {
+    try {
+        return scriptFromArkAddress(row.address) === row.script;
+    }
+    catch {
+        return false;
+    }
+}
+function shouldReplaceVtxo(existing, incoming) {
+    const existingCanonical = isCanonicalRow(existing);
+    const incomingCanonical = isCanonicalRow(incoming);
+    if (incomingCanonical && !existingCanonical)
+        return true;
+    if (existingCanonical && !incomingCanonical)
+        return false;
+    // Tie on canonicality, check lifecycle completeness
+    const existingWeight = getLifecycleWeight(existing);
+    const incomingWeight = getLifecycleWeight(incoming);
+    if (incomingWeight > existingWeight)
+        return true;
+    if (existingWeight > incomingWeight)
+        return false;
+    // Tie on weight, stable sort by address
+    return incoming.address < existing.address;
+}
+function getLifecycleWeight(v) {
+    let weight = 0;
+    if (v.isSpent !== undefined)
+        weight += 1;
+    if (v.spentBy)
+        weight += 2;
+    if (v.settledBy)
+        weight += 2;
+    if (v.arkTxId)
+        weight += 2;
+    return weight;
+}

package/dist/esm/repositories/realm/walletRepository.js

@@ -1,5 +1,6 @@
 import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, serializeAssets, deserializeAssets, } from '../serialization.js';
 import { scriptFromArkAddress } from '../scriptFromAddress.js';
+import { isVtxoForScript } from '../../contracts/vtxoOwnership.js';
 /**
  * Realm-based implementation of WalletRepository.
  *
@@ -85,6 +86,33 @@ export class RealmWalletRepository {
             this.realm.delete(toDelete);
         });
     }
+    async getVtxosForScript(script) {
+        await this.ensureInit();
+        const results = this.realm
+            .objects("ArkVtxo")
+            .filtered("script == $0", script);
+        return [...results].map(vtxoObjectToDomain);
+    }
+    async saveVtxosForScript(key, vtxos) {
+        if (!key.address) {
+            throw new Error("RealmWalletRepository requires an address");
+        }
+        for (const vtxo of vtxos) {
+            if (!isVtxoForScript(vtxo, key.script)) {
+                throw new Error(`VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`);
+            }
+        }
+        return this.saveVtxos(key.address, vtxos);
+    }
+    async deleteVtxosForScript(script) {
+        await this.ensureInit();
+        this.realm.write(() => {
+            const toDelete = this.realm
+                .objects("ArkVtxo")
+                .filtered("script == $0", script);
+            this.realm.delete(toDelete);
+        });
+    }
     // ── UTXO management ────────────────────────────────────────────────
     async getUtxos(address) {
         await this.ensureInit();

package/dist/esm/repositories/sqlite/walletRepository.js

@@ -1,5 +1,6 @@
 import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, serializeAssets, deserializeAssets, } from '../serialization.js';
 import { scriptFromArkAddress } from '../scriptFromAddress.js';
+import { isVtxoForScript } from '../../contracts/vtxoOwnership.js';
 /**
  * SQLite-based implementation of WalletRepository.
  *
@@ -242,6 +243,28 @@ export class SQLiteWalletRepository {
         await this.ensureInit();
         await this.db.run(`DELETE FROM ${this.tables.vtxos} WHERE address = ?`, [address]);
     }
+    async getVtxosForScript(script) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.vtxos} WHERE script = ?`, [script]);
+        return rows.map(vtxoRowToDomain);
+    }
+    async saveVtxosForScript(key, vtxos) {
+        if (!key.address) {
+            throw new Error("SQLiteWalletRepository requires an address");
+        }
+        for (const vtxo of vtxos) {
+            if (!isVtxoForScript(vtxo, key.script)) {
+                throw new Error(`VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`);
+            }
+        }
+        return this.saveVtxos(key.address, vtxos);
+    }
+    async deleteVtxosForScript(script) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.vtxos} WHERE script = ?`, [
+            script,
+        ]);
+    }
     // ── UTXO management ────────────────────────────────────────────────
     async getUtxos(address) {
         await this.ensureInit();

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -2,7 +2,7 @@ import { RestIndexerProvider } from '../../providers/indexer.js';
 import { isExpired, isRecoverable, isSpendable, isSubdust, } from '../index.js';
 import { extendCoin } from '../utils.js';
 import { buildTransactionHistory } from '../../utils/transactionHistory.js';
-import { filterVtxosForScript, warnAndFilterVtxosForScript, } from '../../contracts/vtxoOwnership.js';
+import { filterVtxosForScript, getVtxosForContract, saveVtxosForContract, warnAndFilterVtxosForScript, } from '../../contracts/vtxoOwnership.js';
 import { scriptFromArkAddress } from '../../repositories/scriptFromAddress.js';
 export class WalletNotInitializedError extends Error {
     constructor() {
@@ -313,6 +313,16 @@ export class WalletMessageHandler {
                         type: "REFRESH_VTXOS_SUCCESS",
                     });
                 }
+                case "REFRESH_OUTPOINTS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const { outpoints } = message
+                        .payload;
+                    await manager.refreshOutpoints(outpoints);
+                    return this.tagged({
+                        id,
+                        type: "REFRESH_OUTPOINTS_SUCCESS",
+                    });
+                }
                 case "SEND": {
                     const { recipients } = message.payload;
                     const txid = await this.wallet.send(...recipients);
@@ -620,7 +630,9 @@ export class WalletMessageHandler {
                             : addrByScript.get(script);
                         if (!targetAddress)
                             continue;
-                        await this.walletRepository?.saveVtxos(targetAddress, filtered);
+                        if (this.walletRepository) {
+                            await saveVtxosForContract(this.walletRepository, { script, address: targetAddress }, filtered);
+                        }
                     }
                     // notify all clients about the virtual output state update
                     this.scheduleForNextTick(() => this.tagged({
@@ -840,8 +852,7 @@ export class WalletMessageHandler {
         const manager = await this.readonlyWallet.getContractManager();
         const contracts = await manager.getContracts();
         for (const contract of contracts) {
-            const vtxos = await this.walletRepository.getVtxos(contract.address);
-            addVtxos(filterVtxosForScript(vtxos, contract.script));
+            addVtxos(await getVtxosForContract(this.walletRepository, contract));
         }
         // Also check the wallet's primary address. Decode it to its script
         // and apply the same script gate. Failing to decode the wallet's own

package/dist/esm/wallet/serviceWorker/wallet.js

@@ -57,6 +57,7 @@ export const DEFAULT_MESSAGE_TIMEOUTS = {
     UPDATE_CONTRACT: 30000,
     DELETE_CONTRACT: 10000,
     REFRESH_VTXOS: 30000,
+    REFRESH_OUTPOINTS: 30000,
 };
 const DEDUPABLE_REQUEST_TYPES = new Set([
     "GET_ADDRESS",
@@ -821,6 +822,15 @@ export class ServiceWorkerReadonlyWallet {
                 };
                 await sendContractMessage(message);
             },
+            async refreshOutpoints(outpoints) {
+                const message = {
+                    type: "REFRESH_OUTPOINTS",
+                    id: getRandomId(),
+                    tag: messageTag,
+                    payload: { outpoints },
+                };
+                await sendContractMessage(message);
+            },
             async isWatching() {
                 const message = {
                     type: "IS_CONTRACT_MANAGER_WATCHING",