@arkade-os/sdk 0.2.3 → 0.3.0-alpha.1

package/dist/cjs/repositories/contractRepository.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractRepositoryImpl = void 0;
+class ContractRepositoryImpl {
+    constructor(storage) {
+        this.cache = new Map();
+        this.storage = storage;
+    }
+    async getContractData(contractId, key) {
+        const storageKey = `contract:${contractId}:${key}`;
+        const cached = this.cache.get(storageKey);
+        if (cached !== undefined)
+            return cached;
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored)
+            return null;
+        try {
+            const data = JSON.parse(stored);
+            this.cache.set(storageKey, data);
+            return data;
+        }
+        catch (error) {
+            console.error(`Failed to parse contract data for ${contractId}:${key}:`, error);
+            return null;
+        }
+    }
+    async setContractData(contractId, key, data) {
+        const storageKey = `contract:${contractId}:${key}`;
+        try {
+            // First persist to storage, only update cache if successful
+            await this.storage.setItem(storageKey, JSON.stringify(data));
+            this.cache.set(storageKey, data);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to persist contract data for ${contractId}:${key}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async deleteContractData(contractId, key) {
+        const storageKey = `contract:${contractId}:${key}`;
+        try {
+            // First remove from persistent storage, only delete from cache if successful
+            await this.storage.removeItem(storageKey);
+            this.cache.delete(storageKey);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to remove contract data for ${contractId}:${key}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+    async getContractCollection(contractType) {
+        const storageKey = `collection:${contractType}`;
+        const cached = this.cache.get(storageKey);
+        if (cached !== undefined)
+            return cached;
+        const stored = await this.storage.getItem(storageKey);
+        if (!stored) {
+            this.cache.set(storageKey, []);
+            return [];
+        }
+        try {
+            const collection = JSON.parse(stored);
+            this.cache.set(storageKey, collection);
+            return collection;
+        }
+        catch (error) {
+            console.error(`Failed to parse contract collection ${contractType}:`, error);
+            this.cache.set(storageKey, []);
+            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];
+        }
+        const storageKey = `collection:${contractType}`;
+        try {
+            // First persist to storage, only update cache if successful
+            await this.storage.setItem(storageKey, JSON.stringify(newCollection));
+            this.cache.set(storageKey, newCollection);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            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);
+        const storageKey = `collection:${contractType}`;
+        try {
+            // First persist to storage, only update cache if successful
+            await this.storage.setItem(storageKey, JSON.stringify(filtered));
+            this.cache.set(storageKey, filtered);
+        }
+        catch (error) {
+            // Storage operation failed, cache remains unchanged
+            console.error(`Failed to persist contract collection removal for ${contractType}:`, error);
+            throw error; // Rethrow to notify caller of failure
+        }
+    }
+}
+exports.ContractRepositoryImpl = ContractRepositoryImpl;

package/dist/cjs/repositories/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./walletRepository"), exports);
+__exportStar(require("./contractRepository"), exports);

package/dist/cjs/repositories/walletRepository.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletRepositoryImpl = void 0;
+class WalletRepositoryImpl {
+    constructor(storage) {
+        this.storage = storage;
+        this.cache = {
+            vtxos: new Map(),
+            transactions: new Map(),
+            walletState: null,
+            initialized: new Set(),
+        };
+    }
+    async getVtxos(address) {
+        const cacheKey = `vtxos:${address}`;
+        if (this.cache.vtxos.has(address)) {
+            return this.cache.vtxos.get(address);
+        }
+        const stored = await this.storage.getItem(cacheKey);
+        if (!stored) {
+            this.cache.vtxos.set(address, []);
+            return [];
+        }
+        try {
+            const vtxos = JSON.parse(stored);
+            this.cache.vtxos.set(address, vtxos);
+            return vtxos.slice();
+        }
+        catch (error) {
+            console.error(`Failed to parse VTXOs for address ${address}:`, error);
+            this.cache.vtxos.set(address, []);
+            return [];
+        }
+    }
+    async saveVtxo(address, vtxo) {
+        const vtxos = await this.getVtxos(address);
+        const existing = vtxos.findIndex((v) => v.txid === vtxo.txid && v.vout === vtxo.vout);
+        if (existing !== -1) {
+            vtxos[existing] = vtxo;
+        }
+        else {
+            vtxos.push(vtxo);
+        }
+        this.cache.vtxos.set(address, vtxos);
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(vtxos));
+    }
+    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);
+            }
+        }
+        this.cache.vtxos.set(address, storedVtxos);
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(storedVtxos));
+    }
+    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)));
+        this.cache.vtxos.set(address, filtered);
+        await this.storage.setItem(`vtxos:${address}`, JSON.stringify(filtered));
+    }
+    async clearVtxos(address) {
+        this.cache.vtxos.set(address, []);
+        await this.storage.removeItem(`vtxos:${address}`);
+    }
+    async getTransactionHistory(address) {
+        const cacheKey = `tx:${address}`;
+        if (this.cache.transactions.has(address)) {
+            return this.cache.transactions.get(address);
+        }
+        const stored = await this.storage.getItem(cacheKey);
+        if (!stored) {
+            this.cache.transactions.set(address, []);
+            return [];
+        }
+        try {
+            const transactions = JSON.parse(stored);
+            this.cache.transactions.set(address, transactions);
+            return transactions.slice();
+        }
+        catch (error) {
+            console.error(`Failed to parse transactions for address ${address}:`, error);
+            this.cache.transactions.set(address, []);
+            return [];
+        }
+    }
+    async saveTransaction(address, tx) {
+        const transactions = await this.getTransactionHistory(address);
+        const existing = transactions.findIndex((t) => t.id === tx.id);
+        if (existing !== -1) {
+            transactions[existing] = tx;
+        }
+        else {
+            transactions.push(tx);
+            // Sort by timestamp descending
+            transactions.sort((a, b) => b.timestamp - a.timestamp);
+        }
+        this.cache.transactions.set(address, transactions);
+        await this.storage.setItem(`tx:${address}`, JSON.stringify(transactions));
+    }
+    async getWalletState() {
+        if (this.cache.walletState !== null ||
+            this.cache.initialized.has("walletState")) {
+            return this.cache.walletState;
+        }
+        const stored = await this.storage.getItem("wallet:state");
+        if (!stored) {
+            this.cache.walletState = null;
+            this.cache.initialized.add("walletState");
+            return null;
+        }
+        try {
+            const state = JSON.parse(stored);
+            this.cache.walletState = state;
+            this.cache.initialized.add("walletState");
+            return state;
+        }
+        catch (error) {
+            console.error("Failed to parse wallet state:", error);
+            this.cache.walletState = null;
+            this.cache.initialized.add("walletState");
+            return null;
+        }
+    }
+    async saveWalletState(state) {
+        this.cache.walletState = state;
+        await this.storage.setItem("wallet:state", JSON.stringify(state));
+    }
+}
+exports.WalletRepositoryImpl = WalletRepositoryImpl;

