@0xkaleab/sdk-js 0.2.7

package/dist/cjs/index.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Lumera SDK - Main entry point
+ *
+ * @module @lumera-protocol/sdk-js
+ */
+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 });
+exports.isKeplrAvailable = exports.getKeplrSigner = exports.createDefaultTxPrompter = exports.defaultSignaturePrompter = exports.createBatchedSignaturePrompter = exports.createDefaultSignaturePrompter = exports.buildIndexFile = exports.generateIds = exports.createSingleBlockLayout = exports.RaptorQProxy = exports.HttpError = exports.HttpClient = exports.TaskManager = exports.CascadeDownloader = exports.CascadeUploader = exports.BlockchainActionAdapter = exports.SNApiClient = exports.createLumeraRegistry = exports.calculateCascadeFee = exports.estimateGas = exports.buildBatchMessages = exports.CosmjsTxClient = exports.CosmjsRpcBlockchainClient = exports.makeBlockchainClient = exports.CHAIN_PRESETS = exports.createLumeraClient = exports.LumeraClient = void 0;
+// Main client - unified facade
+var client_1 = require("./client");
+Object.defineProperty(exports, "LumeraClient", { enumerable: true, get: function () { return client_1.LumeraClient; } });
+Object.defineProperty(exports, "createLumeraClient", { enumerable: true, get: function () { return client_1.createLumeraClient; } });
+Object.defineProperty(exports, "CHAIN_PRESETS", { enumerable: true, get: function () { return client_1.CHAIN_PRESETS; } });
+// Blockchain layer - interfaces and types
+__exportStar(require("./blockchain/interfaces"), exports);
+// Blockchain layer - client factory and implementations
+var client_2 = require("./blockchain/client");
+Object.defineProperty(exports, "makeBlockchainClient", { enumerable: true, get: function () { return client_2.makeBlockchainClient; } });
+Object.defineProperty(exports, "CosmjsRpcBlockchainClient", { enumerable: true, get: function () { return client_2.CosmjsRpcBlockchainClient; } });
+// Blockchain layer - transaction client
+var cosmjs_1 = require("./blockchain/cosmjs");
+Object.defineProperty(exports, "CosmjsTxClient", { enumerable: true, get: function () { return cosmjs_1.CosmjsTxClient; } });
+// Blockchain layer - message utilities
+var messages_1 = require("./blockchain/messages");
+Object.defineProperty(exports, "buildBatchMessages", { enumerable: true, get: function () { return messages_1.buildBatchMessages; } });
+Object.defineProperty(exports, "estimateGas", { enumerable: true, get: function () { return messages_1.estimateGas; } });
+Object.defineProperty(exports, "calculateCascadeFee", { enumerable: true, get: function () { return messages_1.calculateCascadeFee; } });
+// Blockchain layer - message registry
+var registry_1 = require("./blockchain/registry");
+Object.defineProperty(exports, "createLumeraRegistry", { enumerable: true, get: function () { return registry_1.createLumeraRegistry; } });
+// Storage layer - SNApiClient and types
+var client_3 = require("./cascade/client");
+Object.defineProperty(exports, "SNApiClient", { enumerable: true, get: function () { return client_3.SNApiClient; } });
+// Blockchain adapter for Cascade port
+var cascade_port_1 = require("./blockchain/adapters/cascade-port");
+Object.defineProperty(exports, "BlockchainActionAdapter", { enumerable: true, get: function () { return cascade_port_1.BlockchainActionAdapter; } });
+// Storage layer - Cascade uploader and downloader
+var uploader_1 = require("./cascade/uploader");
+Object.defineProperty(exports, "CascadeUploader", { enumerable: true, get: function () { return uploader_1.CascadeUploader; } });
+var downloader_1 = require("./cascade/downloader");
+Object.defineProperty(exports, "CascadeDownloader", { enumerable: true, get: function () { return downloader_1.CascadeDownloader; } });
+// Storage layer - Task manager
+var task_1 = require("./cascade/task");
+Object.defineProperty(exports, "TaskManager", { enumerable: true, get: function () { return task_1.TaskManager; } });
+// Internal layer - HTTP client
+var http_1 = require("./internal/http");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_1.HttpClient; } });
+Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return http_1.HttpError; } });
+// WASM layer - RaptorQ proxy and LEP-1 helpers
+var raptorq_proxy_1 = require("./wasm/raptorq-proxy");
+Object.defineProperty(exports, "RaptorQProxy", { enumerable: true, get: function () { return raptorq_proxy_1.RaptorQProxy; } });
+var lep1_1 = require("./wasm/lep1");
+Object.defineProperty(exports, "createSingleBlockLayout", { enumerable: true, get: function () { return lep1_1.createSingleBlockLayout; } });
+Object.defineProperty(exports, "generateIds", { enumerable: true, get: function () { return lep1_1.generateIds; } });
+Object.defineProperty(exports, "buildIndexFile", { enumerable: true, get: function () { return lep1_1.buildIndexFile; } });
+// Wallet utilities - Signature prompter
+var prompter_1 = require("./wallets/prompter");
+Object.defineProperty(exports, "createDefaultSignaturePrompter", { enumerable: true, get: function () { return prompter_1.createDefaultSignaturePrompter; } });
+Object.defineProperty(exports, "createBatchedSignaturePrompter", { enumerable: true, get: function () { return prompter_1.createBatchedSignaturePrompter; } });
+Object.defineProperty(exports, "defaultSignaturePrompter", { enumerable: true, get: function () { return prompter_1.defaultSignaturePrompter; } });
+Object.defineProperty(exports, "createDefaultTxPrompter", { enumerable: true, get: function () { return prompter_1.createDefaultTxPrompter; } });
+// Wallet utilities - Keplr adapter
+var keplr_1 = require("./wallets/keplr");
+Object.defineProperty(exports, "getKeplrSigner", { enumerable: true, get: function () { return keplr_1.getKeplrSigner; } });
+Object.defineProperty(exports, "isKeplrAvailable", { enumerable: true, get: function () { return keplr_1.isKeplrAvailable; } });

