@0xkaleab/sdk-js 0.2.7

package/dist/esm/codegen/varint.js

@@ -0,0 +1,409 @@
+// @ts-nocheck
+/* eslint-disable */
+/**
+* This file and any referenced files were automatically generated by @hyperweb/telescope@2.0.3
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+// Copyright 2008 Google Inc.  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Code generated by the Protocol Buffer compiler is owned by the owner
+// of the input file used when generating it.  This code is not
+// standalone and requires a support library to be linked with it.  This
+// support library is itself covered by the above license.
+/* eslint-disable prefer-const,@typescript-eslint/restrict-plus-operands */
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export function varint64read() {
+    let lowBits = 0;
+    let highBits = 0;
+    for (let shift = 0; shift < 28; shift += 7) {
+        let b = this.buf[this.pos++];
+        lowBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
+    }
+    let middleByte = this.buf[this.pos++];
+    // last four bits of the first 32 bit number
+    lowBits |= (middleByte & 0x0f) << 28;
+    // 3 upper bits are part of the next 32 bit number
+    highBits = (middleByte & 0x70) >> 4;
+    if ((middleByte & 0x80) == 0) {
+        this.assertBounds();
+        return [lowBits, highBits];
+    }
+    for (let shift = 3; shift <= 31; shift += 7) {
+        let b = this.buf[this.pos++];
+        highBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
+    }
+    throw new Error("invalid varint");
+}
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export function varint64write(lo, hi, bytes) {
+    for (let i = 0; i < 28; i = i + 7) {
+        const shift = lo >>> i;
+        const hasNext = !(shift >>> 7 == 0 && hi == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+    const hasMoreBits = !(hi >> 3 == 0);
+    bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
+    if (!hasMoreBits) {
+        return;
+    }
+    for (let i = 3; i < 31; i = i + 7) {
+        const shift = hi >>> i;
+        const hasNext = !(shift >>> 7 == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    bytes.push((hi >>> 31) & 0x01);
+}
+// constants for binary math
+const TWO_PWR_32_DBL = 0x100000000;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function int64FromString(dec) {
+    // Check for minus sign.
+    const minus = dec[0] === "-";
+    if (minus) {
+        dec = dec.slice(1);
+    }
+    // Work 6 decimal digits at a time, acting like we're converting base 1e6
+    // digits to binary. This is safe to do with floating point math because
+    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
+    const base = 1e6;
+    let lowBits = 0;
+    let highBits = 0;
+    function add1e6digit(begin, end) {
+        // Note: Number('') is 0.
+        const digit1e6 = Number(dec.slice(begin, end));
+        highBits *= base;
+        lowBits = lowBits * base + digit1e6;
+        // Carry bits from lowBits to
+        if (lowBits >= TWO_PWR_32_DBL) {
+            highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
+            lowBits = lowBits % TWO_PWR_32_DBL;
+        }
+    }
+    add1e6digit(-24, -18);
+    add1e6digit(-18, -12);
+    add1e6digit(-12, -6);
+    add1e6digit(-6);
+    return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function int64ToString(lo, hi) {
+    let bits = newBits(lo, hi);
+    // If we're treating the input as a signed value and the high bit is set, do
+    // a manual two's complement conversion before the decimal conversion.
+    const negative = bits.hi & 0x80000000;
+    if (negative) {
+        bits = negate(bits.lo, bits.hi);
+    }
+    const result = uInt64ToString(bits.lo, bits.hi);
+    return negative ? "-" + result : result;
+}
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function uInt64ToString(lo, hi) {
+    ({ lo, hi } = toUnsigned(lo, hi));
+    // Skip the expensive conversion if the number is small enough to use the
+    // built-in conversions.
+    // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
+    // highBits <= 0x1FFFFF can be safely expressed with a number and retain
+    // integer precision.
+    // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
+    if (hi <= 0x1fffff) {
+        return String(TWO_PWR_32_DBL * hi + lo);
+    }
+    // What this code is doing is essentially converting the input number from
+    // base-2 to base-1e7, which allows us to represent the 64-bit range with
+    // only 3 (very large) digits. Those digits are then trivial to convert to
+    // a base-10 string.
+    // The magic numbers used here are -
+    // 2^24 = 16777216 = (1,6777216) in base-1e7.
+    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
+    // Split 32:32 representation into 16:24:24 representation so our
+    // intermediate digits don't overflow.
+    const low = lo & 0xffffff;
+    const mid = ((lo >>> 24) | (hi << 8)) & 0xffffff;
+    const high = (hi >> 16) & 0xffff;
+    // Assemble our three base-1e7 digits, ignoring carries. The maximum
+    // value in a digit at this step is representable as a 48-bit integer, which
+    // can be stored in a 64-bit floating point number.
+    let digitA = low + mid * 6777216 + high * 6710656;
+    let digitB = mid + high * 8147497;
+    let digitC = high * 2;
+    // Apply carries from A to B and from B to C.
+    const base = 10000000;
+    if (digitA >= base) {
+        digitB += Math.floor(digitA / base);
+        digitA %= base;
+    }
+    if (digitB >= base) {
+        digitC += Math.floor(digitB / base);
+        digitB %= base;
+    }
+    // If digitC is 0, then we should have returned in the trivial code path
+    // at the top for non-safe integers. Given this, we can assume both digitB
+    // and digitA need leading zeros.
+    return (digitC.toString() +
+        decimalFrom1e7WithLeadingZeros(digitB) +
+        decimalFrom1e7WithLeadingZeros(digitA));
+}
+function toUnsigned(lo, hi) {
+    return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+    return { lo: lo | 0, hi: hi | 0 };
+}
+/**
+ * Returns two's compliment negation of input.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
+ */
+function negate(lowBits, highBits) {
+    highBits = ~highBits;
+    if (lowBits) {
+        lowBits = ~lowBits + 1;
+    }
+    else {
+        // If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
+        // adding 1 to that, results in 0x100000000, which leaves
+        // the low bits 0x0 and simply adds one to the high bits.
+        highBits += 1;
+    }
+    return newBits(lowBits, highBits);
+}
+/**
+ * Returns decimal representation of digit1e7 with leading zeros.
+ */
+const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+    const partial = String(digit1e7);
+    return "0000000".slice(partial.length) + partial;
+};
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export function varint32write(value, bytes) {
+    if (value >= 0) {
+        // write value as varint 32
+        while (value > 0x7f) {
+            bytes.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
+        }
+        bytes.push(value);
+    }
+    else {
+        for (let i = 0; i < 9; i++) {
+            bytes.push((value & 127) | 128);
+            value = value >> 7;
+        }
+        bytes.push(1);
+    }
+}
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export function varint32read() {
+    let b = this.buf[this.pos++];
+    let result = b & 0x7f;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 7;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 14;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 21;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    // Extract only last 4 bits
+    b = this.buf[this.pos++];
+    result |= (b & 0x0f) << 28;
+    for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+        b = this.buf[this.pos++];
+    if ((b & 0x80) != 0)
+        throw new Error("invalid varint");
+    this.assertBounds();
+    // Result can have 32 bits, convert it to unsigned
+    return result >>> 0;
+}
+/**
+ * encode zig zag
+ */
+export function zzEncode(lo, hi) {
+    let mask = hi >> 31;
+    hi = (((hi << 1) | (lo >>> 31)) ^ mask) >>> 0;
+    lo = ((lo << 1) ^ mask) >>> 0;
+    return [lo, hi];
+}
+/**
+ * decode zig zag
+ */
+export function zzDecode(lo, hi) {
+    let mask = -(lo & 1);
+    lo = (((lo >>> 1) | (hi << 31)) ^ mask) >>> 0;
+    hi = ((hi >>> 1) ^ mask) >>> 0;
+    return [lo, hi];
+}
+/**
+ * unsigned int32 without moving pos.
+ */
+export function readUInt32(buf, pos) {
+    return ((buf[pos] | (buf[pos + 1] << 8) | (buf[pos + 2] << 16)) +
+        buf[pos + 3] * 0x1000000);
+}
+/**
+ * signed int32 without moving pos.
+ */
+export function readInt32(buf, pos) {
+    return ((buf[pos] | (buf[pos + 1] << 8) | (buf[pos + 2] << 16)) +
+        (buf[pos + 3] << 24));
+}
+/**
+ * writing varint32 to pos
+ */
+export function writeVarint32(val, buf, pos) {
+    while (val > 127) {
+        buf[pos++] = (val & 127) | 128;
+        val >>>= 7;
+    }
+    buf[pos] = val;
+}
+/**
+ * writing varint64 to pos
+ */
+export function writeVarint64(val, buf, pos) {
+    while (val.hi) {
+        buf[pos++] = (val.lo & 127) | 128;
+        val.lo = ((val.lo >>> 7) | (val.hi << 25)) >>> 0;
+        val.hi >>>= 7;
+    }
+    while (val.lo > 127) {
+        buf[pos++] = (val.lo & 127) | 128;
+        val.lo = val.lo >>> 7;
+    }
+    buf[pos++] = val.lo;
+}
+export function int64Length(lo, hi) {
+    let part0 = lo, part1 = ((lo >>> 28) | (hi << 4)) >>> 0, part2 = hi >>> 24;
+    return part2 === 0
+        ? part1 === 0
+            ? part0 < 16384
+                ? part0 < 128
+                    ? 1
+                    : 2
+                : part0 < 2097152
+                    ? 3
+                    : 4
+            : part1 < 16384
+                ? part1 < 128
+                    ? 5
+                    : 6
+                : part1 < 2097152
+                    ? 7
+                    : 8
+        : part2 < 128
+            ? 9
+            : 10;
+}
+export function writeFixed32(val, buf, pos) {
+    buf[pos] = val & 255;
+    buf[pos + 1] = (val >>> 8) & 255;
+    buf[pos + 2] = (val >>> 16) & 255;
+    buf[pos + 3] = val >>> 24;
+}
+export function writeByte(val, buf, pos) {
+    buf[pos] = val & 255;
+}

package/dist/esm/compat/blake3.browser.js

@@ -0,0 +1,17 @@
+import loadBlake3 from 'blake3/browser-async';
+import wasmUrl from 'blake3/dist/wasm/web/blake3_js_bg.wasm?url';
+let blake3Instance = null;
+let wasmLoaded = null;
+async function ensureLoaded() {
+    if (!wasmLoaded) {
+        wasmLoaded = (async () => {
+            // Load WASM by passing the fetched WASM binary to the loader
+            blake3Instance = await loadBlake3(fetch(wasmUrl));
+        })();
+    }
+    await wasmLoaded;
+}
+export async function createHash() {
+    await ensureLoaded();
+    return blake3Instance.createHash();
+}

package/dist/esm/compat/blake3.node.js

@@ -0,0 +1 @@
+export { createHash } from "blake3";

package/dist/esm/compat/zstd.browser.js

@@ -0,0 +1,35 @@
+const toUint8 = (data) => {
+    if (data instanceof Uint8Array)
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+};
+// We lazy-load and init @bokuweb/zstd-wasm because it needs to fetch/instantiate WASM.
+let bokuReady = null;
+async function ensureBokuwebLoaded() {
+    if (!bokuReady) {
+        bokuReady = (async () => {
+            // Let the package choose the right browser entry and wasm asset.
+            const zstd = (await import('@bokuweb/zstd-wasm'));
+            if (typeof zstd.init === 'function') {
+                // In bundler environments, init() without a path resolves the wasm internally.
+                await zstd.init();
+            }
+            if (typeof zstd.compress !== 'function') {
+                throw new Error('@bokuweb/zstd-wasm does not expose compress()');
+            }
+            return (input, level = 3) => new Uint8Array(zstd.compress(input, level));
+        })();
+    }
+    return bokuReady;
+}
+/**
+ * Compress bytes at the given zstd level (default 3).
+ * Returns a new Uint8Array containing the compressed payload.
+ */
+export async function compress(data, level = 3) {
+    const inputBytes = toUint8(data);
+    const compressor = await ensureBokuwebLoaded();
+    return compressor(inputBytes, level);
+}

package/dist/esm/compat/zstd.node.js

@@ -0,0 +1,9 @@
+import { compress as zstdCompress } from "@mongodb-js/zstd";
+export async function compress(data, level = 3) {
+    const view = data instanceof ArrayBuffer ? new Uint8Array(data) :
+        data instanceof Uint8Array ? data :
+            new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const buffer = Buffer.from(view);
+    const out = await zstdCompress(buffer, level);
+    return new Uint8Array(out);
+}

package/dist/esm/index.js

@@ -0,0 +1,35 @@
+/**
+ * Lumera SDK - Main entry point
+ *
+ * @module @lumera-protocol/sdk-js
+ */
+// Main client - unified facade
+export { LumeraClient, createLumeraClient, CHAIN_PRESETS, } from "./client";
+// Blockchain layer - interfaces and types
+export * from "./blockchain/interfaces";
+// Blockchain layer - client factory and implementations
+export { makeBlockchainClient, CosmjsRpcBlockchainClient } from "./blockchain/client";
+// Blockchain layer - transaction client
+export { CosmjsTxClient } from "./blockchain/cosmjs";
+// Blockchain layer - message utilities
+export { buildBatchMessages, estimateGas, calculateCascadeFee, } from "./blockchain/messages";
+// Blockchain layer - message registry
+export { createLumeraRegistry } from "./blockchain/registry";
+// Storage layer - SNApiClient and types
+export { SNApiClient, } from "./cascade/client";
+// Blockchain adapter for Cascade port
+export { BlockchainActionAdapter } from "./blockchain/adapters/cascade-port";
+// Storage layer - Cascade uploader and downloader
+export { CascadeUploader, } from "./cascade/uploader";
+export { CascadeDownloader, } from "./cascade/downloader";
+// Storage layer - Task manager
+export { TaskManager, } from "./cascade/task";
+// Internal layer - HTTP client
+export { HttpClient, HttpError } from "./internal/http";
+// WASM layer - RaptorQ proxy and LEP-1 helpers
+export { RaptorQProxy } from "./wasm/raptorq-proxy";
+export { createSingleBlockLayout, generateIds, buildIndexFile, } from "./wasm/lep1";
+// Wallet utilities - Signature prompter
+export { createDefaultSignaturePrompter, createBatchedSignaturePrompter, defaultSignaturePrompter, createDefaultTxPrompter, } from "./wallets/prompter";
+// Wallet utilities - Keplr adapter
+export { getKeplrSigner, isKeplrAvailable } from "./wallets/keplr";

package/dist/esm/internal/encoding.js

@@ -0,0 +1,158 @@
+/**
+ * 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}'
+ * ```
+ */
+export 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="
+ * ```
+ */
+export 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])
+ * ```
+ */
+export 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
+ */
+export 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
+ */
+export 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"}'
+ * ```
+ */
+export 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;
+    });
+}