@arkade-os/sdk 0.4.24 → 0.4.26

package/dist/esm/index.js

@@ -1,51 +1,51 @@
-import { Transaction } from './utils/transaction.js';
-import { SingleKey, ReadonlySingleKey } from './identity/singleKey.js';
-import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, } from './identity/seedIdentity.js';
-import { isBatchSignable, } from './identity/index.js';
-import { ArkAddress } from './script/address.js';
-import { VHTLC } from './script/vhtlc.js';
-import { DefaultVtxo } from './script/default.js';
-import { DelegateVtxo } from './script/delegate.js';
-import { MessageBus, } from './worker/messageBus.js';
-import { VtxoScript, TapTreeCoder, getSequence, } from './script/base.js';
-import { TxType, isSpendable, isSubdust, isRecoverable, isExpired, } from './wallet/index.js';
-import { Batch } from './wallet/batch.js';
-import { Wallet, ReadonlyWallet, waitForIncomingFunds, } from './wallet/wallet.js';
-import { TxTree } from './tree/txTree.js';
-import { Ramps } from './wallet/ramps.js';
-import { HDDescriptorProvider } from './wallet/hdDescriptorProvider.js';
-import { isVtxoExpiringSoon, VtxoManager } from './wallet/vtxo-manager.js';
-import { ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, } from './wallet/serviceWorker/wallet.js';
-import { OnchainWallet } from './wallet/onchain.js';
-import { setupServiceWorker } from './worker/browser/utils.js';
-import { ESPLORA_URL, EsploraProvider, } from './providers/onchain.js';
-import { ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ElectrumOnchainProvider, WsElectrumChainSource, } from './providers/electrum.js';
-import { RestArkProvider, SettlementEventType, } from './providers/ark.js';
-import { RestDelegatorProvider, } from './providers/delegator.js';
-import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from './script/tapscript.js';
-import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, isValidArkAddress, } from './utils/arkTransaction.js';
-import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
-import { Intent } from './intent/index.js';
-import { BIP322 } from './bip322/index.js';
-import { ArkNote } from './arknote/index.js';
-import { networks } from './networks.js';
-import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
-import { P2A } from './utils/anchor.js';
-import { TxWeightEstimator } from './utils/txSizeEstimator.js';
-import { Unroll } from './wallet/unroll.js';
-import { ArkError, maybeArkError } from './providers/errors.js';
-import { validateVtxoTxGraph, validateConnectorsTxGraph, } from './tree/validation.js';
-import { buildForfeitTx } from './forfeit.js';
-import { IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, } from './repositories/index.js';
-import { DelegatorManagerImpl } from './wallet/delegator.js';
-export * from './arkfee/index.js';
-export * as asset from './extension/asset/index.js';
+import { Transaction } from "./utils/transaction.js";
+import { SingleKey, ReadonlySingleKey } from "./identity/singleKey.js";
+import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, } from "./identity/seedIdentity.js";
+import { isBatchSignable, } from "./identity/index.js";
+import { ArkAddress } from "./script/address.js";
+import { VHTLC } from "./script/vhtlc.js";
+import { DefaultVtxo } from "./script/default.js";
+import { DelegateVtxo } from "./script/delegate.js";
+import { MessageBus, } from "./worker/messageBus.js";
+import { VtxoScript, TapTreeCoder, getSequence, } from "./script/base.js";
+import { TxType, isSpendable, isSubdust, isRecoverable, isExpired, } from "./wallet/index.js";
+import { Batch } from "./wallet/batch.js";
+import { Wallet, ReadonlyWallet, waitForIncomingFunds, } from "./wallet/wallet.js";
+import { TxTree } from "./tree/txTree.js";
+import { Ramps } from "./wallet/ramps.js";
+import { HDDescriptorProvider } from "./wallet/hdDescriptorProvider.js";
+import { isVtxoExpiringSoon, VtxoManager } from "./wallet/vtxo-manager.js";
+import { ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, } from "./wallet/serviceWorker/wallet.js";
+import { OnchainWallet } from "./wallet/onchain.js";
+import { setupServiceWorker } from "./worker/browser/utils.js";
+import { ESPLORA_URL, EsploraProvider, } from "./providers/onchain.js";
+import { ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ElectrumOnchainProvider, WsElectrumChainSource, } from "./providers/electrum.js";
+import { RestArkProvider, SettlementEventType, } from "./providers/ark.js";
+import { RestDelegatorProvider, } from "./providers/delegator.js";
+import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from "./script/tapscript.js";
+import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, isValidArkAddress, } from "./utils/arkTransaction.js";
+import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from "./utils/unknownFields.js";
+import { Intent } from "./intent/index.js";
+import { BIP322 } from "./bip322/index.js";
+import { ArkNote } from "./arknote/index.js";
+import { networks } from "./networks.js";
+import { RestIndexerProvider, IndexerTxType, ChainTxType, } from "./providers/indexer.js";
+import { P2A } from "./utils/anchor.js";
+import { TxWeightEstimator } from "./utils/txSizeEstimator.js";
+import { Unroll } from "./wallet/unroll.js";
+import { ArkError, maybeArkError } from "./providers/errors.js";
+import { validateVtxoTxGraph, validateConnectorsTxGraph, } from "./tree/validation.js";
+import { buildForfeitTx } from "./forfeit.js";
+import { IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, } from "./repositories/index.js";
+import { DelegatorManagerImpl } from "./wallet/delegator.js";
+export * from "./arkfee/index.js";
+export * as asset from "./extension/asset/index.js";
 // Contracts
