@arkade-os/sdk 0.4.17 → 0.4.19

package/dist/esm/contracts/contractWatcher.js

@@ -62,6 +62,12 @@ export class ContractWatcher {
             lastKnownVtxos: new Map(),
         };
         this.contracts.set(contract.script, state);
+        // Seed the baseline from the repository BEFORE any poll or event
+        // emits. Without this, the first poll after (re)start treats every
+        // persisted vtxo as "new" and emits `vtxo_received` for each —
+        // which downstream triggers a redundant per-vtxo sync on every
+        // app launch and can confuse consumers that react to the event.
+        await this.seedLastKnownVtxos(state);
         // If we're already watching, poll to discover virtual outputs and update subscription
         if (this.isWatching) {
             // Poll first to discover virtual outputs (may affect whether we watch this contract).
@@ -70,6 +76,31 @@ export class ContractWatcher {
             await this.tryUpdateSubscription();
         }
     }
+    /**
+     * Pre-populate `lastKnownVtxos` from the wallet repository.
+     *
+     * Runs on add (and can be re-run after reconnect) so polling always
+     * compares the indexer's view against what is already persisted,
+     * emitting only genuine deltas.
+     */
+    async seedLastKnownVtxos(state) {
+        try {
+            const cached = await this.config.walletRepository.getVtxos(state.contract.address);
+            for (const vtxo of cached) {
+                if (vtxo.isSpent)
+                    continue;
+                const key = `${vtxo.txid}:${vtxo.vout}`;
+                state.lastKnownVtxos.set(key, vtxo);
+            }
+        }
+        catch (error) {
+            // Don't throw — the watcher can still recover via poll and
+            // subscription events. A failed seed just means the first poll
+            // may emit some redundant `vtxo_received` events for already
+            // known vtxos.
+            console.error(`ContractWatcher: failed to seed lastKnownVtxos for ${state.contract.script}`, error);
+        }
+    }
     /**
      * Update an existing contract.
      */
@@ -102,35 +133,20 @@ export class ContractWatcher {
         return Array.from(this.contracts.values()).map((s) => s.contract);
     }
     /**
-     * Get all active in-memory contracts.
-     */
-    getActiveContracts() {
-        return this.getAllContracts().filter((c) => c.state === "active");
-    }
-    /**
-     * Get scripts that should be watched.
+     * Contracts the watcher is actually tracking:
+     * - all active contracts, plus
+     * - inactive contracts that still hold known virtual outputs
+     *   (the subscription keeps watching them so `vtxo_spent` events for
+     *   those unspent outputs are still observed).
      *
-     * Returns scripts for:
-     * - All active contracts
-     * - All contracts with known virtual outputs (regardless of state)
-     *
-     * This ensures we continue monitoring contracts even after they're
-     * deactivated, as long as they have unspent virtual outputs.
+     * This is the single source of truth for "contracts whose VTXO state
+     * we still care about" — callers and the subscription itself fan out
+     * over the same set so nothing is reconciled that isn't also watched.
      */
-    getScriptsToWatch() {
-        const scripts = new Set();
-        for (const [, state] of this.contracts) {
-            // Always watch active contracts
-            if (state.contract.state === "active") {
-                scripts.add(state.contract.script);
-                continue;
-            }
-            // Also watch inactive/expired contracts that have virtual outputs.
-            if (state.lastKnownVtxos.size > 0) {
-                scripts.add(state.contract.script);
-            }
-        }
-        return Array.from(scripts);
+    getWatchedContracts() {
+        return Array.from(this.contracts.values())
+            .filter((s) => s.contract.state === "active" || s.lastKnownVtxos.size > 0)
+            .map((s) => s.contract);
     }
     /**
      * Get virtual outputs for contracts, grouped by contract script.
@@ -232,28 +248,6 @@ export class ContractWatcher {
             return;
         await this.pollAllContracts();
     }
-    /**
-     * Check for expired contracts, update their state, and emit events.
-     */
-    checkExpiredContracts() {
-        const now = Date.now();
-        const expired = [];
-        for (const state of this.contracts.values()) {
-            const contract = state.contract;
-            if (contract.state === "active" &&
-                contract.expiresAt &&
-                contract.expiresAt <= now) {
-                contract.state = "inactive";
-                expired.push(contract);
-                this.eventCallback?.({
-                    type: "contract_expired",
-                    contractScript: contract.script,
-                    contract,
-                    timestamp: now,
-                });
-            }
-        }
-    }
     /**
      * Connect to the subscription.
      */
@@ -329,14 +323,11 @@ export class ContractWatcher {
             }
         }, this.config.failsafePollIntervalMs);
     }
-    /**
-     * Poll all active contracts for current state.
-     */
     async pollAllContracts() {
-        const activeScripts = this.getActiveContracts().map((c) => c.script);
-        if (activeScripts.length === 0)
+        const scripts = this.getWatchedContracts().map((c) => c.script);
+        if (scripts.length === 0)
             return;
-        await this.pollContracts(activeScripts);
+        await this.pollContracts(scripts);
     }
     /**
      * Poll specific contracts and emit events for changes.
@@ -404,7 +395,7 @@ export class ContractWatcher {
      * Watches both active contracts and contracts with virtual outputs.
      */
     async updateSubscription() {
-        const scriptsToWatch = this.getScriptsToWatch();
+        const scriptsToWatch = this.getWatchedContracts().map((c) => c.script);
         if (scriptsToWatch.length === 0) {
             if (this.subscriptionId) {
                 try {
@@ -469,61 +460,55 @@ export class ContractWatcher {
         if (!this.eventCallback)
             return;
         const timestamp = Date.now();
-        const scripts = update.scripts || [];
         if (update.newVtxos?.length) {
-            this.processSubscriptionVtxos(update.newVtxos, scripts, "vtxo_received", timestamp);
+            this.processSubscriptionVtxos(update.newVtxos, "vtxo_received", timestamp);
         }
         if (update.spentVtxos?.length) {
-            this.processSubscriptionVtxos(update.spentVtxos, scripts, "vtxo_spent", timestamp);
+            this.processSubscriptionVtxos(update.spentVtxos, "vtxo_spent", timestamp);
         }
     }
     /**
-     * Process virtual outputs from subscription and route to correct contracts.
-     * Uses the scripts from the subscription response to determine contract ownership.
+     * Process virtual outputs from subscription and route each VTXO to the
+     * single contract that actually locks it via `vtxo.script`. If the script
+     * doesn't match any watched contract, skip the VTXO rather than fan it
+     * out to every matching contract — fan-out produced phantom state in
+     * non-owning contracts that then never reconciled.
      */
-    processSubscriptionVtxos(vtxos, scripts, eventType, timestamp) {
-        // If we have exactly one script, all virtual outputs belong to that contract
-        // Otherwise, we can't reliably determine ownership without script in VirtualCoin
-        if (scripts.length === 1) {
-            const contractScript = scripts[0];
-            if (contractScript) {
-                // Update tracking
-                const state = this.contracts.get(contractScript);
-                if (state) {
-                    for (const vtxo of vtxos) {
-                        const key = `${vtxo.txid}:${vtxo.vout}`;
-                        if (eventType === "vtxo_received") {
-                            state.lastKnownVtxos.set(key, vtxo);
-                        }
-                        else if (eventType === "vtxo_spent") {
-                            state.lastKnownVtxos.delete(key);
-                        }
-                    }
-                }
-                this.emitVtxoEvent(contractScript, vtxos, eventType, timestamp);
+    processSubscriptionVtxos(vtxos, eventType, timestamp) {
+        const byContract = new Map();
+        let unknownScript = 0;
+        for (const vtxo of vtxos) {
+            if (!this.contracts.has(vtxo.script)) {
+                unknownScript++;
+                continue;
             }
-            return;
+            let bucket = byContract.get(vtxo.script);
+            if (!bucket) {
+                bucket = [];
+                byContract.set(vtxo.script, bucket);
+            }
+            bucket.push(vtxo);
         }
-        // Multiple scripts - assign virtual outputs to all matching contracts
-        // This is a limitation: we can't know which virtual output belongs to which script
-        // In practice, subscription events usually come with a single script context
-        for (const script of scripts) {
-            const contractScript = script;
-            if (contractScript) {
-                const state = this.contracts.get(contractScript);
-                if (state) {
-                    for (const vtxo of vtxos) {
-                        const key = `${vtxo.txid}:${vtxo.vout}`;
-                        if (eventType === "vtxo_received") {
-                            state.lastKnownVtxos.set(key, vtxo);
-                        }
-                        else {
-                            state.lastKnownVtxos.delete(key);
-                        }
+        if (unknownScript > 0) {
+            // The failsafe poll is the backstop for these; log at debug so we
+            // can correlate "VTXO state drift" reports with subscription
+            // drops rather than chase phantom bugs.
+            console.debug(`ContractWatcher.processSubscriptionVtxos[${eventType}]: dropped ${unknownScript} unknown-script VTXOs (${vtxos.length} total)`);
+        }
+        for (const [contractScript, bucketVtxos] of byContract) {
+            const state = this.contracts.get(contractScript);
+            if (state) {
+                for (const vtxo of bucketVtxos) {
+                    const key = `${vtxo.txid}:${vtxo.vout}`;
+                    if (eventType === "vtxo_received") {
+                        state.lastKnownVtxos.set(key, vtxo);
+                    }
+                    else if (eventType === "vtxo_spent") {
+                        state.lastKnownVtxos.delete(key);
                     }
                 }
-                this.emitVtxoEvent(contractScript, vtxos, eventType, timestamp);
             }
+            this.emitVtxoEvent(contractScript, bucketVtxos, eventType, timestamp);
         }
     }
     /**
@@ -533,12 +518,10 @@ export class ContractWatcher {
         if (!this.eventCallback)
             return;
         const state = this.contracts.get(contractScript);
-        // ensure we check somehow regularly
-        this.checkExpiredContracts();
+        if (!state)
+            return;
         switch (eventType) {
             case "vtxo_received":
-                if (!state)
-                    return;
                 this.eventCallback({
                     type: "vtxo_received",
                     vtxos: vtxos.map((v) => ({
@@ -555,8 +538,6 @@ export class ContractWatcher {
                 });
                 return;
             case "vtxo_spent":
-                if (!state)
-                    return;
                 this.eventCallback({
                     type: "vtxo_spent",
                     vtxos: vtxos.map((v) => ({
@@ -572,16 +553,6 @@ export class ContractWatcher {
                     timestamp,
                 });
                 return;
-            case "contract_expired":
-                if (!state)
-                    return;
-                this.eventCallback({
-                    type: "contract_expired",
-                    contractScript,
-                    contract: state.contract,
-                    timestamp,
-                });
-                return;
             default:
                 return;
         }

package/dist/esm/providers/ark.js

@@ -227,28 +227,21 @@ export class RestArkProvider {
         const queryParams = topics.length > 0
             ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
             : "";
-        // Create first EventSource eagerly so events are buffered
-        // before the caller starts iterating, preventing race conditions
-        // where the server emits events before iteration begins.
-        const eagerEventSource = new EventSource(url + queryParams);
-        const eagerIterator = eventSourceIterator(eagerEventSource);
+        // The EventSource is allocated inside the generator body so that
+        // abandoning the returned iterator before iteration starts does not
+        // leak the underlying SSE connection. `return()` is overridden below
+        // so that closing the generator also closes the connection even when
+        // the body is currently suspended at an await point.
+        let eventSource = null;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
-        return (async function* () {
-            let firstIteration = true;
-            while (!signal?.aborted) {
-                const eventSource = firstIteration
-                    ? eagerEventSource
-                    : new EventSource(url + queryParams);
-                const iterator = firstIteration
-                    ? eagerIterator
-                    : eventSourceIterator(eventSource);
-                firstIteration = false;
-                try {
-                    const abortHandler = () => {
-                        eventSource.close();
-                    };
-                    signal?.addEventListener("abort", abortHandler);
+        const gen = (async function* () {
+            const abortHandler = () => eventSource?.close();
+            signal?.addEventListener("abort", abortHandler);
+            try {
+                while (!signal?.aborted) {
+                    eventSource = new EventSource(url + queryParams);
+                    const iterator = eventSourceIterator(eventSource);
                     try {
                         for await (const event of iterator) {
                             if (signal?.aborted)
@@ -266,25 +259,35 @@ export class RestArkProvider {
                             }
                         }
                     }
+                    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
+                        if (isFetchTimeoutError(error)) {
+                            console.debug("Timeout error ignored");
+                            continue;
+                        }
+                        console.error("Event stream error:", error);
+                        throw error;
+                    }
                     finally {
-                        signal?.removeEventListener("abort", abortHandler);
                         eventSource.close();
                     }
                 }
-                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
-                    if (isFetchTimeoutError(error)) {
-                        console.debug("Timeout error ignored");
-                        continue;
-                    }
-                    console.error("Event stream error:", error);
-                    throw error;
-                }
+            }
+            finally {
+                signal?.removeEventListener("abort", abortHandler);
+                eventSource?.close();
             }
         })();
+        const origReturn = gen.return.bind(gen);
+        gen.return = (value) => {
+            eventSource?.close();
+            return origReturn(value);
+        };
+        return gen;
     }
     async *getTransactionsStream(signal) {
         const url = `${this.serverUrl}/v1/txs`;

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

@@ -21,7 +21,10 @@ const refCounts = new Map();
  *
  * @param dbName The name of the database to open.
  * @param dbVersion The database version to open.
- * @param initDatabase A function that migrates the database schema, called on `onupgradeneeded` only.
+ * @param initDatabase A function that migrates the database schema, called
+ *   on `onupgradeneeded` only. Receives the database, the previous version
+ *   (0 for fresh installs), and the upgrade transaction — the transaction is
+ *   required for data migrations (cursor/update on existing stores).
  *
  * @returns A promise that resolves to the database instance.
  */
@@ -49,9 +52,9 @@ export async function openDatabase(dbName, dbVersion, initDatabase) {
         request.onsuccess = () => {
             resolve(request.result);
         };
-        request.onupgradeneeded = () => {
+        request.onupgradeneeded = (event) => {
             const db = request.result;
-            initDatabase(db);
+            initDatabase(db, event.oldVersion, request.transaction);
         };
         request.onblocked = () => {
             console.warn("Database upgrade blocked - close other tabs/connections");

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

@@ -1,3 +1,4 @@
+import { scriptFromArkAddress } from '../scriptFromAddress.js';
 // Store names introduced in V2, they are all new to the migration
 export const STORE_VTXOS = "vtxos";
 export const STORE_UTXOS = "utxos";
@@ -6,8 +7,15 @@ export const STORE_WALLET_STATE = "walletState";
 export const STORE_CONTRACTS = "contracts";
 // @deprecated use only for migrations, this is created in V1
 export const LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
-export const DB_VERSION = 2;
-export function initDatabase(db) {
+// Version history:
+//   v1 — initial wallet repo schema, `contractsCollections` store.
+//   v2 — new `vtxos/utxos/transactions/walletState/contracts` stores.
+//   v3 — add `script` index on the vtxos store and backfill missing
+//        `vtxo.script` from `vtxo.address` so the field is always present
+//        at read time. Matches the `script` indexing already in place for
+//        Realm (`realm/schemas.ts`) and SQLite (`sqlite/walletRepository.ts`).
+export const DB_VERSION = 3;
+export function initDatabase(db, oldVersion, transaction) {
     // Create wallet stores
     if (!db.objectStoreNames.contains(STORE_VTXOS)) {
         const vtxosStore = db.createObjectStore(STORE_VTXOS, {
@@ -64,6 +72,11 @@ export function initDatabase(db) {
                 unique: false,
             });
         }
+        if (!vtxosStore.indexNames.contains("script")) {
+            vtxosStore.createIndex("script", "script", {
+                unique: false,
+            });
+        }
     }
     if (!db.objectStoreNames.contains(STORE_UTXOS)) {
         const utxosStore = db.createObjectStore(STORE_UTXOS, {
@@ -152,4 +165,35 @@ export function initDatabase(db) {
             keyPath: "key",
         });
     }
+    // v2 → v3: add the `script` index on the existing vtxos store and
+    // backfill missing `script` on legacy VTXO rows. The upgrade transaction
+    // is null only on a brand-new database (oldVersion === 0), where no
+    // legacy rows exist. `createIndex` scans existing records; rows still
+    // missing `script` are skipped and get indexed automatically when the
+    // backfill's `cursor.update()` adds the field.
+    if (oldVersion >= 1 && oldVersion < 3 && transaction) {
+        const vtxosStore = transaction.objectStore(STORE_VTXOS);
+        if (!vtxosStore.indexNames.contains("script")) {
+            vtxosStore.createIndex("script", "script", { unique: false });
+        }
+        backfillVtxoScripts(transaction);
+    }
+}
+// Exported for unit tests — the `onupgradeneeded` transaction can't be
+// forged in-process, so tests exercise the cursor logic with a regular
+// readwrite transaction on a live DB.
+export function backfillVtxoScripts(transaction) {
+    const store = transaction.objectStore(STORE_VTXOS);
+    const cursorRequest = store.openCursor();
+    cursorRequest.onsuccess = () => {
+        const cursor = cursorRequest.result;
+        if (!cursor)
+            return;
+        const value = cursor.value;
+        if (!value.script) {
+            value.script = scriptFromArkAddress(value.address);
+            cursor.update(value);
+        }
+        cursor.continue();
+    };
 }

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

@@ -1,6 +1,7 @@
 import { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, DB_VERSION, } from './db.js';
 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';
 /**
  * IndexedDB-based implementation of WalletRepository.
@@ -66,8 +67,17 @@ export class IndexedDBWalletRepository {
                 request.onerror = () => reject(request.error);
                 request.onsuccess = () => {
                     const results = request.result || [];
-                    const vtxos = results.map(deserializeVtxo);
-                    resolve(vtxos);
+                    // Wrap `.map` in try/catch so a bad row (e.g. a legacy
+                    // VTXO whose address can't be decoded during backfill)
+                    // rejects the promise instead of silently throwing
+                    // inside the IDB event handler, which would otherwise
+                    // hang the caller.
+                    try {
+                        resolve(results.map(deserializeVtxoWithBackfill));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
                 };
             });
         }
@@ -332,3 +342,12 @@ export class IndexedDBWalletRepository {
         return this.db;
     }
 }
+// Post-migration every row has `script`, but the backfill is idempotent: if a
+// legacy row is ever read before the upgrade-path completes, derive `script`
+// from `address` the same way the indexer would have populated it.
+function deserializeVtxoWithBackfill(o) {
+    if (!o.script) {
+        o = { ...o, script: scriptFromArkAddress(o.address) };
+    }
+    return deserializeVtxo(o);
+}

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

@@ -54,7 +54,6 @@ export class RealmContractRepository {
                 state: contract.state,
                 paramsJson: JSON.stringify(contract.params),
                 createdAt: contract.createdAt,
-                expiresAt: contract.expiresAt ?? null,
                 label: contract.label ?? null,
                 metadataJson: contract.metadata
                     ? JSON.stringify(contract.metadata)
@@ -103,9 +102,6 @@ function contractObjectToDomain(obj) {
         params: JSON.parse(obj.paramsJson),
         createdAt: obj.createdAt,
     };
-    if (obj.expiresAt !== null && obj.expiresAt !== undefined) {
-        contract.expiresAt = obj.expiresAt;
-    }
     if (obj.label !== null && obj.label !== undefined) {
         contract.label = obj.label;
     }

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

@@ -1,3 +1,3 @@
 export { RealmWalletRepository } from './walletRepository.js';
 export { RealmContractRepository } from './contractRepository.js';
-export { ArkRealmSchemas } from './schemas.js';
+export { ArkRealmSchemas, ARK_REALM_SCHEMA_VERSION, runArkRealmMigrations, } from './schemas.js';

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

@@ -8,6 +8,7 @@
  * schemas are defined as plain JS objects conforming to Realm's
  * ObjectSchema shape.
  */
+import { scriptFromArkAddress } from '../scriptFromAddress.js';
 export const ArkVtxoSchema = {
     name: "ArkVtxo",
     primaryKey: "pk",
@@ -32,6 +33,11 @@ export const ArkVtxoSchema = {
         isUnrolled: "bool",
         isSpent: "bool?",
         assetsJson: "string?",
+        // scriptPubKey (hex) locking this VTXO, indexed so contract-scoped
+        // queries can resolve ownership without touching address mapping.
+        // Required as of schema v2; legacy rows are backfilled from `address`
+        // during migration (see `runArkRealmMigrations`).
+        script: { type: "string", indexed: true },
     },
 };
 export const ArkUtxoSchema = {
@@ -103,3 +109,45 @@ export const ArkRealmSchemas = [
     ArkWalletStateSchema,
     ArkContractSchema,
 ];
+/**
+ * Current Realm schema version for the Arkade wallet.
+ *
+ * Consumers opening Realm must pass a `schemaVersion` at least this high so
+ * legacy databases get migrated; merge it with your own app's version:
+ *
+ * ```ts
+ * await Realm.open({
+ *     schema: [...ArkRealmSchemas, ...yourSchemas],
+ *     schemaVersion: Math.max(ARK_REALM_SCHEMA_VERSION, yourSchemaVersion),
+ *     onMigration: (oldRealm, newRealm) => {
+ *         runArkRealmMigrations(oldRealm, newRealm);
+ *         // your own migrations
+ *     },
+ * });
+ * ```
+ *
+ * History:
+ *   - v1: initial ArkVtxo/ArkUtxo/... schemas, `script` nullable.
+ *   - v2: ArkVtxo.script becomes required; NULL values are backfilled from
+ *     the owning Ark address during migration.
+ */
+export const ARK_REALM_SCHEMA_VERSION = 2;
+/**
+ * Run every Arkade schema migration applicable to the open Realm.
+ *
+ * Designed to be composed with the consumer's own migrations inside a single
+ * `onMigration` callback. Each migration step does a per-row check so it
+ * remains idempotent and independent of the app's global `schemaVersion` —
+ * a consumer whose app is already at version 10 can still trigger the
+ * Arkade v1→v2 script backfill when the row has never been populated.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function runArkRealmMigrations(oldRealm, newRealm) {
+    const newVtxos = newRealm.objects("ArkVtxo");
+    for (let i = 0; i < newVtxos.length; i++) {
+        const newVtxo = newVtxos[i];
+        if (!newVtxo.script) {
+            newVtxo.script = scriptFromArkAddress(newVtxo.address);
+        }
+    }
+}

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

@@ -1,4 +1,5 @@
 import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, } from '../serialization.js';
+import { scriptFromArkAddress } from '../scriptFromAddress.js';
 /**
  * Realm-based implementation of WalletRepository.
  *
@@ -70,6 +71,7 @@ export class RealmWalletRepository {
                         ? JSON.stringify(s.extraWitness)
                         : null,
                     assetsJson: s.assets ? JSON.stringify(s.assets) : null,
+                    script: s.script ?? null,
                 }, "modified");
             }
         });
@@ -175,12 +177,10 @@ export class RealmWalletRepository {
             return null;
         const obj = items[0];
         const state = {};
-        if (obj.lastSyncTime !== null && obj.lastSyncTime !== undefined) {
-            state.lastSyncTime = obj.lastSyncTime;
-        }
         if (obj.settingsJson) {
             state.settings = JSON.parse(obj.settingsJson);
         }
+        state.lastSyncTime = obj.lastSyncTime ?? undefined;
         return state;
     }
     async saveWalletState(state) {
@@ -188,7 +188,7 @@ export class RealmWalletRepository {
         this.realm.write(() => {
             this.realm.create("ArkWalletState", {
                 key: "state",
-                lastSyncTime: state.lastSyncTime ?? null,
+                lastSyncTime: state.lastSyncTime,
                 settingsJson: state.settings
                     ? JSON.stringify(state.settings)
                     : null,
@@ -224,6 +224,10 @@ function vtxoObjectToDomain(obj) {
             ? JSON.parse(obj.extraWitnessJson)
             : undefined,
         assets: obj.assetsJson ? JSON.parse(obj.assetsJson) : undefined,
+        // Post-migration every row has `script`, but the backfill is
+        // idempotent: derive from `address` if the legacy column is still
+        // null (e.g. the migration hasn't run yet on this handle).
+        script: obj.script ?? scriptFromArkAddress(obj.address),
     };
     return deserializeVtxo(serialized);
 }