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

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/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;

package/dist/cjs/storage/fileSystem.js

@@ -0,0 +1,138 @@
+"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.FileSystemStorageAdapter = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class FileSystemStorageAdapter {
+    constructor(dirPath) {
+        // Normalize and resolve the storage base path once
+        this.basePath = path.resolve(dirPath).replace(/[/\\]+$/, "");
+    }
+    validateAndGetFilePath(key) {
+        // Reject dangerous keys
+        if (key === "." || key === "..") {
+            throw new Error("Invalid key: '.' and '..' are not allowed");
+        }
+        // Check for null bytes
+        if (key.includes("\0")) {
+            throw new Error("Invalid key: null bytes are not allowed");
+        }
+        // Check for path traversal attempts before normalization
+        if (key.includes("..")) {
+            throw new Error("Invalid key: directory traversal is not allowed");
+        }
+        // Check for reserved Windows names (case-insensitive)
+        const reservedNames = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+        const keyWithoutExt = key.split(".")[0];
+        if (reservedNames.test(keyWithoutExt)) {
+            throw new Error(`Invalid key: '${key}' uses a reserved Windows name`);
+        }
+        // Check for trailing spaces or dots
+        if (key.endsWith(" ") || key.endsWith(".")) {
+            throw new Error("Invalid key: trailing spaces or dots are not allowed");
+        }
+        // Normalize path separators and sanitize key
+        const normalizedKey = key
+            .replace(/[/\\]/g, "_")
+            .replace(/[^a-zA-Z0-9._-]/g, "_");
+        // Resolve the full path and check for directory traversal
+        const resolved = path.resolve(this.basePath, normalizedKey);
+        const relative = path.relative(this.basePath, resolved);
+        // Reject if trying to escape the base directory
+        if (relative.startsWith("..") || relative.includes(path.sep + "..")) {
+            throw new Error("Invalid key: directory traversal is not allowed");
+        }
+        return resolved;
+    }
+    async ensureDirectory() {
+        try {
+            await fs.access(this.basePath);
+        }
+        catch {
+            await fs.mkdir(this.basePath, { recursive: true });
+        }
+    }
+    async getItem(key) {
+        try {
+            const filePath = this.validateAndGetFilePath(key);
+            const data = await fs.readFile(filePath, "utf-8");
+            return data;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            console.error(`Failed to read file for key ${key}:`, error);
+            return null;
+        }
+    }
+    async setItem(key, value) {
+        try {
+            await this.ensureDirectory();
+            const filePath = this.validateAndGetFilePath(key);
+            await fs.writeFile(filePath, value, "utf-8");
+        }
+        catch (error) {
+            console.error(`Failed to write file for key ${key}:`, error);
+            throw error;
+        }
+    }
+    async removeItem(key) {
+        try {
+            const filePath = this.validateAndGetFilePath(key);
+            await fs.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                console.error(`Failed to remove file for key ${key}:`, error);
+            }
+        }
+    }
+    async clear() {
+        try {
+            const entries = await fs.readdir(this.basePath);
+            await Promise.all(entries.map(async (entry) => {
+                const entryPath = path.join(this.basePath, entry);
+                // Use fs.rm with recursive option to handle both files and directories
+                await fs.rm(entryPath, { recursive: true, force: true });
+            }));
+        }
+        catch (error) {
+            console.error("Failed to clear storage directory:", error);
+        }
+    }
+}
+exports.FileSystemStorageAdapter = FileSystemStorageAdapter;

package/dist/cjs/storage/inMemory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorageAdapter = void 0;
+class InMemoryStorageAdapter {
+    constructor() {
+        this.store = new Map();
+    }
+    async getItem(key) {
+        return this.store.get(key) ?? null;
+    }
+    async setItem(key, value) {
+        this.store.set(key, value);
+    }
+    async removeItem(key) {
+        this.store.delete(key);
+    }
+    async clear() {
+        this.store.clear();
+    }
+}
+exports.InMemoryStorageAdapter = InMemoryStorageAdapter;