-import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from './contracts/index.js';
-import { timelockToSequence, sequenceToTimelock } from './utils/timelock.js';
-import { closeDatabase, openDatabase } from './repositories/indexedDB/manager.js';
-import { WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, } from './wallet/serviceWorker/wallet-message-handler.js';
-import { MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from './worker/errors.js';
+import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from "./contracts/index.js";
+import { timelockToSequence, sequenceToTimelock } from "./utils/timelock.js";
+import { closeDatabase, openDatabase } from "./repositories/indexedDB/manager.js";
+import { WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, } from "./wallet/serviceWorker/wallet-message-handler.js";
+import { MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from "./worker/errors.js";
 export { 
 // Wallets
 Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, isBatchSignable, OnchainWallet, Ramps, VtxoManager, HDDescriptorProvider, DelegatorManagerImpl, RestDelegatorProvider, 

package/dist/esm/intent/index.js

@@ -1,9 +1,9 @@
 import { OP, Script, SigHash } from "@scure/btc-signer";
 import { schnorr } from "@noble/curves/secp256k1.js";
-import { Transaction } from '../utils/transaction.js';
-import { ConditionWitness, VtxoTaprootTree } from '../utils/unknownFields.js';
+import { Transaction } from "../utils/transaction.js";
+import { ConditionWitness, VtxoTaprootTree } from "../utils/unknownFields.js";
 import { hex } from "@scure/base";
-import { getSequence, VtxoScript } from '../script/base.js';
+import { getSequence, VtxoScript } from "../script/base.js";
 /**
  * Intent proof implementation for Bitcoin message signing.
  *

package/dist/esm/musig2/index.js

@@ -1,3 +1,3 @@
-export { generateNonces, aggregateNonces } from './nonces.js';
-export { PartialSig, sign } from './sign.js';
-export { aggregateKeys } from './keys.js';
+export { generateNonces, aggregateNonces } from "./nonces.js";
+export { PartialSig, sign } from "./sign.js";
+export { aggregateKeys } from "./keys.js";

package/dist/esm/musig2/sign.js

@@ -1,7 +1,7 @@
 import * as musig from "@scure/btc-signer/musig2.js";
 import { bytesToNumberBE } from "@noble/curves/utils.js";
 import { Point } from "@noble/secp256k1";
-import { aggregateKeys } from './keys.js';
+import { aggregateKeys } from "./keys.js";
 import { schnorr } from "@noble/curves/secp256k1.js";
 // Add this error type for decode failures
 export class PartialSignatureError extends Error {

package/dist/esm/providers/ark.js

@@ -1,7 +1,7 @@
 import { hex } from "@scure/base";
-import { eventSourceIterator, isEventSourceError } from './utils.js';
-import { maybeArkError } from './errors.js';
-import { Intent } from '../intent/index.js';
+import { eventSourceIterator, isEventSourceError } from "./utils.js";
+import { maybeArkError } from "./errors.js";
+import { Intent } from "../intent/index.js";
 export var SettlementEventType;
 (function (SettlementEventType) {
     SettlementEventType["BatchStarted"] = "batch_started";

package/dist/esm/providers/delegator.js

@@ -1,4 +1,4 @@
-import { Intent } from '../intent/index.js';
+import { Intent } from "../intent/index.js";
 /**
  * REST-based delegation provider implementation.
  * @example

package/dist/esm/providers/electrum.js

@@ -92,8 +92,8 @@ function parseBlockHeader(headerHex) {
  * @example
  * ```typescript
  * import { ElectrumWS } from "ws-electrumx-client";
- * import { WsElectrumChainSource } from './providers/electrum.js';
- * import { networks } from './networks.js';
+ * import { WsElectrumChainSource } from "./providers/electrum.js";
+ * import { networks } from "./networks.js";
  *
  * const ws = new ElectrumWS("wss://electrum.blockstream.info:50004");
  * const chain = new WsElectrumChainSource(ws, networks.bitcoin);

package/dist/esm/providers/expoArk.js

@@ -1,5 +1,5 @@
-import { RestArkProvider, isFetchTimeoutError, } from './ark.js';
-import { getExpoFetch, sseStreamIterator } from './expoUtils.js';
+import { RestArkProvider, isFetchTimeoutError, } from "./ark.js";
+import { getExpoFetch, sseStreamIterator } from "./expoUtils.js";
 /**
  * Expo-compatible Arkade provider implementation using expo/fetch for SSE support.
  * This provider works specifically in React Native/Expo environments where

package/dist/esm/providers/expoIndexer.js

@@ -1,6 +1,6 @@
-import { RestIndexerProvider } from './indexer.js';
-import { isFetchTimeoutError } from './ark.js';
-import { getExpoFetch, sseStreamIterator } from './expoUtils.js';
+import { RestIndexerProvider } from "./indexer.js";
+import { isFetchTimeoutError } from "./ark.js";
+import { getExpoFetch, sseStreamIterator } from "./expoUtils.js";
 // Helper function to convert Vtxo to VirtualCoin (same as in indexer.ts)
 function convertVtxo(vtxo) {
     return {

package/dist/esm/providers/indexer.js

@@ -1,7 +1,7 @@
 import { hex } from "@scure/base";
-import { isFetchTimeoutError } from './ark.js';
-import { eventSourceIterator, isEventSourceError } from './utils.js';
-import { MetadataList } from '../extension/asset/index.js';
+import { isFetchTimeoutError } from "./ark.js";
+import { eventSourceIterator, isEventSourceError } from "./utils.js";
+import { MetadataList } from "../extension/asset/index.js";
 export var IndexerTxType;
 (function (IndexerTxType) {
     IndexerTxType[IndexerTxType["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";

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/index.js

@@ -1,10 +1,10 @@
-export * from './walletRepository.js';
-export * from './contractRepository.js';
-export * from './inMemory/walletRepository.js';
-export * from './inMemory/contractRepository.js';
-export * from './indexedDB/contractRepository.js';
-export * from './indexedDB/walletRepository.js';
-export { MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, } from './migrations/fromStorageAdapter.js';
+export * from "./walletRepository.js";
+export * from "./contractRepository.js";
+export * from "./inMemory/walletRepository.js";
+export * from "./inMemory/contractRepository.js";
+export * from "./indexedDB/contractRepository.js";
+export * from "./indexedDB/walletRepository.js";
+export { MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, } from "./migrations/fromStorageAdapter.js";
 // Deprecated
-export { WalletRepositoryImpl } from './migrations/walletRepositoryImpl.js';
-export { ContractRepositoryImpl } from './migrations/contractRepositoryImpl.js';
+export { WalletRepositoryImpl } from "./migrations/walletRepositoryImpl.js";
+export { ContractRepositoryImpl } from "./migrations/contractRepositoryImpl.js";

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

@@ -1,7 +1,7 @@
-import { DB_VERSION, STORE_CONTRACTS } from './db.js';
-import { closeDatabase, openDatabase } from './manager.js';
-import { initDatabase } from './schema.js';
-import { DEFAULT_DB_NAME } from '../../worker/browser/utils.js';
+import { DB_VERSION, STORE_CONTRACTS } from "./db.js";
+import { closeDatabase, openDatabase } from "./manager.js";
+import { initDatabase } from "./schema.js";
+import { DEFAULT_DB_NAME } from "../../worker/browser/utils.js";
 /**
  * IndexedDB-based implementation of ContractRepository.
  *

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

@@ -1,4 +1,4 @@
-import { DB_VERSION, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, STORE_TRANSACTIONS, STORE_UTXOS, STORE_VTXOS, STORE_WALLET_STATE, } from './schema.js';
+import { DB_VERSION, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, STORE_TRANSACTIONS, STORE_UTXOS, STORE_VTXOS, STORE_WALLET_STATE, } from "./schema.js";
 export { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, DB_VERSION, };
 // Serialization helpers (re-exported from shared module)
-export { serializeTapLeaf, serializeVtxo, serializeUtxo, deserializeTapLeaf, deserializeVtxo, deserializeUtxo, } from '../serialization.js';
+export { serializeTapLeaf, serializeVtxo, serializeUtxo, deserializeTapLeaf, deserializeVtxo, deserializeUtxo, } from "../serialization.js";

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

@@ -1,4 +1,4 @@
-import { scriptFromArkAddress } from '../scriptFromAddress.js';
+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";

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

@@ -1,8 +1,9 @@
-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';
+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";
+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/migrations/fromStorageAdapter.js

@@ -1,4 +1,4 @@
-import { WalletRepositoryImpl } from './walletRepositoryImpl.js';
+import { WalletRepositoryImpl } from "./walletRepositoryImpl.js";
 export const MIGRATION_KEY = (repoType) => `migration-from-storage-adapter-${repoType}`;
 export async function getMigrationStatus(repoType, storageAdapter) {
     try {

package/dist/esm/repositories/migrations/walletRepositoryImpl.js

@@ -1,6 +1,6 @@
 import { hex } from "@scure/base";
 import { TaprootControlBlock } from "@scure/btc-signer";
-import { serializeAssets, deserializeAssets, serializeTransaction, deserializeTransaction, } from '../serialization.js';
+import { serializeAssets, deserializeAssets, serializeTransaction, deserializeTransaction, } from "../serialization.js";
 const getVtxosStorageKey = (address) => `vtxos:${address}`;
 const getUtxosStorageKey = (address) => `utxos:${address}`;
 const getTransactionsStorageKey = (address) => `tx:${address}`;

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

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

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

@@ -8,7 +8,7 @@
  * schemas are defined as plain JS objects conforming to Realm's
  * ObjectSchema shape.
  */
-import { scriptFromArkAddress } from '../scriptFromAddress.js';
+import { scriptFromArkAddress } from "../scriptFromAddress.js";
 export const ArkVtxoSchema = {
     name: "ArkVtxo",
     primaryKey: "pk",

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 { 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/scriptFromAddress.js

@@ -1,5 +1,5 @@
 import { hex } from "@scure/base";
-import { ArkAddress } from '../index.js';
+import { ArkAddress } from "../index.js";
 /**
  * Compute the hex-encoded `scriptPubKey` locking a VTXO from its owning Ark
  * address. Used by repository-layer migrations to backfill `script` on legacy

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

@@ -1,2 +1,2 @@
-export { SQLiteWalletRepository } from './walletRepository.js';
-export { SQLiteContractRepository } from './contractRepository.js';
+export { SQLiteWalletRepository } from "./walletRepository.js";
+export { SQLiteContractRepository } from "./contractRepository.js";

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 { 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/script/address.js

@@ -1,6 +1,6 @@
 import { bech32m } from "@scure/base";
 import { Script } from "@scure/btc-signer/script.js";
-import { DEFAULT_ARKADE_HRP } from '../wallet/index.js';
+import { DEFAULT_ARKADE_HRP } from "../wallet/index.js";
 /**
  * ArkAddress allows creating and decoding bech32m-encoded Arkade addresses.
  *
@@ -32,10 +32,10 @@ import { DEFAULT_ARKADE_HRP } from '../wallet/index.js';
  */
 export class ArkAddress {
     /**
-     * Create an Arkade address from its server key, vtxo taproot public key, and prefix.
+     * Create an Arkade address from its server public key, Taproot output key, and prefix.
      *
      * @param serverPubKey - 32-byte Arkade server public key
-     * @param vtxoTaprootKey - 32-byte tweaked vtxo taproot public key
+     * @param vtxoTaprootKey - 32-byte Taproot output key (a.k.a. tweaked public key)
      * @param hrp - Bech32 human-readable prefix
      * @param version - Address version byte
      * @defaultValue `version = 0`

package/dist/esm/script/base.js

@@ -2,9 +2,9 @@ import { Script, Address, p2tr, taprootListToTree, TAPROOT_UNSPENDABLE_KEY, } fr
 import { TAP_LEAF_VERSION } from "@scure/btc-signer/payment.js";
 import { PSBTOutput } from "@scure/btc-signer/psbt.js";
 import { hex } from "@scure/base";
-import { ArkAddress } from './address.js';
-import { timelockToSequence } from '../utils/timelock.js';
-import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from './tapscript.js';
+import { ArkAddress } from "./address.js";
+import { timelockToSequence } from "../utils/timelock.js";
+import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from "./tapscript.js";
 export const TapTreeCoder = PSBTOutput.tapTree[2];
 export function scriptFromTapLeafScript(leaf) {
     return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte

package/dist/esm/script/default.js

@@ -1,5 +1,5 @@
-import { VtxoScript } from './base.js';
-import { CSVMultisigTapscript, MultisigTapscript, } from './tapscript.js';
+import { VtxoScript } from "./base.js";
+import { CSVMultisigTapscript, MultisigTapscript, } from "./tapscript.js";
 import { hex } from "@scure/base";
 /**
  * DefaultVtxo is the default implementation of a VtxoScript.