@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/cjs/script/vhtlc.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VHTLC = void 0;
-const btc_signer_1 = require("@scure/btc-signer");
-const tapscript_1 = require("./tapscript");
-const base_1 = require("@scure/base");
-const base_2 = require("./base");
-/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
-var VHTLC;
-(function (VHTLC) {
-    /**
-     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
-     *
-     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
-     * It provides multiple spending paths:
-     *
-     * - **claim**: Receiver can claim funds by revealing the preimage
-     * - **refund**: Sender and receiver can collaboratively refund
-     * - **refundWithoutReceiver**: Sender can refund after locktime expires
-     * - **unilateralClaim**: Receiver can claim unilaterally after delay
-     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
-     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
-     *
-     * @example
-     * ```typescript
-     * const vhtlc = new VHTLC.Script({
-     *   sender: alicePubKey,
-     *   receiver: bobPubKey,
-     *   server: serverPubKey,
-     *   preimageHash: hash160(secret),
-     *   refundLocktime: BigInt(chainTip + 10),
-     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
-     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
-     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
-     * });
-     * ```
-     */
-    class Script extends base_2.VtxoScript {
-        /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
-        constructor(options) {
-            validateOptions(options);
-            const { sender, receiver, server, preimageHash, refundLocktime, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, } = options;
-            const conditionScript = preimageConditionScript(preimageHash);
-            const claimScript = tapscript_1.ConditionMultisigTapscript.encode({
-                conditionScript,
-                pubkeys: [receiver, server],
-            }).script;
-            const refundScript = tapscript_1.MultisigTapscript.encode({
-                pubkeys: [sender, receiver, server],
-            }).script;
-            const refundWithoutReceiverScript = tapscript_1.CLTVMultisigTapscript.encode({
-                absoluteTimelock: refundLocktime,
-                pubkeys: [sender, server],
-            }).script;
-            const unilateralClaimScript = tapscript_1.ConditionCSVMultisigTapscript.encode({
-                conditionScript,
-                timelock: unilateralClaimDelay,
-                pubkeys: [receiver],
-            }).script;
-            const unilateralRefundScript = tapscript_1.CSVMultisigTapscript.encode({
-                timelock: unilateralRefundDelay,
-                pubkeys: [sender, receiver],
-            }).script;
-            const unilateralRefundWithoutReceiverScript = tapscript_1.CSVMultisigTapscript.encode({
-                timelock: unilateralRefundWithoutReceiverDelay,
-                pubkeys: [sender],
-            }).script;
-            super([
-                claimScript,
-                refundScript,
-                refundWithoutReceiverScript,
-                unilateralClaimScript,
-                unilateralRefundScript,
-                unilateralRefundWithoutReceiverScript,
-            ]);
-            this.options = options;
-            this.claimScript = base_1.hex.encode(claimScript);
-            this.refundScript = base_1.hex.encode(refundScript);
-            this.refundWithoutReceiverScript = base_1.hex.encode(refundWithoutReceiverScript);
-            this.unilateralClaimScript = base_1.hex.encode(unilateralClaimScript);
-            this.unilateralRefundScript = base_1.hex.encode(unilateralRefundScript);
-            this.unilateralRefundWithoutReceiverScript = base_1.hex.encode(unilateralRefundWithoutReceiverScript);
-        }
-        /** Return the collaborative claim tapleaf script. */
-        claim() {
-            return this.findLeaf(this.claimScript);
-        }
-        /** Return the collaborative refund tapleaf script. */
-        refund() {
-            return this.findLeaf(this.refundScript);
-        }
-        /** Return the refund-without-receiver tapleaf script. */
-        refundWithoutReceiver() {
-            return this.findLeaf(this.refundWithoutReceiverScript);
-        }
-        /** Return the unilateral claim tapleaf script. */
-        unilateralClaim() {
-            return this.findLeaf(this.unilateralClaimScript);
-        }
-        /** Return the unilateral refund tapleaf script. */
-        unilateralRefund() {
-            return this.findLeaf(this.unilateralRefundScript);
-        }
-        /** Return the unilateral refund-without-receiver tapleaf script. */
-        unilateralRefundWithoutReceiver() {
-            return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
-        }
-    }
-    VHTLC.Script = Script;
-    function validateOptions(options) {
-        const { sender, receiver, server, preimageHash, refundLocktime, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, } = options;
-        if (!preimageHash || preimageHash.length !== 20) {
-            throw new Error("preimage hash must be 20 bytes");
-        }
-        if (!receiver || receiver.length !== 32) {
-            throw new Error("Invalid public key length (receiver)");
-        }
-        if (!sender || sender.length !== 32) {
-            throw new Error("Invalid public key length (sender)");
-        }
-        if (!server || server.length !== 32) {
-            throw new Error("Invalid public key length (server)");
-        }
-        if (typeof refundLocktime !== "bigint" || refundLocktime <= 0n) {
-            throw new Error("refund locktime must be greater than 0");
-        }
-        if (!unilateralClaimDelay ||
-            typeof unilateralClaimDelay.value !== "bigint" ||
-            unilateralClaimDelay.value <= 0n) {
-            throw new Error("unilateral claim delay must greater than 0");
-        }
-        if (unilateralClaimDelay.type === "seconds" &&
-            unilateralClaimDelay.value % 512n !== 0n) {
-            throw new Error("seconds timelock must be multiple of 512");
-        }
-        if (unilateralClaimDelay.type === "seconds" &&
-            unilateralClaimDelay.value < 512n) {
-            throw new Error("seconds timelock must be greater or equal to 512");
-        }
-        if (!unilateralRefundDelay ||
-            typeof unilateralRefundDelay.value !== "bigint" ||
-            unilateralRefundDelay.value <= 0n) {
-            throw new Error("unilateral refund delay must greater than 0");
-        }
-        if (unilateralRefundDelay.type === "seconds" &&
-            unilateralRefundDelay.value % 512n !== 0n) {
-            throw new Error("seconds timelock must be multiple of 512");
-        }
-        if (unilateralRefundDelay.type === "seconds" &&
-            unilateralRefundDelay.value < 512n) {
-            throw new Error("seconds timelock must be greater or equal to 512");
-        }
-        if (!unilateralRefundWithoutReceiverDelay ||
-            typeof unilateralRefundWithoutReceiverDelay.value !== "bigint" ||
-            unilateralRefundWithoutReceiverDelay.value <= 0n) {
-            throw new Error("unilateral refund without receiver delay must greater than 0");
-        }
-        if (unilateralRefundWithoutReceiverDelay.type === "seconds" &&
-            unilateralRefundWithoutReceiverDelay.value % 512n !== 0n) {
-            throw new Error("seconds timelock must be multiple of 512");
-        }
-        if (unilateralRefundWithoutReceiverDelay.type === "seconds" &&
-            unilateralRefundWithoutReceiverDelay.value < 512n) {
-            throw new Error("seconds timelock must be greater or equal to 512");
-        }
-    }
-})(VHTLC || (exports.VHTLC = VHTLC = {}));
-function preimageConditionScript(preimageHash) {
-    return btc_signer_1.Script.encode(["HASH160", preimageHash, "EQUAL"]);
-}

package/dist/cjs/storage/asyncStorage.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncStorageAdapter = void 0;
-/**
- * @deprecated Use repositories instead
- * 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

@@ -1,141 +0,0 @@
-"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"));
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryStorageAdapter = void 0;
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-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/index.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/storage/indexedDB.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedDBStorageAdapter = void 0;
-const db_1 = require("../repositories/indexedDB/db");
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-class IndexedDBStorageAdapter {
-    constructor(dbName, version = db_1.DB_VERSION) {
-        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

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalStorageAdapter = void 0;
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-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;