package/dist/cjs/storage/indexedDB.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBStorageAdapter = void 0;
+class IndexedDBStorageAdapter {
+    constructor(dbName, version = 1) {
+        this.db = null;
+        this.dbName = dbName;
+        this.version = version;
+    }
+    async getDB() {
+        if (this.db)
+            return this.db;
+        const globalObject = typeof window === "undefined" ? self : window;
+        if (!(globalObject && "indexedDB" in globalObject)) {
+            throw new Error("IndexedDB is not available in this environment");
+        }
+        return new Promise((resolve, reject) => {
+            const request = globalObject.indexedDB.open(this.dbName, this.version);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve(this.db);
+            };
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains("storage")) {
+                    db.createObjectStore("storage");
+                }
+            };
+        });
+    }
+    async getItem(key) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(["storage"], "readonly");
+                const store = transaction.objectStore("storage");
+                const request = store.get(key);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => {
+                    resolve(request.result || null);
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to get item for key ${key}:`, error);
+            return null;
+        }
+    }
+    async setItem(key, value) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(["storage"], "readwrite");
+                const store = transaction.objectStore("storage");
+                const request = store.put(value, key);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        }
+        catch (error) {
+            console.error(`Failed to set item for key ${key}:`, error);
+            throw error;
+        }
+    }
+    async removeItem(key) {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(["storage"], "readwrite");
+                const store = transaction.objectStore("storage");
+                const request = store.delete(key);
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        }
+        catch (error) {
+            console.error(`Failed to remove item for key ${key}:`, error);
+        }
+    }
+    async clear() {
+        try {
+            const db = await this.getDB();
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction(["storage"], "readwrite");
+                const store = transaction.objectStore("storage");
+                const request = store.clear();
+                request.onerror = () => reject(request.error);
+                request.onsuccess = () => resolve();
+            });
+        }
+        catch (error) {
+            console.error("Failed to clear storage:", error);
+        }
+    }
+}
+exports.IndexedDBStorageAdapter = IndexedDBStorageAdapter;

package/dist/cjs/storage/localStorage.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageAdapter = void 0;
+class LocalStorageAdapter {
+    getSafeLocalStorage() {
+        try {
+            if (typeof window === "undefined" || !window.localStorage) {
+                return null;
+            }
+            // Test access to ensure localStorage is actually available
+            window.localStorage.length;
+            return window.localStorage;
+        }
+        catch {
+            // localStorage may throw in some environments (e.g., private browsing, disabled storage)
+            return null;
+        }
+    }
+    async getItem(key) {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        return localStorage.getItem(key);
+    }
+    async setItem(key, value) {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        localStorage.setItem(key, value);
+    }
+    async removeItem(key) {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        localStorage.removeItem(key);
+    }
+    async clear() {
+        const localStorage = this.getSafeLocalStorage();
+        if (!localStorage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+        localStorage.clear();
+    }
+}
+exports.LocalStorageAdapter = LocalStorageAdapter;

package/dist/cjs/tree/signingSession.js

@@ -38,7 +38,7 @@ exports.validateTreeSigs = validateTreeSigs;
 const musig2 = __importStar(require("../musig2"));
 const btc_signer_1 = require("@scure/btc-signer");
 const base_1 = require("@scure/base");
-const secp256k1_1 = require("@noble/curves/secp256k1");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
 const utils_1 = require("@scure/btc-signer/utils");
 const unknownFields_1 = require("../utils/unknownFields");
 exports.ErrMissingVtxoGraph = new Error("missing vtxo graph");
@@ -62,7 +62,7 @@ class TreeSignerSession {
         this.rootSharedOutputAmount = rootInputAmount;
     }
     getPublicKey() {
-        return secp256k1_1.secp256k1.getPublicKey(this.secretKey);
+        return secp256k1_js_1.secp256k1.getPublicKey(this.secretKey);
     }
     getNonces() {
         if (!this.graph)
@@ -99,7 +99,7 @@ class TreeSignerSession {
         if (!this.graph)
             throw exports.ErrMissingVtxoGraph;
         const myNonces = new Map();
-        const publicKey = secp256k1_1.secp256k1.getPublicKey(this.secretKey);
+        const publicKey = secp256k1_js_1.secp256k1.getPublicKey(this.secretKey);
         for (const g of this.graph) {
             const nonces = musig2.generateNonces(publicKey);
             myNonces.set(g.txid, nonces);
@@ -156,7 +156,7 @@ async function validateTreeSigs(finalAggregatedKey, sharedOutputAmount, vtxoTree
         const message = g.root.preimageWitnessV1(0, // always first input
         [prevout.script], btc_signer_1.SigHash.DEFAULT, [prevout.amount]);
         // Verify the signature
-        const isValid = secp256k1_1.schnorr.verify(input.tapKeySig, message, finalAggregatedKey);
+        const isValid = secp256k1_js_1.schnorr.verify(input.tapKeySig, message, finalAggregatedKey);
         if (!isValid) {
             throw new Error("invalid signature");
         }

package/dist/cjs/wallet/onchain.js

@@ -17,7 +17,7 @@ const txSizeEstimator_1 = require("../utils/txSizeEstimator");
  *
  * @example
  * ```typescript
- * const wallet = new OnchainWallet(identity, 'mainnet');
+ * const wallet = await OnchainWallet.create(identity, 'mainnet');
  * const balance = await wallet.getBalance();
  * const txid = await wallet.send({
  *   address: 'bc1...',
@@ -26,15 +26,21 @@ const txSizeEstimator_1 = require("../utils/txSizeEstimator");
  * ```
  */
 class OnchainWallet {
-    constructor(identity, network, provider) {
+    constructor(identity, network, onchainP2TR, provider) {
         this.identity = identity;
-        const pubkey = identity.xOnlyPublicKey();
+        this.network = network;
+        this.onchainP2TR = onchainP2TR;
+        this.provider = provider;
+    }
+    static async create(identity, networkName, provider) {
+        const pubkey = await identity.xOnlyPublicKey();
         if (!pubkey) {
             throw new Error("Invalid configured public key");
         }
-        this.provider = provider || new onchain_1.EsploraProvider(onchain_1.ESPLORA_URL[network]);
-        this.network = (0, networks_1.getNetwork)(network);
-        this.onchainP2TR = (0, payment_1.p2tr)(pubkey, undefined, this.network);
+        const network = (0, networks_1.getNetwork)(networkName);
+        const onchainProvider = provider || new onchain_1.EsploraProvider(onchain_1.ESPLORA_URL[networkName]);
+        const onchainP2TR = (0, payment_1.p2tr)(pubkey, undefined, network);
+        return new OnchainWallet(identity, network, onchainP2TR, onchainProvider);
     }
     get address() {
         return this.onchainP2TR.address || "";

package/dist/cjs/wallet/serviceWorker/request.js

@@ -12,13 +12,13 @@ var Request;
     Request.isBase = isBase;
     function isInitWallet(message) {
         return (message.type === "INIT_WALLET" &&
-            "privateKey" in message &&
-            typeof message.privateKey === "string" &&
             "arkServerUrl" in message &&
             typeof message.arkServerUrl === "string" &&
+            "privateKey" in message &&
+            typeof message.privateKey === "string" &&
             ("arkServerPublicKey" in message
-                ? typeof message.arkServerPublicKey === "string" ||
-                    message.arkServerPublicKey === undefined
+                ? message.arkServerPublicKey === undefined ||
+                    typeof message.arkServerPublicKey === "string"
                 : true));
     }
     Request.isInitWallet = isInitWallet;
@@ -69,14 +69,4 @@ var Request;
         return message.type === "GET_STATUS";
     }
     Request.isGetStatus = isGetStatus;
-    function isSign(message) {
-        return (message.type === "SIGN" &&
-            "tx" in message &&
-            typeof message.tx === "string" &&
-            ("inputIndexes" in message && message.inputIndexes != undefined
-                ? Array.isArray(message.inputIndexes) &&
-                    message.inputIndexes.every((index) => typeof index === "number")
-                : true));
-    }
-    Request.isSign = isSign;
 })(Request || (exports.Request = Request = {}));

package/dist/cjs/wallet/serviceWorker/response.js

@@ -175,17 +175,4 @@ var Response;
         };
     }
     Response.clearResponse = clearResponse;
-    function signSuccess(id, tx) {
-        return {
-            type: "SIGN_SUCCESS",
-            success: true,
-            tx,
-            id,
-        };
-    }
-    Response.signSuccess = signSuccess;
-    function isSignSuccess(response) {
-        return response.type === "SIGN_SUCCESS" && response.success === true;
-    }
-    Response.isSignSuccess = isSignSuccess;
 })(Response || (exports.Response = Response = {}));