@arkade-os/sdk 0.4.0-next.0 → 0.4.0-next.2

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

@@ -0,0 +1,324 @@
+import { serializeVtxo, serializeUtxo, deserializeVtxo, deserializeUtxo, } from '../serialization.js';
+/**
+ * SQLite-based implementation of WalletRepository.
+ *
+ * Uses the SQLExecutor interface so consumers can plug in any SQLite driver
+ * (expo-sqlite, better-sqlite3, etc.).
+ *
+ * Tables are created lazily on first operation via `ensureInit()`.
+ * The consumer owns the SQLExecutor lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+export class SQLiteWalletRepository {
+    constructor(db, options) {
+        this.db = db;
+        this.version = 1;
+        this.initPromise = null;
+        this.prefix = sanitizePrefix(options?.prefix ?? "ark_");
+        this.tables = {
+            vtxos: `${this.prefix}vtxos`,
+            utxos: `${this.prefix}utxos`,
+            transactions: `${this.prefix}transactions`,
+            walletState: `${this.prefix}wallet_state`,
+        };
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    ensureInit() {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        return this.initPromise;
+    }
+    async init() {
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.vtxos} (
+                txid TEXT NOT NULL,
+                vout INTEGER NOT NULL,
+                value INTEGER NOT NULL,
+                address TEXT NOT NULL,
+                tap_tree TEXT NOT NULL,
+                forfeit_cb TEXT NOT NULL,
+                forfeit_s TEXT NOT NULL,
+                intent_cb TEXT NOT NULL,
+                intent_s TEXT NOT NULL,
+                status_json TEXT NOT NULL,
+                virtual_status_json TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                is_unrolled INTEGER NOT NULL DEFAULT 0,
+                is_spent INTEGER,
+                spent_by TEXT,
+                settled_by TEXT,
+                ark_tx_id TEXT,
+                extra_witness_json TEXT,
+                assets_json TEXT,
+                PRIMARY KEY (txid, vout)
+            )
+        `);
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.utxos} (
+                txid TEXT NOT NULL,
+                vout INTEGER NOT NULL,
+                value INTEGER NOT NULL,
+                address TEXT NOT NULL,
+                tap_tree TEXT NOT NULL,
+                forfeit_cb TEXT NOT NULL,
+                forfeit_s TEXT NOT NULL,
+                intent_cb TEXT NOT NULL,
+                intent_s TEXT NOT NULL,
+                status_json TEXT NOT NULL,
+                extra_witness_json TEXT,
+                PRIMARY KEY (txid, vout)
+            )
+        `);
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.transactions} (
+                address TEXT NOT NULL,
+                boarding_txid TEXT NOT NULL,
+                commitment_txid TEXT NOT NULL,
+                ark_txid TEXT NOT NULL,
+                type TEXT NOT NULL,
+                amount INTEGER NOT NULL,
+                settled INTEGER NOT NULL DEFAULT 0,
+                created_at INTEGER NOT NULL,
+                assets_json TEXT,
+                PRIMARY KEY (address, boarding_txid, commitment_txid, ark_txid)
+            )
+        `);
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.tables.walletState} (
+                key TEXT PRIMARY KEY,
+                last_sync_time INTEGER,
+                settings_json TEXT
+            )
+        `);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}vtxos_address ON ${this.tables.vtxos} (address)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}utxos_address ON ${this.tables.utxos} (address)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_${this.prefix}transactions_address ON ${this.tables.transactions} (address)`);
+    }
+    async [Symbol.asyncDispose]() {
+        // no-op — consumer owns the SQLExecutor lifecycle
+    }
+    // ── Clear ──────────────────────────────────────────────────────────
+    async clear() {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.vtxos}`);
+        await this.db.run(`DELETE FROM ${this.tables.utxos}`);
+        await this.db.run(`DELETE FROM ${this.tables.transactions}`);
+        await this.db.run(`DELETE FROM ${this.tables.walletState}`);
+    }
+    // ── VTXO management ────────────────────────────────────────────────
+    async getVtxos(address) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.vtxos} WHERE address = ?`, [address]);
+        return rows.map(vtxoRowToDomain);
+    }
+    async saveVtxos(address, vtxos) {
+        await this.ensureInit();
+        for (const vtxo of vtxos) {
+            const s = serializeVtxo(vtxo);
+            await this.db.run(`INSERT OR REPLACE INTO ${this.tables.vtxos}
+                    (txid, vout, value, address,
+                     tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
+                     status_json, virtual_status_json, created_at,
+                     is_unrolled, is_spent, spent_by, settled_by, ark_tx_id,
+                     extra_witness_json, assets_json)
+                 VALUES (?, ?, ?, ?,
+                         ?, ?, ?, ?, ?,
+                         ?, ?, ?,
+                         ?, ?, ?, ?, ?,
+                         ?, ?)`, [
+                s.txid,
+                s.vout,
+                s.value,
+                address,
+                s.tapTree,
+                s.forfeitTapLeafScript.cb,
+                s.forfeitTapLeafScript.s,
+                s.intentTapLeafScript.cb,
+                s.intentTapLeafScript.s,
+                JSON.stringify(s.status),
+                JSON.stringify(s.virtualStatus),
+                typeof s.createdAt === "string"
+                    ? s.createdAt
+                    : s.createdAt instanceof Date
+                        ? s.createdAt.toISOString()
+                        : new Date(s.createdAt).toISOString(),
+                s.isUnrolled ? 1 : 0,
+                s.isSpent === undefined ? null : s.isSpent ? 1 : 0,
+                s.spentBy ?? null,
+                s.settledBy ?? null,
+                s.arkTxId ?? null,
+                s.extraWitness ? JSON.stringify(s.extraWitness) : null,
+                s.assets ? JSON.stringify(s.assets) : null,
+            ]);
+        }
+    }
+    async deleteVtxos(address) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.vtxos} WHERE address = ?`, [address]);
+    }
+    // ── UTXO management ────────────────────────────────────────────────
+    async getUtxos(address) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.utxos} WHERE address = ?`, [address]);
+        return rows.map(utxoRowToDomain);
+    }
+    async saveUtxos(address, utxos) {
+        await this.ensureInit();
+        for (const utxo of utxos) {
+            const s = serializeUtxo(utxo);
+            await this.db.run(`INSERT OR REPLACE INTO ${this.tables.utxos}
+                    (txid, vout, value, address,
+                     tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
+                     status_json, extra_witness_json)
+                 VALUES (?, ?, ?, ?,
+                         ?, ?, ?, ?, ?,
+                         ?, ?)`, [
+                s.txid,
+                s.vout,
+                s.value,
+                address,
+                s.tapTree,
+                s.forfeitTapLeafScript.cb,
+                s.forfeitTapLeafScript.s,
+                s.intentTapLeafScript.cb,
+                s.intentTapLeafScript.s,
+                JSON.stringify(s.status),
+                s.extraWitness ? JSON.stringify(s.extraWitness) : null,
+            ]);
+        }
+    }
+    async deleteUtxos(address) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.utxos} WHERE address = ?`, [address]);
+    }
+    // ── Transaction history ────────────────────────────────────────────
+    async getTransactionHistory(address) {
+        await this.ensureInit();
+        const rows = await this.db.all(`SELECT * FROM ${this.tables.transactions} WHERE address = ? ORDER BY created_at ASC`, [address]);
+        return rows.map(txRowToDomain);
+    }
+    async saveTransactions(address, txs) {
+        await this.ensureInit();
+        for (const tx of txs) {
+            await this.db.run(`INSERT OR REPLACE INTO ${this.tables.transactions}
+                    (address, boarding_txid, commitment_txid, ark_txid,
+                     type, amount, settled, created_at, assets_json)
+                 VALUES (?, ?, ?, ?,
+                         ?, ?, ?, ?, ?)`, [
+                address,
+                tx.key.boardingTxid,
+                tx.key.commitmentTxid,
+                tx.key.arkTxid,
+                tx.type,
+                tx.amount,
+                tx.settled ? 1 : 0,
+                tx.createdAt,
+                tx.assets ? JSON.stringify(tx.assets) : null,
+            ]);
+        }
+    }
+    async deleteTransactions(address) {
+        await this.ensureInit();
+        await this.db.run(`DELETE FROM ${this.tables.transactions} WHERE address = ?`, [address]);
+    }
+    // ── Wallet state ───────────────────────────────────────────────────
+    async getWalletState() {
+        await this.ensureInit();
+        const row = await this.db.get(`SELECT * FROM ${this.tables.walletState} WHERE key = ?`, ["state"]);
+        if (!row)
+            return null;
+        const state = {};
+        if (row.last_sync_time !== null && row.last_sync_time !== undefined) {
+            state.lastSyncTime = row.last_sync_time;
+        }
+        if (row.settings_json) {
+            state.settings = JSON.parse(row.settings_json);
+        }
+        return state;
+    }
+    async saveWalletState(state) {
+        await this.ensureInit();
+        await this.db.run(`INSERT OR REPLACE INTO ${this.tables.walletState}
+                (key, last_sync_time, settings_json)
+             VALUES (?, ?, ?)`, [
+            "state",
+            state.lastSyncTime ?? null,
+            state.settings ? JSON.stringify(state.settings) : null,
+        ]);
+    }
+}
+const SAFE_PREFIX = /^[a-zA-Z0-9_]+$/;
+function sanitizePrefix(prefix) {
+    if (!SAFE_PREFIX.test(prefix)) {
+        throw new Error(`Invalid table prefix "${prefix}": only letters, digits, and underscores are allowed`);
+    }
+    return prefix;
+}
+// ── Row → Domain converters ────────────────────────────────────────────
+function vtxoRowToDomain(row) {
+    const serialized = {
+        txid: row.txid,
+        vout: row.vout,
+        value: row.value,
+        tapTree: row.tap_tree,
+        forfeitTapLeafScript: {
+            cb: row.forfeit_cb,
+            s: row.forfeit_s,
+        },
+        intentTapLeafScript: {
+            cb: row.intent_cb,
+            s: row.intent_s,
+        },
+        status: JSON.parse(row.status_json),
+        virtualStatus: JSON.parse(row.virtual_status_json),
+        createdAt: new Date(row.created_at),
+        isUnrolled: row.is_unrolled === 1,
+        isSpent: row.is_spent === null ? undefined : row.is_spent === 1,
+        spentBy: row.spent_by ?? undefined,
+        settledBy: row.settled_by ?? undefined,
+        arkTxId: row.ark_tx_id ?? undefined,
+        extraWitness: row.extra_witness_json
+            ? JSON.parse(row.extra_witness_json)
+            : undefined,
+        assets: row.assets_json ? JSON.parse(row.assets_json) : undefined,
+    };
+    return deserializeVtxo(serialized);
+}
+function utxoRowToDomain(row) {
+    const serialized = {
+        txid: row.txid,
+        vout: row.vout,
+        value: row.value,
+        tapTree: row.tap_tree,
+        forfeitTapLeafScript: {
+            cb: row.forfeit_cb,
+            s: row.forfeit_s,
+        },
+        intentTapLeafScript: {
+            cb: row.intent_cb,
+            s: row.intent_s,
+        },
+        status: JSON.parse(row.status_json),
+        extraWitness: row.extra_witness_json
+            ? JSON.parse(row.extra_witness_json)
+            : undefined,
+    };
+    return deserializeUtxo(serialized);
+}
+function txRowToDomain(row) {
+    const tx = {
+        key: {
+            boardingTxid: row.boarding_txid,
+            commitmentTxid: row.commitment_txid,
+            arkTxid: row.ark_txid,
+        },
+        type: row.type,
+        amount: row.amount,
+        settled: row.settled === 1,
+        createdAt: row.created_at,
+    };
+    if (row.assets_json) {
+        tx.assets = JSON.parse(row.assets_json);
+    }
+    return tx;
+}

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

@@ -166,12 +166,20 @@ export class ServiceWorkerReadonlyWallet {
     // send a message and wait for a response
     async sendMessage(request) {
         return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                navigator.serviceWorker.removeEventListener("message", messageHandler);
+            };
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Service worker message timed out (${request.type})`));
+            }, 30000);
             const messageHandler = (event) => {
                 const response = event.data;
                 if (request.id !== response.id) {
                     return;
                 }
-                navigator.serviceWorker.removeEventListener("message", messageHandler);
+                cleanup();
                 if (response.error) {
                     reject(response.error);
                 }

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

@@ -88,6 +88,13 @@ export function isVtxoExpiringSoon(vtxo, thresholdMs // in milliseconds
     const { batchExpiry } = vtxo.virtualStatus;
     if (!batchExpiry)
         return false; // it doesn't expire
+    // we use this as a workaround to avoid issue on regtest where expiry date is
+    // expressed in blockheight instead of timestamp. If expiry, as Date, is before 2025,
+    // then we admit it's too small to be a timestamp
+    // TODO: API should return the expiry unit
+    const expireAt = new Date(batchExpiry);
+    if (expireAt.getFullYear() < 2025)
+        return false;
     const now = Date.now();
     if (batchExpiry <= now)
         return false; // already expired

package/dist/esm/worker/messageBus.js

@@ -104,8 +104,19 @@ export class MessageBus {
         }
     }
     async waitForInit(config) {
-        if (this.initialized)
-            return;
+        if (this.initialized) {
+            // Stop existing handlers before re-initializing.
+            // This handles the case where CLEAR was called, which nullifies
+            // handler state (readonlyWallet, etc.) without resetting the
+            // initialized flag. Without this, handlers never get start()
+            // called again and all messages fail with "not initialized".
+            //
+            // Clear the flag first so onMessage() rejects incoming messages
+            // during the stop/start window instead of routing them to
+            // half-reset handlers. Restored to true after start() completes.
+            this.initialized = false;
+            await Promise.all(Array.from(this.handlers.values()).map((h) => h.stop().catch(() => { })));
+        }
         const services = await this.buildServicesFn(config);
         // Start all handlers
         for (const updater of this.handlers.values()) {
@@ -165,6 +176,15 @@ export class MessageBus {
         if (!this.initialized) {
             if (this.debug)
                 console.warn("Event received before initialization, dropping", event.data);
+            // Send error response so the caller's promise rejects instead of
+            // hanging forever. This happens when the browser kills and restarts
+            // the service worker — the new instance has initialized=false and
+            // messages arrive before INITIALIZE_MESSAGE_BUS is re-sent.
+            event.source?.postMessage({
+                id,
+                tag: tag ?? "unknown",
+                error: new Error("MessageBus not initialized"),
+            });
             return;
         }
         if (!id || !tag) {

package/dist/types/bip322/index.d.ts

@@ -0,0 +1,55 @@
+import { type BTC_NETWORK } from "@scure/btc-signer/utils.js";
+import type { Identity } from "../identity";
+/**
+ * BIP-322 simple message signing and verification.
+ *
+ * Supports P2TR (Taproot) signing and verification, P2WPKH verification,
+ * and legacy P2PKH verification (Bitcoin Core signmessage format).
+ *
+ * Reuses the same toSpend/toSign transaction construction as Intent proofs,
+ * but with the standard BIP-322 tagged hash ("BIP0322-signed-message")
+ * instead of the Ark-specific tag.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ *
+ * @example
+ * ```typescript
+ * // Sign a message (P2TR)
+ * const signature = await BIP322.sign("Hello Bitcoin!", identity);
+ *
+ * // Verify a signature (P2TR or P2WPKH)
+ * const valid = BIP322.verify("Hello Bitcoin!", signature, "bc1p...");
+ * const valid2 = BIP322.verify("Hello Bitcoin!", signature, "bc1q...");
+ * ```
+ */
+export declare namespace BIP322 {
+    /**
+     * Sign a message using the BIP-322 simple signature scheme.
+     *
+     * Constructs the standard BIP-322 toSpend and toSign transactions,
+     * signs via the Identity interface, and returns the base64-encoded
+     * witness stack.
+     *
+     * @param message - The message to sign
+     * @param identity - Identity instance (holds the private key internally)
+     * @param network - Optional Bitcoin network for P2TR address derivation
+     * @returns Base64-encoded BIP-322 simple signature (witness stack)
+     */
+    function sign(message: string, identity: Identity, network?: BTC_NETWORK): Promise<string>;
+    /**
+     * Verify a BIP-322 signature for a P2TR, P2WPKH, or legacy P2PKH address.
+     *
+     * For segwit addresses (P2TR, P2WPKH), reconstructs the BIP-322
+     * toSpend/toSign transactions and verifies the witness signature.
+     *
+     * For P2PKH addresses, verifies using the Bitcoin Core legacy
+     * `signmessage` format (compact recoverable ECDSA signature).
+     *
+     * @param message - The original message that was signed
+     * @param signature - Base64-encoded signature (BIP-322 witness or legacy compact)
+     * @param address - P2TR, P2WPKH, or P2PKH address of the signer
+     * @param network - Optional Bitcoin network for address decoding
+     * @returns true if the signature is valid
+     */
+    function verify(message: string, signature: string, address: string, network?: BTC_NETWORK): boolean;
+}

