@arkade-os/sdk 0.3.13 → 0.4.0-next.1

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

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * WebSQL adapter over expo-sqlite.
+ *
+ * Bridges the WebSQL API surface that indexeddbshim expects to the
+ * synchronous expo-sqlite driver.  Only the subset actually called by
+ * the shim is implemented:
+ *
+ *   openDatabase(name, version, displayName, estimatedSize) → WebSQLDatabase
+ *   db.transaction(cb, errCb?, successCb?)
+ *   tx.executeSql(sql, args?, successCb?, errorCb?)
+ *   resultSet = { insertId, rowsAffected, rows: { length, item(i) } }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSQLDatabase = exports.WebSQLTransaction = void 0;
+exports.openDatabase = openDatabase;
+const expo_sqlite_1 = require("expo-sqlite");
+// ── Database cache ───────────────────────────────────────────────────
+const dbCache = new Map();
+function getSqliteDb(name) {
+    let db = dbCache.get(name);
+    if (db)
+        return { db, created: false };
+    db = (0, expo_sqlite_1.openDatabaseSync)(name);
+    dbCache.set(name, db);
+    return { db, created: true };
+}
+// ── WebSQLTransaction ────────────────────────────────────────────────
+class WebSQLTransaction {
+    constructor() {
+        /** @internal */
+        this._queue = [];
+    }
+    executeSql(sql, args, successCb, errorCb) {
+        this._queue.push({ sql, args: args ?? [], successCb, errorCb });
+    }
+}
+exports.WebSQLTransaction = WebSQLTransaction;
+// ── Helpers ──────────────────────────────────────────────────────────
+function isRead(sql) {
+    const trimmed = sql.trimStart().toUpperCase();
+    return trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA");
+}
+function buildResultSet(db, sql, args) {
+    if (isRead(sql)) {
+        const rows = db.getAllSync(sql, args);
+        return {
+            insertId: 0,
+            rowsAffected: 0,
+            rows: {
+                length: rows.length,
+                item(i) {
+                    return rows[i];
+                },
+            },
+        };
+    }
+    const result = db.runSync(sql, args);
+    return {
+        insertId: result.lastInsertRowId,
+        rowsAffected: result.changes,
+        rows: {
+            length: 0,
+            item(_i) {
+                return undefined;
+            },
+        },
+    };
+}
+function drainQueue(db, tx) {
+    // Process until the queue is empty.  Success callbacks may enqueue
+    // more statements, so we loop rather than iterate a snapshot.
+    while (tx._queue.length > 0) {
+        const stmt = tx._queue.shift();
+        try {
+            const rs = buildResultSet(db, stmt.sql, stmt.args);
+            if (stmt.successCb) {
+                stmt.successCb(tx, rs);
+            }
+        }
+        catch (err) {
+            const sqlError = {
+                code: 0,
+                message: err?.message ?? String(err),
+            };
+            if (stmt.errorCb) {
+                const shouldContinue = stmt.errorCb(tx, sqlError);
+                if (shouldContinue === true) {
+                    // Error handler returned true → swallow error and continue
+                    continue;
+                }
+            }
+            // Abort the transaction
+            throw err;
+        }
+    }
+}
+// ── WebSQLDatabase ───────────────────────────────────────────────────
+class WebSQLDatabase {
+    constructor(db, version) {
+        this._db = db;
+        this.version = version;
+    }
+    transaction(callback, errorCb, successCb) {
+        // WebSQL is async/callback-based.  Schedule via macrotask so the
+        // caller's subsequent code runs first (matches browser behavior).
+        setTimeout(() => {
+            const tx = new WebSQLTransaction();
+            try {
+                // Let the caller enqueue statements
+                callback(tx);
+                // Execute everything inside a real SQLite transaction
+                this._db.withTransactionSync(() => {
+                    drainQueue(this._db, tx);
+                });
+                if (successCb)
+                    successCb();
+            }
+            catch (err) {
+                const sqlError = {
+                    code: 0,
+                    message: err?.message ?? String(err),
+                };
+                if (errorCb) {
+                    errorCb(sqlError);
+                }
+            }
+        }, 0);
+    }
+    readTransaction(callback, errorCb, successCb) {
+        // Reads go through the same path — SQLite handles concurrency.
+        this.transaction(callback, errorCb, successCb);
+    }
+}
+exports.WebSQLDatabase = WebSQLDatabase;
+// ── openDatabase (WebSQL entry point) ────────────────────────────────
+function openDatabase(name, version, _displayName, _estimatedSize, _creationCallback) {
+    const { db: sqliteDb, created } = getSqliteDb(name);
+    const wsdb = new WebSQLDatabase(sqliteDb, version);
+    if (created && _creationCallback) {
+        _creationCallback(wsdb);
+    }
+    return wsdb;
+}

