@arkade-os/sdk 0.4.17 → 0.4.18

package/dist/cjs/contracts/contractWatcher.js

@@ -65,6 +65,12 @@ 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).
@@ -73,6 +79,31 @@ 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.
      */
@@ -105,35 +136,20 @@ 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.
@@ -235,28 +251,6 @@ 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.
      */
@@ -332,14 +326,11 @@ 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.
@@ -407,7 +398,7 @@ 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 {
@@ -472,61 +463,55 @@ 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);
         }
     }
     /**
@@ -536,12 +521,10 @@ 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) => ({
@@ -558,8 +541,6 @@ class ContractWatcher {
                 });
                 return;
             case "vtxo_spent":
-                if (!state)
-                    return;
                 this.eventCallback({
                     type: "vtxo_spent",
                     vtxos: vtxos.map((v) => ({
@@ -575,16 +556,6 @@ 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/cjs/repositories/indexedDB/manager.js

@@ -26,7 +26,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.
  */
@@ -54,9 +57,9 @@ 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/cjs/repositories/indexedDB/schema.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB_VERSION = exports.LEGACY_STORE_CONTRACT_COLLECTIONS = exports.STORE_CONTRACTS = exports.STORE_WALLET_STATE = exports.STORE_TRANSACTIONS = exports.STORE_UTXOS = exports.STORE_VTXOS = void 0;
 exports.initDatabase = initDatabase;
+exports.backfillVtxoScripts = backfillVtxoScripts;
+const scriptFromAddress_1 = require("../scriptFromAddress");
 // Store names introduced in V2, they are all new to the migration
 exports.STORE_VTXOS = "vtxos";
 exports.STORE_UTXOS = "utxos";
@@ -10,8 +12,15 @@ exports.STORE_WALLET_STATE = "walletState";
 exports.STORE_CONTRACTS = "contracts";
 // @deprecated use only for migrations, this is created in V1
 exports.LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
-exports.DB_VERSION = 2;
-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`).
+exports.DB_VERSION = 3;
+function initDatabase(db, oldVersion, transaction) {
     // Create wallet stores
     if (!db.objectStoreNames.contains(exports.STORE_VTXOS)) {
         const vtxosStore = db.createObjectStore(exports.STORE_VTXOS, {
@@ -68,6 +77,11 @@ function initDatabase(db) {
                 unique: false,
             });
         }
+        if (!vtxosStore.indexNames.contains("script")) {
+            vtxosStore.createIndex("script", "script", {
+                unique: false,
+            });
+        }
     }
     if (!db.objectStoreNames.contains(exports.STORE_UTXOS)) {
         const utxosStore = db.createObjectStore(exports.STORE_UTXOS, {
@@ -156,4 +170,35 @@ 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(exports.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.
+function backfillVtxoScripts(transaction) {
+    const store = transaction.objectStore(exports.STORE_VTXOS);
+    const cursorRequest = store.openCursor();
+    cursorRequest.onsuccess = () => {
+        const cursor = cursorRequest.result;
+        if (!cursor)
+            return;
+        const value = cursor.value;
+        if (!value.script) {
+            value.script = (0, scriptFromAddress_1.scriptFromArkAddress)(value.address);
+            cursor.update(value);
+        }
+        cursor.continue();
+    };
 }

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

@@ -4,6 +4,7 @@ exports.IndexedDBWalletRepository = void 0;
 const db_1 = require("./db");
 const manager_1 = require("./manager");
 const schema_1 = require("./schema");
+const scriptFromAddress_1 = require("../scriptFromAddress");
 const utils_1 = require("../../worker/browser/utils");
 /**
  * IndexedDB-based implementation of WalletRepository.
@@ -69,8 +70,17 @@ class IndexedDBWalletRepository {
                 request.onerror = () => reject(request.error);
                 request.onsuccess = () => {
                     const results = request.result || [];
-                    const vtxos = results.map(db_1.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);
+                    }
                 };
             });
         }
@@ -336,3 +346,12 @@ class IndexedDBWalletRepository {
     }
 }
 exports.IndexedDBWalletRepository = IndexedDBWalletRepository;
+// 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: (0, scriptFromAddress_1.scriptFromArkAddress)(o.address) };
+    }
+    return (0, db_1.deserializeVtxo)(o);
+}

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

@@ -57,7 +57,6 @@ 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)
@@ -107,9 +106,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/cjs/repositories/realm/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArkRealmSchemas = exports.RealmContractRepository = exports.RealmWalletRepository = void 0;
+exports.runArkRealmMigrations = exports.ARK_REALM_SCHEMA_VERSION = exports.ArkRealmSchemas = exports.RealmContractRepository = exports.RealmWalletRepository = void 0;
 var walletRepository_1 = require("./walletRepository");
 Object.defineProperty(exports, "RealmWalletRepository", { enumerable: true, get: function () { return walletRepository_1.RealmWalletRepository; } });
 var contractRepository_1 = require("./contractRepository");
 Object.defineProperty(exports, "RealmContractRepository", { enumerable: true, get: function () { return contractRepository_1.RealmContractRepository; } });
 var schemas_1 = require("./schemas");
 Object.defineProperty(exports, "ArkRealmSchemas", { enumerable: true, get: function () { return schemas_1.ArkRealmSchemas; } });
+Object.defineProperty(exports, "ARK_REALM_SCHEMA_VERSION", { enumerable: true, get: function () { return schemas_1.ARK_REALM_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "runArkRealmMigrations", { enumerable: true, get: function () { return schemas_1.runArkRealmMigrations; } });

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

@@ -10,7 +10,9 @@
  * ObjectSchema shape.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArkRealmSchemas = exports.ArkContractSchema = exports.ArkWalletStateSchema = exports.ArkTransactionSchema = exports.ArkUtxoSchema = exports.ArkVtxoSchema = void 0;
+exports.ARK_REALM_SCHEMA_VERSION = exports.ArkRealmSchemas = exports.ArkContractSchema = exports.ArkWalletStateSchema = exports.ArkTransactionSchema = exports.ArkUtxoSchema = exports.ArkVtxoSchema = void 0;
+exports.runArkRealmMigrations = runArkRealmMigrations;
+const scriptFromAddress_1 = require("../scriptFromAddress");
 exports.ArkVtxoSchema = {
     name: "ArkVtxo",
     primaryKey: "pk",
@@ -35,6 +37,11 @@ exports.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 },
     },
 };
 exports.ArkUtxoSchema = {
@@ -106,3 +113,45 @@ exports.ArkRealmSchemas = [
     exports.ArkWalletStateSchema,
     exports.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.
+ */
+exports.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
+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 = (0, scriptFromAddress_1.scriptFromArkAddress)(newVtxo.address);
+        }
+    }
+}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RealmWalletRepository = void 0;
 const serialization_1 = require("../serialization");
+const scriptFromAddress_1 = require("../scriptFromAddress");
 /**
  * Realm-based implementation of WalletRepository.
  *
@@ -73,6 +74,7 @@ class RealmWalletRepository {
                         ? JSON.stringify(s.extraWitness)
                         : null,
                     assetsJson: s.assets ? JSON.stringify(s.assets) : null,
+                    script: s.script ?? null,
                 }, "modified");
             }
         });
@@ -178,12 +180,10 @@ 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) {
@@ -191,7 +191,7 @@ 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,
@@ -228,6 +228,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 ?? (0, scriptFromAddress_1.scriptFromArkAddress)(obj.address),
     };
     return (0, serialization_1.deserializeVtxo)(serialized);
 }

package/dist/cjs/repositories/scriptFromAddress.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptFromArkAddress = scriptFromArkAddress;
+const base_1 = require("@scure/base");
+const index_1 = require("../index");
+/**
+ * Compute the hex-encoded `scriptPubKey` locking a VTXO from its owning Ark
+ * address. Used by repository-layer migrations to backfill `script` on legacy
+ * rows that pre-date the column (the indexer now guarantees the field, so new
+ * rows never go through this path). The `script` field is required by the
+ * domain type, so backfill must produce the same value the indexer would
+ * have returned — which is the hex of the address's `pkScript`.
+ */
+function scriptFromArkAddress(address) {
+    return base_1.hex.encode(index_1.ArkAddress.decode(address).pkScript);
+}

package/dist/cjs/repositories/sqlite/contractRepository.js

@@ -71,16 +71,15 @@ class SQLiteContractRepository {
         await this.ensureInit();
         await this.db.run(`INSERT OR REPLACE INTO ${this.table}
                 (script, address, type, state, params_json,
-                 created_at, expires_at, label, metadata_json)
+                 created_at, label, metadata_json)
              VALUES (?, ?, ?, ?, ?,
-                     ?, ?, ?, ?)`, [
+                     ?, ?, ?)`, [
             contract.script,
             contract.address,
             contract.type,
             contract.state,
             JSON.stringify(contract.params),
             contract.createdAt,
-            contract.expiresAt ?? null,
             contract.label ?? null,
             contract.metadata ? JSON.stringify(contract.metadata) : null,
         ]);
@@ -126,9 +125,6 @@ function contractRowToDomain(row) {
         params: JSON.parse(row.params_json),
         createdAt: row.created_at,
     };
-    if (row.expires_at !== null) {
-        contract.expiresAt = row.expires_at;
-    }
     if (row.label !== null) {
         contract.label = row.label;
     }