package/dist/types/index.d.ts

@@ -26,6 +26,7 @@ import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisig
 import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, ArkTxInput, OffchainTx, combineTapscriptSigs, isValidArkAddress } from "./utils/arkTransaction";
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry } from "./utils/unknownFields";
 import { Intent } from "./intent";
+import { BIP322 } from "./bip322";
 import { ArkNote } from "./arknote";
 import { networks, Network, NetworkName } from "./networks";
 import { RestIndexerProvider, IndexerProvider, IndexerTxType, ChainTxType, PageResponse, BatchInfo, ChainTx, CommitmentTx, TxHistoryRecord, VtxoChain, Tx, Vtxo, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent } from "./providers/indexer";
@@ -44,7 +45,7 @@ export * as asset from "./asset";
 import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract } from "./contracts";
 import type { Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams } from "./contracts";
 import { IContractManager } from "./contracts/contractManager";
-import { closeDatabase, openDatabase } from "./db/manager";
+import { closeDatabase, openDatabase } from "./repositories/indexedDB/manager";
 import { WalletMessageHandler } from "./wallet/serviceWorker/wallet-message-handler";
-export { Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, MessageBus, WalletMessageHandler, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, ArkNote, networks, closeDatabase, openDatabase, IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, Intent, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };
+export { Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, ESPLORA_URL, EsploraProvider, RestArkProvider, RestIndexerProvider, ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, TxType, IndexerTxType, ChainTxType, SettlementEventType, setupServiceWorker, MessageBus, WalletMessageHandler, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, ArkNote, networks, closeDatabase, openDatabase, IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, Intent, BIP322, TxTree, P2A, Unroll, Transaction, ArkError, maybeArkError, Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };
 export type { Identity, ReadonlyIdentity, IWallet, IReadonlyWallet, BaseWalletConfig, WalletConfig, ReadonlyWalletConfig, ProviderClass, ArkTransaction, Coin, ExtendedCoin, ExtendedVirtualCoin, WalletBalance, SendBitcoinParams, SettleParams, Status, VirtualStatus, Outpoint, VirtualCoin, TxKey, TapscriptType, ArkTxInput, OffchainTx, TapLeaves, IncomingFunds, SeedIdentityOptions, MnemonicOptions, NetworkOptions, DescriptorOptions, IndexerProvider, PageResponse, BatchInfo, ChainTx, CommitmentTx, TxHistoryRecord, Vtxo, VtxoChain, Tx, OnchainProvider, ArkProvider, SettlementEvent, FeeInfo, ArkInfo, SignedIntent, Output, TxNotification, ExplorerTransaction, BatchFinalizationEvent, BatchFinalizedEvent, BatchFailedEvent, TreeSigningStartedEvent, TreeNoncesEvent, BatchStartedEvent, TreeTxEvent, TreeSignatureEvent, ScheduledSession, PaginationOptions, SubscriptionResponse, SubscriptionHeartbeat, SubscriptionEvent, Network, NetworkName, ArkTapscript, RelativeTimelock, EncodedVtxoScript, TapLeafScript, SignerSession, TreeNonces, TreePartialSigs, GetVtxosFilter, Asset, Recipient, IssuanceParams, IssuanceResult, ReissuanceParams, BurnParams, AssetDetails, AssetMetadata, KnownMetadata, Nonces, PartialSig, ArkPsbtFieldCoder, TxTreeNode, AnchorBumper, StorageConfig, Contract, ContractVtxo, ContractState, ContractEvent, ContractEventCallback, ContractBalance, ContractWithVtxos, ContractHandler, IContractManager, PathSelection, PathContext, ContractManagerConfig, CreateContractParams, ContractWatcherConfig, ParsedArkContract, DefaultContractParams, DelegateContractParams, VHTLCContractParams, MessageHandler, RequestEnvelope, ResponseEnvelope, DelegatorManager, DelegatorProvider, DelegateInfo, DelegateOptions, WalletRepository, ContractRepository, MigrationStatus, };