package/dist/cjs/script/address.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArkAddress = void 0;
 const base_1 = require("@scure/base");
-const btc_signer_1 = require("@scure/btc-signer");
+const script_js_1 = require("@scure/btc-signer/script.js");
 /**
  * ArkAddress allows to create and decode bech32m encoded ark address.
  * An ark address is composed of:
@@ -66,11 +66,11 @@ class ArkAddress {
     }
     // pkScript is the script that should be used to send non-dust funds to the address
     get pkScript() {
-        return btc_signer_1.Script.encode(["OP_1", this.vtxoTaprootKey]);
+        return script_js_1.Script.encode(["OP_1", this.vtxoTaprootKey]);
     }
     // subdustPkScript is the script that should be used to send sub-dust funds to the address
     get subdustPkScript() {
-        return btc_signer_1.Script.encode(["RETURN", this.vtxoTaprootKey]);
+        return script_js_1.Script.encode(["RETURN", this.vtxoTaprootKey]);
     }
 }
 exports.ArkAddress = ArkAddress;

package/dist/cjs/script/base.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VtxoScript = void 0;
 exports.scriptFromTapLeafScript = scriptFromTapLeafScript;
-const payment_1 = require("@scure/btc-signer/payment");
-const utils_1 = require("@scure/btc-signer/utils");
+const payment_js_1 = require("@scure/btc-signer/payment.js");
+const utils_js_1 = require("@scure/btc-signer/utils.js");
 const address_1 = require("./address");
-const btc_signer_1 = require("@scure/btc-signer");
+const script_js_1 = require("@scure/btc-signer/script.js");
 const base_1 = require("@scure/base");
 const tapscript_1 = require("./tapscript");
 function scriptFromTapLeafScript(leaf) {
@@ -26,8 +26,8 @@ class VtxoScript {
     }
     constructor(scripts) {
         this.scripts = scripts;
-        const tapTree = (0, payment_1.taprootListToTree)(scripts.map((script) => ({ script, leafVersion: payment_1.TAP_LEAF_VERSION })));
-        const payment = (0, payment_1.p2tr)(utils_1.TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
+        const tapTree = (0, payment_js_1.taprootListToTree)(scripts.map((script) => ({ script, leafVersion: payment_js_1.TAP_LEAF_VERSION })));
+        const payment = (0, payment_js_1.p2tr)(utils_js_1.TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
         if (!payment.tapLeafScript ||
             payment.tapLeafScript.length !== scripts.length) {
             throw new Error("invalid scripts");
@@ -43,10 +43,10 @@ class VtxoScript {
         return new address_1.ArkAddress(serverPubKey, this.tweakedPublicKey, prefix);
     }
     get pkScript() {
-        return btc_signer_1.Script.encode(["OP_1", this.tweakedPublicKey]);
+        return script_js_1.Script.encode(["OP_1", this.tweakedPublicKey]);
     }
     onchainAddress(network) {
-        return (0, payment_1.Address)(network).encode({
+        return (0, payment_js_1.Address)(network).encode({
             type: "tr",
             pubkey: this.tweakedPublicKey,
         });

package/dist/cjs/script/tapscript.js

@@ -36,10 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLTVMultisigTapscript = exports.ConditionMultisigTapscript = exports.ConditionCSVMultisigTapscript = exports.CSVMultisigTapscript = exports.MultisigTapscript = exports.TapscriptType = void 0;
 exports.decodeTapscript = decodeTapscript;
 const bip68 = __importStar(require("bip68"));
-const script_1 = require("@scure/btc-signer/script");
-const payment_1 = require("@scure/btc-signer/payment");
+const script_js_1 = require("@scure/btc-signer/script.js");
+const payment_js_1 = require("@scure/btc-signer/payment.js");
 const base_1 = require("@scure/base");
-const MinimalScriptNum = (0, script_1.ScriptNum)(undefined, true);
+const MinimalScriptNum = (0, script_js_1.ScriptNum)(undefined, true);
 var TapscriptType;
 (function (TapscriptType) {
     TapscriptType["Multisig"] = "multisig";
@@ -109,7 +109,7 @@ var MultisigTapscript;
             return {
                 type: TapscriptType.Multisig,
                 params,
-                script: (0, payment_1.p2tr_ms)(params.pubkeys.length, params.pubkeys).script,
+                script: (0, payment_js_1.p2tr_ms)(params.pubkeys.length, params.pubkeys).script,
             };
         }
         const asm = [];
@@ -126,7 +126,7 @@ var MultisigTapscript;
         return {
             type: TapscriptType.Multisig,
             params,
-            script: script_1.Script.encode(asm),
+            script: script_js_1.Script.encode(asm),
         };
     }
     MultisigTapscript.encode = encode;
@@ -151,7 +151,7 @@ var MultisigTapscript;
     MultisigTapscript.decode = decode;
     // <pubkey> CHECKSIG <pubkey> CHECKSIGADD <len_keys> NUMEQUAL
     function decodeChecksigAdd(script) {
-        const asm = script_1.Script.decode(script);
+        const asm = script_js_1.Script.decode(script);
         const pubkeys = [];
         let foundNumEqual = false;
         // Parse through ASM operations
@@ -201,7 +201,7 @@ var MultisigTapscript;
     }
     // <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
     function decodeChecksig(script) {
-        const asm = script_1.Script.decode(script);
+        const asm = script_js_1.Script.decode(script);
         const pubkeys = [];
         // Parse through ASM operations
         for (let i = 0; i < asm.length; i++) {
@@ -278,7 +278,7 @@ var CSVMultisigTapscript;
         ];
         const multisigScript = MultisigTapscript.encode(params);
         const script = new Uint8Array([
-            ...script_1.Script.encode(asm),
+            ...script_js_1.Script.encode(asm),
             ...multisigScript.script,
         ]);
         return {
@@ -292,7 +292,7 @@ var CSVMultisigTapscript;
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
         }
-        const asm = script_1.Script.decode(script);
+        const asm = script_js_1.Script.decode(script);
         if (asm.length < 3) {
             throw new Error(`Invalid script: too short (expected at least 3)`);
         }
@@ -303,7 +303,7 @@ var CSVMultisigTapscript;
         if (asm[1] !== "CHECKSEQUENCEVERIFY" || asm[2] !== "DROP") {
             throw new Error("Invalid script: expected CHECKSEQUENCEVERIFY DROP");
         }
-        const multisigScript = new Uint8Array(script_1.Script.encode(asm.slice(3)));
+        const multisigScript = new Uint8Array(script_js_1.Script.encode(asm.slice(3)));
         let multisig;
         try {
             multisig = MultisigTapscript.decode(multisigScript);
@@ -355,7 +355,7 @@ var ConditionCSVMultisigTapscript;
     function encode(params) {
         const script = new Uint8Array([
             ...params.conditionScript,
-            ...script_1.Script.encode(["VERIFY"]),
+            ...script_js_1.Script.encode(["VERIFY"]),
             ...CSVMultisigTapscript.encode(params).script,
         ]);
         return {
@@ -369,7 +369,7 @@ var ConditionCSVMultisigTapscript;
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
         }
-        const asm = script_1.Script.decode(script);
+        const asm = script_js_1.Script.decode(script);
         if (asm.length < 1) {
             throw new Error(`Invalid script: too short (expected at least 1)`);
         }
@@ -382,8 +382,8 @@ var ConditionCSVMultisigTapscript;
         if (verifyIndex === -1) {
             throw new Error("Invalid script: missing VERIFY operation");
         }
-        const conditionScript = new Uint8Array(script_1.Script.encode(asm.slice(0, verifyIndex)));
-        const csvMultisigScript = new Uint8Array(script_1.Script.encode(asm.slice(verifyIndex + 1)));
+        const conditionScript = new Uint8Array(script_js_1.Script.encode(asm.slice(0, verifyIndex)));
+        const csvMultisigScript = new Uint8Array(script_js_1.Script.encode(asm.slice(verifyIndex + 1)));
         let csvMultisig;
         try {
             csvMultisig = CSVMultisigTapscript.decode(csvMultisigScript);
@@ -430,7 +430,7 @@ var ConditionMultisigTapscript;
     function encode(params) {
         const script = new Uint8Array([
             ...params.conditionScript,
-            ...script_1.Script.encode(["VERIFY"]),
+            ...script_js_1.Script.encode(["VERIFY"]),
             ...MultisigTapscript.encode(params).script,
         ]);
         return {
@@ -444,7 +444,7 @@ var ConditionMultisigTapscript;
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
         }
-        const asm = script_1.Script.decode(script);
+        const asm = script_js_1.Script.decode(script);
         if (asm.length < 1) {
             throw new Error(`Invalid script: too short (expected at least 1)`);
         }
@@ -457,8 +457,8 @@ var ConditionMultisigTapscript;
         if (verifyIndex === -1) {
             throw new Error("Invalid script: missing VERIFY operation");
         }
-        const conditionScript = new Uint8Array(script_1.Script.encode(asm.slice(0, verifyIndex)));
-        const multisigScript = new Uint8Array(script_1.Script.encode(asm.slice(verifyIndex + 1)));
+        const conditionScript = new Uint8Array(script_js_1.Script.encode(asm.slice(0, verifyIndex)));
+        const multisigScript = new Uint8Array(script_js_1.Script.encode(asm.slice(verifyIndex + 1)));
         let multisig;
         try {
             multisig = MultisigTapscript.decode(multisigScript);
@@ -509,7 +509,7 @@ var CLTVMultisigTapscript;
             "CHECKLOCKTIMEVERIFY",
             "DROP",
         ];
-        const timelockedScript = script_1.Script.encode(asm);
+        const timelockedScript = script_js_1.Script.encode(asm);
         const script = new Uint8Array([
             ...timelockedScript,
             ...MultisigTapscript.encode(params).script,
@@ -525,7 +525,7 @@ var CLTVMultisigTapscript;
         if (script.length === 0) {
             throw new Error("Failed to decode: script is empty");
         }
-        const asm = script_1.Script.decode(script);
+        const asm = script_js_1.Script.decode(script);
         if (asm.length < 3) {
             throw new Error(`Invalid script: too short (expected at least 3)`);
         }
@@ -536,7 +536,7 @@ var CLTVMultisigTapscript;
         if (asm[1] !== "CHECKLOCKTIMEVERIFY" || asm[2] !== "DROP") {
             throw new Error("Invalid script: expected CHECKLOCKTIMEVERIFY DROP");
         }
-        const multisigScript = new Uint8Array(script_1.Script.encode(asm.slice(3)));
+        const multisigScript = new Uint8Array(script_js_1.Script.encode(asm.slice(3)));
         let multisig;
         try {
             multisig = MultisigTapscript.decode(multisigScript);

package/dist/cjs/script/vhtlc.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VHTLC = void 0;
-const btc_signer_1 = require("@scure/btc-signer");
+const script_js_1 = require("@scure/btc-signer/script.js");
 const tapscript_1 = require("./tapscript");
 const base_1 = require("@scure/base");
 const base_2 = require("./base");
@@ -158,5 +158,5 @@ var VHTLC;
     }
 })(VHTLC || (exports.VHTLC = VHTLC = {}));
 function preimageConditionScript(preimageHash) {
-    return btc_signer_1.Script.encode(["HASH160", preimageHash, "EQUAL"]);
+    return script_js_1.Script.encode(["HASH160", preimageHash, "EQUAL"]);
 }

package/dist/cjs/storage/asyncStorage.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncStorageAdapter = void 0;
+// Note: This requires @react-native-async-storage/async-storage to be installed
+class AsyncStorageAdapter {
+    constructor() {
+        try {
+            // Dynamic import to avoid errors in non-React Native environments
+            this.AsyncStorage =
+                require("@react-native-async-storage/async-storage").default;
+        }
+        catch (error) {
+            throw new Error("AsyncStorage is not available. Make sure @react-native-async-storage/async-storage is installed in React Native environment.");
+        }
+    }
+    async getItem(key) {
+        return await this.AsyncStorage.getItem(key);
+    }
+    async setItem(key, value) {
+        try {
+            await this.AsyncStorage.setItem(key, value);
+        }
+        catch (error) {
+            console.error(`Failed to set item for key ${key}:`, error);
+            throw error;
+        }
+    }
+    async removeItem(key) {
+        try {
+            await this.AsyncStorage.removeItem(key);
+        }
+        catch (error) {
+            console.error(`Failed to remove item for key ${key}:`, error);
+            throw error;
+        }
+    }
+    async clear() {
+        try {
+            await this.AsyncStorage.clear();
+        }
+        catch (error) {
+            console.error("Failed to clear AsyncStorage:", error);
+            throw error;
+        }
+    }
+}
+exports.AsyncStorageAdapter = AsyncStorageAdapter;