package/dist/cjs/internal/encoding.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCanonicalJsonBytes = toCanonicalJsonBytes;
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+exports.toCanonicalJson = toCanonicalJson;
+exports.toB64 = toB64;
+exports.safeJsonStringify = safeJsonStringify;
+/**
+ * Converts a JavaScript object to its canonical JSON representation as a Uint8Array.
+ *
+ * This function ensures deterministic serialization by:
+ * - Recursively sorting all object keys alphabetically
+ * - Removing all insignificant whitespace
+ * - Producing identical byte sequences for equivalent objects
+ *
+ * This is critical for creating reproducible signatures as required by LEP-1.
+ *
+ * @param obj - The object to canonicalize
+ * @returns A Uint8Array containing the UTF-8 encoded canonical JSON
+ *
+ * @example
+ * ```typescript
+ * const obj = { b: 2, a: { z: 1, y: 2 } };
+ * const canonical = toCanonicalJsonBytes(obj);
+ * // Result: Uint8Array of '{"a":{"y":2,"z":1},"b":2}'
+ * ```
+ */
+function toCanonicalJsonBytes(obj) {
+    const canonicalString = canonicalizeValue(obj);
+    return new TextEncoder().encode(canonicalString);
+}
+/**
+ * Internal helper to recursively canonicalize any JSON value.
+ */
+function canonicalizeValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (value === undefined) {
+        return "null";
+    }
+    if (typeof value === "boolean" || typeof value === "number") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        const elements = value.map(item => canonicalizeValue(item));
+        return "[" + elements.join(",") + "]";
+    }
+    if (typeof value === "object") {
+        const keys = Object.keys(value).sort();
+        const pairs = keys.map(key => {
+            const canonicalKey = JSON.stringify(key);
+            const canonicalValue = canonicalizeValue(value[key]);
+            return canonicalKey + ":" + canonicalValue;
+        });
+        return "{" + pairs.join(",") + "}";
+    }
+    // Fallback for unsupported types
+    return "null";
+}
+/**
+ * Encodes a Uint8Array to a Base64 string using RFC 4648 standard encoding.
+ *
+ * Uses the standard Base64 alphabet with no line wrapping or padding modifications.
+ * This ensures cross-platform compatibility and adherence to the RFC 4648 specification.
+ *
+ * @param bytes - The binary data to encode
+ * @returns A Base64-encoded string
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([72, 101, 108, 108, 111]);
+ * const encoded = toBase64(data);
+ * // Result: "SGVsbG8="
+ * ```
+ */
+function toBase64(bytes) {
+    if (typeof Buffer !== "undefined") {
+        // Node.js environment
+        return Buffer.from(bytes).toString("base64");
+    }
+    else {
+        // Browser environment
+        let binary = "";
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+}
+/**
+ * Decodes a Base64 string to a Uint8Array using RFC 4648 standard decoding.
+ *
+ * Handles standard Base64 alphabet and properly processes padding.
+ *
+ * @param base64String - The Base64-encoded string to decode
+ * @returns The decoded binary data as a Uint8Array
+ * @throws {Error} If the input is not a valid Base64 string
+ *
+ * @example
+ * ```typescript
+ * const decoded = fromBase64("SGVsbG8=");
+ * // Result: Uint8Array([72, 101, 108, 108, 111])
+ * ```
+ */
+function fromBase64(base64String) {
+    if (typeof Buffer !== "undefined") {
+        // Node.js environment
+        return new Uint8Array(Buffer.from(base64String, "base64"));
+    }
+    else {
+        // Browser environment
+        const binary = atob(base64String);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+}
+/**
+ * @deprecated Use toCanonicalJsonBytes instead for canonical JSON serialization
+ */
+function toCanonicalJson(obj) {
+    const keys = Object.keys(obj).sort();
+    const ordered = {};
+    for (const k of keys)
+        ordered[k] = obj[k];
+    return JSON.stringify(ordered);
+}
+/**
+ * @deprecated Use toBase64 instead
+ */
+function toB64(bytes) {
+    return toBase64(bytes);
+}
+/**
+ * Safely serializes an object to JSON, converting BigInt values to strings.
+ *
+ * This function ensures that BigInt values are converted to strings during JSON
+ * serialization to prevent precision loss and JSON serialization errors. This is
+ * critical when working with blockchain data that may contain large numbers.
+ *
+ * @param obj - The object to serialize
+ * @returns A JSON string with all BigInt values converted to strings
+ *
+ * @example
+ * ```typescript
+ * const data = { height: 123456789012345678901n, amount: "1000" };
+ * const json = safeJsonStringify(data);
+ * // Result: '{"height":"123456789012345678901","amount":"1000"}'
+ * ```
+ */
+function safeJsonStringify(obj) {
+    return JSON.stringify(obj, (_, value) => {
+        // Convert BigInt to string to prevent precision loss
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    });
+}

package/dist/cjs/internal/hash.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blake3Hash = blake3Hash;
+exports.blake3HashBytes = blake3HashBytes;
+exports.blake3HashStream = blake3HashStream;
+exports.blake3HashStreamBytes = blake3HashStreamBytes;
+const blake3_1 = require("@lumera-protocol/sdk-js/compat/blake3");
+const encoding_js_1 = require("./encoding.js");
+/**
+ * Computes the BLAKE3 hash of a Uint8Array.
+ *
+ * BLAKE3 is a cryptographic hash function that is faster than MD5, SHA-1, SHA-2,
+ * and SHA-3, yet is just as secure as the latest standard SHA-3.
+ *
+ * This function is used for:
+ * - Computing data_hash for file integrity verification
+ * - Creating signatures for start and download operations
+ * - Ensuring deterministic hashing across platforms
+ *
+ * @param data - The binary data to hash
+ * @returns A Promise resolving to the hash as a Base64 string
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([1, 2, 3, 4, 5]);
+ * const hash = await blake3Hash(data);
+ * // Result: "oRNTIA..." (Base64 encoded string)
+ * ```
+ */
+async function blake3Hash(data) {
+    const hasher = await (0, blake3_1.createHash)();
+    hasher.update(data);
+    const digest = hasher.digest();
+    // Get the hash as Uint8Array and encode to Base64
+    const hashBytes = digest instanceof Uint8Array ? digest : new Uint8Array(digest);
+    return (0, encoding_js_1.toBase64)(hashBytes);
+}
+/**
+ * Computes the BLAKE3 hash of a Uint8Array and returns it as a Uint8Array.
+ *
+ * Similar to blake3Hash but returns the raw bytes instead of a hex string.
+ * Useful when you need the hash in binary form for further processing.
+ *
+ * @param data - The binary data to hash
+ * @returns A Promise resolving to the 32-byte hash as a Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([1, 2, 3, 4, 5]);
+ * const hashBytes = await blake3HashBytes(data);
+ * // Result: Uint8Array(32) [...]
+ * ```
+ */
+async function blake3HashBytes(data) {
+    const hasher = await (0, blake3_1.createHash)();
+    hasher.update(data);
+    const digest = hasher.digest();
+    // Handle both Node.js and browser (both return Uint8Array or compatible)
+    return digest instanceof Uint8Array ? digest : new Uint8Array(digest);
+}
+/**
+ * Computes the BLAKE3 hash of a ReadableStream.
+ *
+ * This function processes the stream incrementally, making it suitable for
+ * hashing large files without loading them entirely into memory.
+ *
+ * The stream will be fully consumed during hashing.
+ *
+ * @param stream - The ReadableStream to hash
+ * @returns A Promise resolving to the hash as a Base64 string
+ *
+ * @example
+ * ```typescript
+ * const fileStream = file.stream();
+ * const hash = await blake3HashStream(fileStream);
+ * // Result: "oRNTIA..." (Base64 encoded string)
+ * ```
+ */
+async function blake3HashStream(stream) {
+    const hasher = await (0, blake3_1.createHash)();
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            hasher.update(value);
+        }
+        const digest = hasher.digest();
+        // Get the hash as Uint8Array and encode to Base64
+        const hashBytes = digest instanceof Uint8Array ? digest : new Uint8Array(digest);
+        return (0, encoding_js_1.toBase64)(hashBytes);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/**
+ * Computes the BLAKE3 hash of a ReadableStream and returns it as a Uint8Array.
+ *
+ * Similar to blake3HashStream but returns the raw bytes instead of a hex string.
+ * Processes the stream incrementally for memory efficiency.
+ *
+ * The stream will be fully consumed during hashing.
+ *
+ * @param stream - The ReadableStream to hash
+ * @returns A Promise resolving to the 32-byte hash as a Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const fileStream = file.stream();
+ * const hashBytes = await blake3HashStreamBytes(fileStream);
+ * // Result: Uint8Array(32) [...]
+ * ```
+ */
+async function blake3HashStreamBytes(stream) {
+    const hasher = await (0, blake3_1.createHash)();
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            hasher.update(value);
+        }
+        const digest = hasher.digest();
+        // Handle both Node.js and browser (both return Uint8Array or compatible)
+        return digest instanceof Uint8Array ? digest : new Uint8Array(digest);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}