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

package/dist/esm/script/tapscript.js

@@ -1,6 +1,6 @@
 import * as bip68 from "bip68";
-import { Script, ScriptNum } from "@scure/btc-signer/script";
-import { p2tr_ms } from "@scure/btc-signer/payment";
+import { Script, ScriptNum } from "@scure/btc-signer/script.js";
+import { p2tr_ms } from "@scure/btc-signer/payment.js";
 import { hex } from "@scure/base";
 const MinimalScriptNum = ScriptNum(undefined, true);
 export var TapscriptType;

package/dist/esm/script/vhtlc.js

@@ -1,4 +1,4 @@
-import { Script } from "@scure/btc-signer";
+import { Script } from "@scure/btc-signer/script.js";
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, MultisigTapscript, } from './tapscript.js';
 import { hex } from "@scure/base";
 import { VtxoScript } from './base.js';

package/dist/esm/storage/asyncStorage.js

@@ -0,0 +1,43 @@
+// Note: This requires @react-native-async-storage/async-storage to be installed
+export 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;
+        }
+    }
+}

package/dist/esm/storage/fileSystem.js

@@ -0,0 +1,101 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export 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);
+        }
+    }
+}

package/dist/esm/storage/inMemory.js

@@ -0,0 +1,17 @@
+export 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();
+    }
+}

package/dist/esm/storage/indexedDB.js

@@ -0,0 +1,93 @@
+export 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);
+        }
+    }
+}

package/dist/esm/storage/localStorage.js

@@ -0,0 +1,44 @@
+export 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();
+    }
+}

package/dist/esm/tree/signingSession.js

@@ -1,8 +1,9 @@
 import * as musig2 from '../musig2/index.js';
-import { Script, SigHash } from "@scure/btc-signer";
+import { Script } from "@scure/btc-signer/script.js";
+import { SigHash } from "@scure/btc-signer/transaction.js";
 import { hex } from "@scure/base";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
-import { randomPrivateKeyBytes, sha256x2 } from "@scure/btc-signer/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
+import { randomPrivateKeyBytes, sha256x2 } from "@scure/btc-signer/utils.js";
 import { CosignerPublicKey, getArkPsbtFields } from '../utils/unknownFields.js';
 export const ErrMissingVtxoGraph = new Error("missing vtxo graph");
 export const ErrMissingAggregateKey = new Error("missing aggregate key");

package/dist/esm/tree/txTree.js

@@ -1,7 +1,7 @@
-import { Transaction } from "@scure/btc-signer";
+import { Transaction } from "@scure/btc-signer/transaction.js";
 import { base64 } from "@scure/base";
 import { hex } from "@scure/base";
-import { sha256x2 } from "@scure/btc-signer/utils";
+import { sha256x2 } from "@scure/btc-signer/utils.js";
 /**
  * TxTree is a graph of bitcoin transactions.
  * It is used to represent batch tree created during settlement session

package/dist/esm/tree/validation.js

@@ -1,7 +1,7 @@
 import { hex } from "@scure/base";
-import { Transaction } from "@scure/btc-signer";
+import { Transaction } from "@scure/btc-signer/transaction.js";
 import { base64 } from "@scure/base";
-import { sha256x2 } from "@scure/btc-signer/utils";
+import { sha256x2 } from "@scure/btc-signer/utils.js";
 import { aggregateKeys } from '../musig2/index.js';
 import { CosignerPublicKey, getArkPsbtFields } from '../utils/unknownFields.js';
 export const ErrInvalidSettlementTx = (tx) => new Error(`invalid settlement transaction: ${tx}`);

package/dist/esm/utils/arkTransaction.js

@@ -1,9 +1,9 @@
-import { DEFAULT_SEQUENCE, Transaction } from "@scure/btc-signer";
+import { DEFAULT_SEQUENCE, Transaction, } from "@scure/btc-signer/transaction.js";
 import { CLTVMultisigTapscript, decodeTapscript } from '../script/tapscript.js';
 import { scriptFromTapLeafScript, VtxoScript, } from '../script/base.js';
 import { P2A } from './anchor.js';
 import { hex } from "@scure/base";
-import { sha256x2 } from "@scure/btc-signer/utils";
+import { sha256x2 } from "@scure/btc-signer/utils.js";
 import { setArkPsbtField, VtxoTaprootTree } from './unknownFields.js';
 /**
  * Builds an offchain transaction with checkpoint transactions.

package/dist/esm/utils/unknownFields.js

@@ -1,5 +1,5 @@
 import * as bip68 from "bip68";
-import { RawWitness, ScriptNum } from "@scure/btc-signer";
+import { RawWitness, ScriptNum } from "@scure/btc-signer/script.js";
 import { hex } from "@scure/base";
 /**
  * ArkPsbtFieldKey is the key values for ark psbt fields.

package/dist/esm/wallet/onchain.js

@@ -1,7 +1,7 @@
-import { p2tr } from "@scure/btc-signer/payment";
+import { p2tr } from "@scure/btc-signer/payment.js";
 import { getNetwork } from '../networks.js';
 import { ESPLORA_URL, EsploraProvider, } from '../providers/onchain.js';
-import { Transaction } from "@scure/btc-signer";
+import { Transaction } from "@scure/btc-signer/transaction.js";
 import { findP2AOutput, P2A } from '../utils/anchor.js';
 import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
 /**
@@ -13,7 +13,7 @@ import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
  *
  * @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...',
@@ -22,15 +22,21 @@ import { TxWeightEstimator } from '../utils/txSizeEstimator.js';
  * ```
  */
 export 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 EsploraProvider(ESPLORA_URL[network]);
-        this.network = getNetwork(network);
-        this.onchainP2TR = p2tr(pubkey, undefined, this.network);
+        const network = getNetwork(networkName);
+        const onchainProvider = provider || new EsploraProvider(ESPLORA_URL[networkName]);
+        const onchainP2TR = p2tr(pubkey, undefined, network);
+        return new OnchainWallet(identity, network, onchainP2TR, onchainProvider);
     }
     get address() {
         return this.onchainP2TR.address || "";

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

@@ -9,13 +9,13 @@ export 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;
@@ -66,14 +66,4 @@ export 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 || (Request = {}));

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

@@ -172,17 +172,4 @@ export 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 || (Response = {}));