package/dist/cjs/repositories/migrations/contractRepositoryImpl.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractRepositoryImpl = exports.getCollectionStorageKey = exports.getContractStorageKey = void 0;
+const getContractStorageKey = (id, key) => `contract:${id}:${key}`;
+exports.getContractStorageKey = getContractStorageKey;
+const getCollectionStorageKey = (type) => `collection:${type}`;
+exports.getCollectionStorageKey = getCollectionStorageKey;
+/**
+ * @deprecated This is only to be used in migration from storage V1
+ */
+class ContractRepositoryImpl {
+    constructor(storage) {
+        this.version = 1;
+        this.storage = storage;
+    }
+    async getContractData(contractId, key) {
+        const stored = await this.storage.getItem((0, exports.getContractStorageKey)(contractId, key));
+        if (!stored)
+            return null;
+        try {
+            const data = JSON.parse(stored);
+            return data;
+        }
+        catch (error) {
+            console.error(`Failed to parse contract data for ${contractId}:${key}:`, error);
+            return null;
+        }
+    }
+    async setContractData(contractId, key, data) {
+        try {
+            await this.storage.setItem((0, exports.getContractStorageKey)(contractId, key), JSON.stringify(data));
+        }
+        catch (error) {
+            console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async deleteContractData(contractId, key) {
+        try {
+            await this.storage.removeItem((0, exports.getContractStorageKey)(contractId, key));
+        }
+        catch (error) {
+            console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async getContractCollection(contractType) {
+        const stored = await this.storage.getItem((0, exports.getCollectionStorageKey)(contractType));
+        if (!stored)
+            return [];
+        try {
+            const collection = JSON.parse(stored);
+            return collection;
+        }
+        catch (error) {
+            console.error(`Failed to parse contract collection ${contractType}:`, error);
+            return [];
+        }
+    }
+    async saveToContractCollection(contractType, item, idField) {
+        const collection = await this.getContractCollection(contractType);
+        // Validate that the item has the required id field
+        const itemId = item[idField];
+        if (itemId === undefined || itemId === null) {
+            throw new Error(`Item is missing required field '${String(idField)}'`);
+        }
+        // Find existing item index without mutating the original collection
+        const existingIndex = collection.findIndex((i) => i[idField] === itemId);
+        // Build new collection without mutating the cached one
+        let newCollection;
+        if (existingIndex !== -1) {
+            // Replace existing item
+            newCollection = [
+                ...collection.slice(0, existingIndex),
+                item,
+                ...collection.slice(existingIndex + 1),
+            ];
+        }
+        else {
+            // Add new item
+            newCollection = [...collection, item];
+        }
+        try {
+            await this.storage.setItem((0, exports.getCollectionStorageKey)(contractType), JSON.stringify(newCollection));
+        }
+        catch (error) {
+            console.error(`Failed to persist contract collection ${contractType}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async removeFromContractCollection(contractType, id, idField) {
+        // Validate input parameters
+        if (id === undefined || id === null) {
+            throw new Error(`Invalid id provided for removal: ${String(id)}`);
+        }
+        const collection = await this.getContractCollection(contractType);
+        // Build new collection without the specified item
+        const filtered = collection.filter((item) => item[idField] !== id);
+        try {
+            await this.storage.setItem((0, exports.getCollectionStorageKey)(contractType), JSON.stringify(filtered));
+        }
+        catch (error) {
+            console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    // The following methods are implemented for compatibility with the new ContractRepository interface
+    // but aren't used.
+    async getContracts(_) {
+        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
+    }
+    async saveContract(_) {
+        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
+    }
+    async deleteContract(_) {
+        throw new TypeError("Method not implemented, this is a legacy class and should only be used for migrating data.");
+    }
+    // used only for tests
+    async clear() {
+        await this.storage.clear();
+    }
+    async [Symbol.asyncDispose]() {
+        // deprecated StorageAdapter doesn't have a `close()` method
+        return;
+    }
+}
+exports.ContractRepositoryImpl = ContractRepositoryImpl;

package/dist/cjs/repositories/migrations/fromStorageAdapter.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_KEY = void 0;
+exports.getMigrationStatus = getMigrationStatus;
+exports.requiresMigration = requiresMigration;
+exports.rollbackMigration = rollbackMigration;
+exports.migrateWalletRepository = migrateWalletRepository;
+const walletRepositoryImpl_1 = require("./walletRepositoryImpl");
+const MIGRATION_KEY = (repoType) => `migration-from-storage-adapter-${repoType}`;
+exports.MIGRATION_KEY = MIGRATION_KEY;
+async function getMigrationStatus(repoType, storageAdapter) {
+    try {
+        const migration = await storageAdapter.getItem((0, exports.MIGRATION_KEY)(repoType));
+        if (migration === "done")
+            return "done";
+        if (migration === "in-progress")
+            return "in-progress";
+        return "pending";
+    }
+    catch (e) {
+        if (e instanceof DOMException && e.name === "NotFoundError")
+            return "not-needed";
+        throw e;
+    }
+}
+async function requiresMigration(repoType, storageAdapter) {
+    const status = await getMigrationStatus(repoType, storageAdapter);
+    return status === "pending" || status === "in-progress";
+}
+async function rollbackMigration(repoType, storageAdapter) {
+    await storageAdapter.removeItem((0, exports.MIGRATION_KEY)(repoType));
+}
+/**
+ * Migrate wallet data from the legacy storage adapter to the new one.
+ * It accepts both onchain and offchain addresses, make sure to pass both.
+ *
+ * @param storageAdapter
+ * @param fresh
+ * @param addresses
+ */
+async function migrateWalletRepository(storageAdapter, fresh, addresses) {
+    const migrate = await requiresMigration("wallet", storageAdapter);
+    if (!migrate)
+        return;
+    await storageAdapter.setItem((0, exports.MIGRATION_KEY)("wallet"), "in-progress");
+    const old = new walletRepositoryImpl_1.WalletRepositoryImpl(storageAdapter);
+    const walletData = await old.getWalletState();
+    const onchainAddrData = await Promise.all(addresses.onchain.map(async (address) => {
+        const utxos = await old.getUtxos(address);
+        return { address, utxos };
+    }));
+    const offchainAddrData = await Promise.all(addresses.offchain.map(async (address) => {
+        const vtxos = await old.getVtxos(address);
+        const txs = await old.getTransactionHistory(address);
+        return { address, vtxos, txs };
+    }));
+    await Promise.all([
+        walletData && fresh.saveWalletState(walletData),
+        ...offchainAddrData.map((addressData) => Promise.all([
+            fresh.saveVtxos(addressData.address, addressData.vtxos),
+            fresh.saveTransactions(addressData.address, addressData.txs),
+        ])),
+        ...onchainAddrData.map((addressData) => fresh.saveUtxos(addressData.address, addressData.utxos)),
+    ]);
+    await storageAdapter.setItem((0, exports.MIGRATION_KEY)("wallet"), "done");
+}

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletRepositoryImpl = void 0;
+const base_1 = require("@scure/base");
+const btc_signer_1 = require("@scure/btc-signer");
+const getVtxosStorageKey = (address) => `vtxos:${address}`;
+const getUtxosStorageKey = (address) => `utxos:${address}`;
+const getTransactionsStorageKey = (address) => `tx:${address}`;
+const walletStateStorageKey = "wallet:state";
+// Utility functions for (de)serializing complex structures
+const serializeVtxo = (v) => ({
+    ...v,
+    tapTree: base_1.hex.encode(v.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
+    extraWitness: v.extraWitness?.map(base_1.hex.encode),
+});
+const serializeUtxo = (u) => ({
+    ...u,
+    tapTree: base_1.hex.encode(u.tapTree),
+    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
+    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
+    extraWitness: u.extraWitness?.map(base_1.hex.encode),
+});
+const deserializeVtxo = (o) => ({
+    ...o,
+    createdAt: new Date(o.createdAt),
+    tapTree: base_1.hex.decode(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(base_1.hex.decode),
+});
+const deserializeUtxo = (o) => ({
+    ...o,
+    tapTree: base_1.hex.decode(o.tapTree),
+    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
+    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
+    extraWitness: o.extraWitness?.map(base_1.hex.decode),
+});
+const serializeTapLeaf = ([cb, s]) => ({
+    cb: base_1.hex.encode(btc_signer_1.TaprootControlBlock.encode(cb)),
+    s: base_1.hex.encode(s),
+});
+const deserializeTapLeaf = (t) => {
+    const cb = btc_signer_1.TaprootControlBlock.decode(base_1.hex.decode(t.cb));
+    const s = base_1.hex.decode(t.s);
+    return [cb, s];
+};
+/**
+ * @deprecated This is only to be used in migration from storage V1
+ */
+class WalletRepositoryImpl {
+    constructor(storage) {
+        this.version = 1;
+        this.storage = storage;
+    }
+    async getVtxos(address) {
+        const stored = await this.storage.getItem(getVtxosStorageKey(address));
+        if (!stored)
+            return [];
+        try {
+            const parsed = JSON.parse(stored);
+            return parsed.map(deserializeVtxo);
+        }
+        catch (error) {
+            console.error(`Failed to parse VTXOs for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveVtxos(address, vtxos) {
+        const storedVtxos = await this.getVtxos(address);
+        for (const vtxo of vtxos) {
+            const existing = storedVtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
+            if (existing !== -1) {
+                storedVtxos[existing] = vtxo;
+            }
+            else {
+                storedVtxos.push(vtxo);
+            }
+        }
+        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(storedVtxos.map(serializeVtxo)));
+    }
+    async clearVtxos(address) {
+        return this.deleteVtxos(address);
+    }
+    async deleteVtxos(address) {
+        await this.storage.removeItem(getVtxosStorageKey(address));
+    }
+    async getUtxos(address) {
+        const stored = await this.storage.getItem(getUtxosStorageKey(address));
+        if (!stored)
+            return [];
+        try {
+            const parsed = JSON.parse(stored);
+            return parsed.map(deserializeUtxo);
+        }
+        catch (error) {
+            console.error(`Failed to parse UTXOs for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveUtxos(address, utxos) {
+        const storedUtxos = await this.getUtxos(address);
+        utxos.forEach((utxo) => {
+            const existing = storedUtxos.findIndex((u) => u.txid === utxo.txid && u.vout === utxo.vout);
+            if (existing !== -1) {
+                storedUtxos[existing] = utxo;
+            }
+            else {
+                storedUtxos.push(utxo);
+            }
+        });
+        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(storedUtxos.map(serializeUtxo)));
+    }
+    async clearUtxos(address) {
+        return this.deleteVtxos(address);
+    }
+    async deleteUtxos(address) {
+        await this.storage.removeItem(getUtxosStorageKey(address));
+    }
+    async getTransactionHistory(address) {
+        const storageKey = getTransactionsStorageKey(address);
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored)
+            return [];
+        try {
+            return JSON.parse(stored);
+        }
+        catch (error) {
+            console.error(`Failed to parse transactions for address ${address}:`, error);
+            return [];
+        }
+    }
+    async saveTransactions(address, txs) {
+        const storedTransactions = await this.getTransactionHistory(address);
+        for (const tx of txs) {
+            const existing = storedTransactions.findIndex((t) => t.key.boardingTxid === tx.key.boardingTxid &&
+                t.key.commitmentTxid === tx.key.commitmentTxid &&
+                t.key.arkTxid === tx.key.arkTxid);
+            if (existing !== -1) {
+                storedTransactions[existing] = tx;
+            }
+            else {
+                storedTransactions.push(tx);
+            }
+        }
+        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions));
+    }
+    async clearTransactions(address) {
+        return this.deleteTransactions(address);
+    }
+    async deleteTransactions(address) {
+        await this.storage.removeItem(getTransactionsStorageKey(address));
+    }
+    async getWalletState() {
+        const stored = await this.storage.getItem(walletStateStorageKey);
+        if (!stored)
+            return null;
+        try {
+            const state = JSON.parse(stored);
+            return state;
+        }
+        catch (error) {
+            console.error("Failed to parse wallet state:", error);
+            return null;
+        }
+    }
+    async saveWalletState(state) {
+        await this.storage.setItem(walletStateStorageKey, JSON.stringify(state));
+    }
+    // New method added in V2, not implemented for legacy
+    async clear() {
+        throw new Error("Method not implemented.");
+    }
+    async [Symbol.asyncDispose]() {
+        // deprecated StorageAdapter doesn't have a `close()` method
+        return;
+    }
+}
+exports.WalletRepositoryImpl = WalletRepositoryImpl;

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealmContractRepository = void 0;
+/**
+ * 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.
+ */
+class RealmContractRepository {
+    constructor(realm) {
+        this.realm = realm;
+        this.version = 1;
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────
+    async ensureInit() {
+        // Realm handles schema on open — nothing to initialise.
+    }
+    async [Symbol.asyncDispose]() {
+        // no-op — consumer owns the Realm lifecycle
+    }
+    // ── Clear ──────────────────────────────────────────────────────────
+    async clear() {
+        await this.ensureInit();
+        this.realm.write(() => {
+            this.realm.delete(this.realm.objects("ArkContract"));
+        });
+    }
+    // ── Contract management ────────────────────────────────────────────
+    async getContracts(filter) {
+        await this.ensureInit();
+        let results = this.realm.objects("ArkContract");
+        if (filter) {
+            const filterParts = [];
+            const filterArgs = [];
+            let argIndex = 0;
+            argIndex = this.addFilterCondition(filterParts, filterArgs, "script", filter.script, argIndex);
+            argIndex = this.addFilterCondition(filterParts, filterArgs, "state", filter.state, argIndex);
+            argIndex = this.addFilterCondition(filterParts, filterArgs, "type", filter.type, argIndex);
+            if (filterParts.length > 0) {
+                const query = filterParts.join(" AND ");
+                results = results.filtered(query, ...filterArgs);
+            }
+        }
+        return [...results].map(contractObjectToDomain);
+    }
+    async saveContract(contract) {
+        await this.ensureInit();
+        this.realm.write(() => {
+            this.realm.create("ArkContract", {
+                script: contract.script,
+                address: contract.address,
+                type: contract.type,
+                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)
+                    : null,
+            }, "modified");
+        });
+    }
+    async deleteContract(script) {
+        await this.ensureInit();
+        this.realm.write(() => {
+            const toDelete = this.realm
+                .objects("ArkContract")
+                .filtered("script == $0", script);
+            this.realm.delete(toDelete);
+        });
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────
+    addFilterCondition(parts, args, column, value, argIndex) {
+        if (value === undefined)
+            return argIndex;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return argIndex;
+            const conditions = value.map((_, i) => {
+                return `${column} == $${argIndex + i}`;
+            });
+            parts.push(`(${conditions.join(" OR ")})`);
+            args.push(...value);
+            return argIndex + value.length;
+        }
+        else {
+            parts.push(`${column} == $${argIndex}`);
+            args.push(value);
+            return argIndex + 1;
+        }
+    }
+}
+exports.RealmContractRepository = RealmContractRepository;
+// ── Realm object → Domain converter ──────────────────────────────────────
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function contractObjectToDomain(obj) {
+    const contract = {
+        script: obj.script,
+        address: obj.address,
+        type: obj.type,
+        state: obj.state,
+        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;
+    }
+    if (obj.metadataJson !== null && obj.metadataJson !== undefined) {
+        contract.metadata = JSON.parse(obj.metadataJson);
+    }
+    return contract;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });