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

package/dist/esm/identity/singleKey.js

@@ -1,7 +1,8 @@
-import { pubSchnorr, randomPrivateKeyBytes } from "@scure/btc-signer/utils";
+import { pubSchnorr, randomPrivateKeyBytes, sha256, } from "@scure/btc-signer/utils";
 import { hex } from "@scure/base";
 import { SigHash } from "@scure/btc-signer";
 import { TreeSignerSession } from '../tree/signingSession.js';
+import { schnorr } from "@noble/secp256k1";
 const ZERO_32 = new Uint8Array(32).fill(0);
 const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
 /**
@@ -15,6 +16,9 @@ const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
  * // Create from raw bytes
  * const key = SingleKey.fromPrivateKey(privateKeyBytes);
  *
+ * // Create random key
+ * const randomKey = SingleKey.fromRandomBytes();
+ *
  * // Sign a transaction
  * const signedTx = await key.sign(transaction);
  * ```
@@ -29,6 +33,17 @@ export class SingleKey {
     static fromHex(privateKeyHex) {
         return new SingleKey(hex.decode(privateKeyHex));
     }
+    static fromRandomBytes() {
+        return new SingleKey(randomPrivateKeyBytes());
+    }
+    /**
+     * Export the private key as a hex string.
+     *
+     * @returns The private key as a hex string
+     */
+    toHex() {
+        return hex.encode(this.key);
+    }
     async sign(tx, inputIndexes) {
         const txCpy = tx.clone();
         if (!inputIndexes) {
@@ -56,9 +71,13 @@ export class SingleKey {
         return txCpy;
     }
     xOnlyPublicKey() {
-        return pubSchnorr(this.key);
+        return Promise.resolve(pubSchnorr(this.key));
     }
     signerSession() {
         return TreeSignerSession.random();
     }
+    async signMessage(message) {
+        const msgBytes = new TextEncoder().encode(message);
+        return schnorr.sign(sha256(msgBytes), this.key);
+    }
 }

package/dist/esm/index.js

@@ -21,11 +21,12 @@ import { buildOffchainTx, } from './utils/arkTransaction.js';
 import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from './utils/unknownFields.js';
 import { BIP322 } from './bip322/index.js';
 import { ArkNote } from './arknote/index.js';
-import { IndexedDBVtxoRepository } from './wallet/serviceWorker/db/vtxo/idb.js';
 import { networks } from './networks.js';
 import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
 import { P2A } from './utils/anchor.js';
 import { Unroll } from './wallet/unroll.js';
+import { WalletRepositoryImpl } from './repositories/walletRepository.js';
+import { ContractRepositoryImpl } from './repositories/contractRepository.js';
 export { 
 // Wallets
 Wallet, SingleKey, OnchainWallet, Ramps, 
@@ -47,8 +48,8 @@ buildOffchainTx, waitForIncomingFunds,
 ArkNote, 
 // Network
 networks, 
-// Database
-IndexedDBVtxoRepository, 
+// Repositories
+WalletRepositoryImpl, ContractRepositoryImpl, 
 // BIP322
 BIP322, 
 // TxTree

package/dist/esm/musig2/keys.js

@@ -1,5 +1,5 @@
 import * as musig from "@scure/btc-signer/musig2";
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 // Aggregates multiple public keys according to the MuSig2 algorithm
 export function aggregateKeys(publicKeys, sort, options = {}) {
     if (sort) {
@@ -8,14 +8,14 @@ export function aggregateKeys(publicKeys, sort, options = {}) {
     const { aggPublicKey: preTweakedKey } = musig.keyAggregate(publicKeys);
     if (!options.taprootTweak) {
         return {
-            preTweakedKey: preTweakedKey.toRawBytes(true),
-            finalKey: preTweakedKey.toRawBytes(true),
+            preTweakedKey: preTweakedKey.toBytes(true),
+            finalKey: preTweakedKey.toBytes(true),
         };
     }
-    const tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.toRawBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
+    const tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.toBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
     const { aggPublicKey: finalKey } = musig.keyAggregate(publicKeys, [tweakBytes], [true]);
     return {
-        preTweakedKey: preTweakedKey.toRawBytes(true),
-        finalKey: finalKey.toRawBytes(true),
+        preTweakedKey: preTweakedKey.toBytes(true),
+        finalKey: finalKey.toBytes(true),
     };
 }

package/dist/esm/musig2/sign.js

@@ -1,8 +1,8 @@
 import * as musig from "@scure/btc-signer/musig2";
-import { bytesToNumberBE } from "@noble/curves/abstract/utils";
-import { CURVE } from "@noble/secp256k1";
+import { bytesToNumberBE } from "@noble/curves/utils.js";
+import { Point } from "@noble/secp256k1";
 import { aggregateKeys } from './keys.js';
-import { schnorr } from "@noble/curves/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1.js";
 // Add this error type for decode failures
 export class PartialSignatureError extends Error {
     constructor(message) {
@@ -40,7 +40,7 @@ export class PartialSig {
         }
         // Verify s is less than curve order
         const s = bytesToNumberBE(bytes);
-        if (s >= CURVE.n) {
+        if (s >= Point.CURVE().n) {
             throw new PartialSignatureError("s value overflows curve order");
         }
         // For decode we don't have R, so we'll need to compute it later

package/dist/esm/repositories/contractRepository.js

@@ -0,0 +1,126 @@
+export 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
+        }
+    }
+}

package/dist/esm/repositories/index.js

@@ -0,0 +1,2 @@
+export * from './walletRepository.js';
+export * from './contractRepository.js';

package/dist/esm/repositories/walletRepository.js

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

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);
+        }
+    }
+}