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

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

@@ -1,171 +1,2 @@
 "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 toHex = (b) => (b ? base_1.hex.encode(b) : undefined);
-const fromHex = (h) => h ? base_1.hex.decode(h) : undefined;
-const serializeTapLeaf = ([cb, s]) => ({
-    cb: base_1.hex.encode(btc_signer_1.TaprootControlBlock.encode(cb)),
-    s: base_1.hex.encode(s),
-});
-const serializeVtxo = (v) => ({
-    ...v,
-    tapTree: toHex(v.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(v.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(v.intentTapLeafScript),
-    extraWitness: v.extraWitness?.map(toHex),
-});
-const serializeUtxo = (u) => ({
-    ...u,
-    tapTree: toHex(u.tapTree),
-    forfeitTapLeafScript: serializeTapLeaf(u.forfeitTapLeafScript),
-    intentTapLeafScript: serializeTapLeaf(u.intentTapLeafScript),
-    extraWitness: u.extraWitness?.map(toHex),
-});
-const deserializeTapLeaf = (t) => {
-    const cb = btc_signer_1.TaprootControlBlock.decode(fromHex(t.cb));
-    const s = fromHex(t.s);
-    return [cb, s];
-};
-const deserializeVtxo = (o) => ({
-    ...o,
-    createdAt: new Date(o.createdAt),
-    tapTree: fromHex(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(fromHex),
-});
-const deserializeUtxo = (o) => ({
-    ...o,
-    tapTree: fromHex(o.tapTree),
-    forfeitTapLeafScript: deserializeTapLeaf(o.forfeitTapLeafScript),
-    intentTapLeafScript: deserializeTapLeaf(o.intentTapLeafScript),
-    extraWitness: o.extraWitness?.map(fromHex),
-});
-class WalletRepositoryImpl {
-    constructor(storage) {
-        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 removeVtxo(address, vtxoId) {
-        const vtxos = await this.getVtxos(address);
-        const [txid, vout] = vtxoId.split(":");
-        const filtered = vtxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        await this.storage.setItem(getVtxosStorageKey(address), JSON.stringify(filtered.map(serializeVtxo)));
-    }
-    async clearVtxos(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 removeUtxo(address, utxoId) {
-        const utxos = await this.getUtxos(address);
-        const [txid, vout] = utxoId.split(":");
-        const filtered = utxos.filter((v) => !(v.txid === txid && v.vout === parseInt(vout, 10)));
-        await this.storage.setItem(getUtxosStorageKey(address), JSON.stringify(filtered.map(serializeUtxo)));
-    }
-    async clearUtxos(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 === tx.key);
-            if (existing !== -1) {
-                storedTransactions[existing] = tx;
-            }
-            else {
-                storedTransactions.push(tx);
-            }
-        }
-        await this.storage.setItem(getTransactionsStorageKey(address), JSON.stringify(storedTransactions));
-    }
-    async clearTransactions(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));
-    }
-}
-exports.WalletRepositoryImpl = WalletRepositoryImpl;

package/dist/cjs/script/base.js

@@ -1,8 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VtxoScript = exports.TapTreeCoder = void 0;
 exports.scriptFromTapLeafScript = scriptFromTapLeafScript;
+exports.getSequence = getSequence;
 const btc_signer_1 = require("@scure/btc-signer");
+const bip68 = __importStar(require("bip68"));
 const payment_js_1 = require("@scure/btc-signer/payment.js");
 const psbt_js_1 = require("@scure/btc-signer/psbt.js");
 const base_1 = require("@scure/base");
@@ -95,3 +130,22 @@ class VtxoScript {
     }
 }
 exports.VtxoScript = VtxoScript;
+function getSequence(tapLeafScript) {
+    let sequence = undefined;
+    try {
+        const scriptWithLeafVersion = tapLeafScript[1];
+        const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
+        try {
+            const params = tapscript_1.CSVMultisigTapscript.decode(script).params;
+            sequence = bip68.encode(params.timelock.type === "blocks"
+                ? { blocks: Number(params.timelock.value) }
+                : { seconds: Number(params.timelock.value) });
+        }
+        catch {
+            const params = tapscript_1.CLTVMultisigTapscript.decode(script).params;
+            sequence = Number(params.absoluteTimelock);
+        }
+    }
+    catch { }
+    return sequence;
+}

package/dist/cjs/script/delegate.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegateVtxo = void 0;
+const default_1 = require("./default");
+const tapscript_1 = require("./tapscript");
+const base_1 = require("./base");
+const base_2 = require("@scure/base");
+/**
+ * DelegateVtxo extends DefaultVtxo with an extra delegator path
+ */
+var DelegateVtxo;
+(function (DelegateVtxo) {
+    /**
+     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DelegateVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     *     delegatePubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends base_1.VtxoScript {
+        constructor(options) {
+            const defaultVtxo = new default_1.DefaultVtxo.Script(options);
+            const { delegatePubKey, pubKey, serverPubKey } = options;
+            const delegateScript = tapscript_1.MultisigTapscript.encode({
+                pubkeys: [pubKey, delegatePubKey, serverPubKey],
+            }).script;
+            super([...defaultVtxo.scripts, delegateScript]);
+            this.options = options;
+            this.defaultVtxo = defaultVtxo;
+            this.delegateScript = base_2.hex.encode(delegateScript);
+        }
+        forfeit() {
+            return this.findLeaf(this.defaultVtxo.forfeitScript);
+        }
+        exit() {
+            return this.findLeaf(this.defaultVtxo.exitScript);
+        }
+        delegate() {
+            return this.findLeaf(this.delegateScript);
+        }
+    }
+    DelegateVtxo.Script = Script;
+})(DelegateVtxo || (exports.DelegateVtxo = DelegateVtxo = {}));

package/dist/cjs/storage/asyncStorage.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncStorageAdapter = void 0;
-// Note: This requires @react-native-async-storage/async-storage to be installed
+/**
+ * @deprecated Use repositories instead
+ * Note: This requires @react-native-async-storage/async-storage to be installed
+ */
 class AsyncStorageAdapter {
     constructor() {
         try {

package/dist/cjs/storage/fileSystem.js

@@ -36,6 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystemStorageAdapter = void 0;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+/**
+ * @deprecated Use repositories instead
+ */
 class FileSystemStorageAdapter {
     constructor(dirPath) {
         // Normalize and resolve the storage base path once