package/dist/types/intent/index.d.ts

@@ -58,3 +58,16 @@ export declare namespace Intent {
     type Message = RegisterMessage | DeleteMessage | GetPendingTxMessage;
     function encodeMessage(message: Message): string;
 }
+export declare const OP_RETURN_EMPTY_PKSCRIPT: Uint8Array<ArrayBuffer>;
+export declare const TAG_INTENT_PROOF = "ark-intent-proof-message";
+/**
+ * Creates the "to_spend" transaction used by both intent proofs and BIP-322.
+ *
+ * The message is hashed with the given tagged-hash tag before being placed
+ * into the scriptSig as `OP_0 <hash>`.
+ *
+ * @param message - The message to embed
+ * @param pkScript - The scriptPubKey of the signer's address
+ * @param tag - Tagged-hash tag (defaults to the Ark intent proof tag)
+ */
+export declare function craftToSpendTx(message: string, pkScript: Uint8Array, tag?: string): Transaction;

package/dist/types/repositories/indexedDB/db.d.ts

@@ -1,56 +1,4 @@
-import { TapLeafScript } from "../../script/base";
-import { ExtendedCoin, ExtendedVirtualCoin } from "../../wallet";
 import { DB_VERSION, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, STORE_TRANSACTIONS, STORE_UTXOS, STORE_VTXOS, STORE_WALLET_STATE } from "./schema";
 export { STORE_VTXOS, STORE_UTXOS, STORE_TRANSACTIONS, STORE_WALLET_STATE, STORE_CONTRACTS, LEGACY_STORE_CONTRACT_COLLECTIONS, DB_VERSION, };
-export type SerializedVtxo = ReturnType<typeof serializeVtxo>;
-export type SerializedUtxo = ReturnType<typeof serializeUtxo>;
-export declare const serializeTapLeaf: ([cb, s]: TapLeafScript) => {
-    cb: string;
-    s: string;
-};
-export declare const serializeVtxo: (v: ExtendedVirtualCoin) => {
-    tapTree: string;
-    forfeitTapLeafScript: {
-        cb: string;
-        s: string;
-    };
-    intentTapLeafScript: {
-        cb: string;
-        s: string;
-    };
-    extraWitness: string[] | undefined;
-    virtualStatus: import("../../wallet").VirtualStatus;
-    spentBy?: string;
-    settledBy?: string;
-    arkTxId?: string;
-    createdAt: Date;
-    isUnrolled: boolean;
-    isSpent?: boolean;
-    assets?: import("../../wallet").Asset[];
-    value: number;
-    status: import("../../wallet").Status;
-    txid: string;
-    vout: number;
-};
-export declare const serializeUtxo: (u: ExtendedCoin) => {
-    tapTree: string;
-    forfeitTapLeafScript: {
-        cb: string;
-        s: string;
-    };
-    intentTapLeafScript: {
-        cb: string;
-        s: string;
-    };
-    extraWitness: string[] | undefined;
-    value: number;
-    status: import("../../wallet").Status;
-    txid: string;
-    vout: number;
-};
-export declare const deserializeTapLeaf: (t: {
-    cb: string;
-    s: string;
-}) => TapLeafScript;
-export declare const deserializeVtxo: (o: SerializedVtxo) => ExtendedVirtualCoin;
-export declare const deserializeUtxo: (o: SerializedUtxo) => ExtendedCoin;
+export { serializeTapLeaf, serializeVtxo, serializeUtxo, deserializeTapLeaf, deserializeVtxo, deserializeUtxo, } from "../serialization";
+export type { SerializedTapLeaf, SerializedVtxo, SerializedUtxo, } from "../serialization";

package/dist/types/repositories/realm/contractRepository.d.ts

@@ -0,0 +1,24 @@
+import { Contract } from "../../contracts/types";
+import { ContractFilter, ContractRepository } from "../contractRepository";
+import { RealmLike } from "./types";
+/**
+ * Realm-based implementation of ContractRepository.
+ *
+ * Consumers must open Realm with the schemas from `./schemas.ts` and pass
+ * the instance to the constructor.
+ *
+ * Realm handles schema creation on open, so `ensureInit()` is a no-op.
+ * The consumer owns the Realm lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+export declare class RealmContractRepository implements ContractRepository {
+    private readonly realm;
+    readonly version: 1;
+    constructor(realm: RealmLike);
+    private ensureInit;
+    [Symbol.asyncDispose](): Promise<void>;
+    clear(): Promise<void>;
+    getContracts(filter?: ContractFilter): Promise<Contract[]>;
+    saveContract(contract: Contract): Promise<void>;
+    deleteContract(script: string): Promise<void>;
+    private addFilterCondition;
+}

package/dist/types/repositories/realm/index.d.ts

@@ -0,0 +1,4 @@
+export { RealmWalletRepository } from "./walletRepository";
+export { RealmContractRepository } from "./contractRepository";
+export { ArkRealmSchemas } from "./schemas";
+export type { RealmLike, RealmResults } from "./types";