@0xkaleab/sdk-js 0.2.7

package/dist/types/codegen/tendermint/types/validator.d.ts

@@ -0,0 +1,161 @@
+import { PublicKey, PublicKeyAmino } from "../crypto/keys";
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/** BlockIdFlag indicates which BlockID the signature is for */
+export declare enum BlockIDFlag {
+    /** BLOCK_ID_FLAG_UNKNOWN - indicates an error condition */
+    BLOCK_ID_FLAG_UNKNOWN = 0,
+    /** BLOCK_ID_FLAG_ABSENT - the vote was not received */
+    BLOCK_ID_FLAG_ABSENT = 1,
+    BLOCK_ID_FLAG_COMMIT = 2,
+    /** BLOCK_ID_FLAG_NIL - voted for nil */
+    BLOCK_ID_FLAG_NIL = 3,
+    UNRECOGNIZED = -1
+}
+export declare const BlockIDFlagAmino: typeof BlockIDFlag;
+export declare function blockIDFlagFromJSON(object: any): BlockIDFlag;
+export declare function blockIDFlagToJSON(object: BlockIDFlag): string;
+/**
+ * @name ValidatorSet
+ * @package tendermint.types
+ * @see proto type: tendermint.types.ValidatorSet
+ */
+export interface ValidatorSet {
+    validators: Validator[];
+    proposer?: Validator;
+    totalVotingPower: bigint;
+}
+export interface ValidatorSetProtoMsg {
+    typeUrl: "/tendermint.types.ValidatorSet";
+    value: Uint8Array;
+}
+/**
+ * @name ValidatorSetAmino
+ * @package tendermint.types
+ * @see proto type: tendermint.types.ValidatorSet
+ */
+export interface ValidatorSetAmino {
+    validators: ValidatorAmino[];
+    proposer?: ValidatorAmino;
+    total_voting_power: string;
+}
+export interface ValidatorSetAminoMsg {
+    type: "/tendermint.types.ValidatorSet";
+    value: ValidatorSetAmino;
+}
+/**
+ * @name Validator
+ * @package tendermint.types
+ * @see proto type: tendermint.types.Validator
+ */
+export interface Validator {
+    address: Uint8Array;
+    pubKey: PublicKey;
+    votingPower: bigint;
+    proposerPriority: bigint;
+}
+export interface ValidatorProtoMsg {
+    typeUrl: "/tendermint.types.Validator";
+    value: Uint8Array;
+}
+/**
+ * @name ValidatorAmino
+ * @package tendermint.types
+ * @see proto type: tendermint.types.Validator
+ */
+export interface ValidatorAmino {
+    address: string;
+    pub_key: PublicKeyAmino;
+    voting_power: string;
+    proposer_priority: string;
+}
+export interface ValidatorAminoMsg {
+    type: "/tendermint.types.Validator";
+    value: ValidatorAmino;
+}
+/**
+ * @name SimpleValidator
+ * @package tendermint.types
+ * @see proto type: tendermint.types.SimpleValidator
+ */
+export interface SimpleValidator {
+    pubKey?: PublicKey;
+    votingPower: bigint;
+}
+export interface SimpleValidatorProtoMsg {
+    typeUrl: "/tendermint.types.SimpleValidator";
+    value: Uint8Array;
+}
+/**
+ * @name SimpleValidatorAmino
+ * @package tendermint.types
+ * @see proto type: tendermint.types.SimpleValidator
+ */
+export interface SimpleValidatorAmino {
+    pub_key?: PublicKeyAmino;
+    voting_power: string;
+}
+export interface SimpleValidatorAminoMsg {
+    type: "/tendermint.types.SimpleValidator";
+    value: SimpleValidatorAmino;
+}
+/**
+ * @name ValidatorSet
+ * @package tendermint.types
+ * @see proto type: tendermint.types.ValidatorSet
+ */
+export declare const ValidatorSet: {
+    typeUrl: string;
+    is(o: any): o is ValidatorSet;
+    isAmino(o: any): o is ValidatorSetAmino;
+    encode(message: ValidatorSet, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ValidatorSet;
+    fromPartial(object: DeepPartial<ValidatorSet>): ValidatorSet;
+    fromAmino(object: ValidatorSetAmino): ValidatorSet;
+    toAmino(message: ValidatorSet): ValidatorSetAmino;
+    fromAminoMsg(object: ValidatorSetAminoMsg): ValidatorSet;
+    fromProtoMsg(message: ValidatorSetProtoMsg): ValidatorSet;
+    toProto(message: ValidatorSet): Uint8Array;
+    toProtoMsg(message: ValidatorSet): ValidatorSetProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * @name Validator
+ * @package tendermint.types
+ * @see proto type: tendermint.types.Validator
+ */
+export declare const Validator: {
+    typeUrl: string;
+    is(o: any): o is Validator;
+    isAmino(o: any): o is ValidatorAmino;
+    encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Validator;
+    fromPartial(object: DeepPartial<Validator>): Validator;
+    fromAmino(object: ValidatorAmino): Validator;
+    toAmino(message: Validator): ValidatorAmino;
+    fromAminoMsg(object: ValidatorAminoMsg): Validator;
+    fromProtoMsg(message: ValidatorProtoMsg): Validator;
+    toProto(message: Validator): Uint8Array;
+    toProtoMsg(message: Validator): ValidatorProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * @name SimpleValidator
+ * @package tendermint.types
+ * @see proto type: tendermint.types.SimpleValidator
+ */
+export declare const SimpleValidator: {
+    typeUrl: string;
+    is(o: any): o is SimpleValidator;
+    isAmino(o: any): o is SimpleValidatorAmino;
+    encode(message: SimpleValidator, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SimpleValidator;
+    fromPartial(object: DeepPartial<SimpleValidator>): SimpleValidator;
+    fromAmino(object: SimpleValidatorAmino): SimpleValidator;
+    toAmino(message: SimpleValidator): SimpleValidatorAmino;
+    fromAminoMsg(object: SimpleValidatorAminoMsg): SimpleValidator;
+    fromProtoMsg(message: SimpleValidatorProtoMsg): SimpleValidator;
+    toProto(message: SimpleValidator): Uint8Array;
+    toProtoMsg(message: SimpleValidator): SimpleValidatorProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/tendermint/version/types.d.ts

@@ -0,0 +1,112 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ * @name App
+ * @package tendermint.version
+ * @see proto type: tendermint.version.App
+ */
+export interface App {
+    protocol: bigint;
+    software: string;
+}
+export interface AppProtoMsg {
+    typeUrl: "/tendermint.version.App";
+    value: Uint8Array;
+}
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ * @name AppAmino
+ * @package tendermint.version
+ * @see proto type: tendermint.version.App
+ */
+export interface AppAmino {
+    protocol: string;
+    software: string;
+}
+export interface AppAminoMsg {
+    type: "/tendermint.version.App";
+    value: AppAmino;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ * @name Consensus
+ * @package tendermint.version
+ * @see proto type: tendermint.version.Consensus
+ */
+export interface Consensus {
+    block: bigint;
+    app: bigint;
+}
+export interface ConsensusProtoMsg {
+    typeUrl: "/tendermint.version.Consensus";
+    value: Uint8Array;
+}
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ * @name ConsensusAmino
+ * @package tendermint.version
+ * @see proto type: tendermint.version.Consensus
+ */
+export interface ConsensusAmino {
+    block: string;
+    app: string;
+}
+export interface ConsensusAminoMsg {
+    type: "/tendermint.version.Consensus";
+    value: ConsensusAmino;
+}
+/**
+ * App includes the protocol and software version for the application.
+ * This information is included in ResponseInfo. The App.Protocol can be
+ * updated in ResponseEndBlock.
+ * @name App
+ * @package tendermint.version
+ * @see proto type: tendermint.version.App
+ */
+export declare const App: {
+    typeUrl: string;
+    is(o: any): o is App;
+    isAmino(o: any): o is AppAmino;
+    encode(message: App, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): App;
+    fromPartial(object: DeepPartial<App>): App;
+    fromAmino(object: AppAmino): App;
+    toAmino(message: App): AppAmino;
+    fromAminoMsg(object: AppAminoMsg): App;
+    fromProtoMsg(message: AppProtoMsg): App;
+    toProto(message: App): Uint8Array;
+    toProtoMsg(message: App): AppProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * Consensus captures the consensus rules for processing a block in the blockchain,
+ * including all blockchain data structures and the rules of the application's
+ * state transition machine.
+ * @name Consensus
+ * @package tendermint.version
+ * @see proto type: tendermint.version.Consensus
+ */
+export declare const Consensus: {
+    typeUrl: string;
+    is(o: any): o is Consensus;
+    isAmino(o: any): o is ConsensusAmino;
+    encode(message: Consensus, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Consensus;
+    fromPartial(object: DeepPartial<Consensus>): Consensus;
+    fromAmino(object: ConsensusAmino): Consensus;
+    toAmino(message: Consensus): ConsensusAmino;
+    fromAminoMsg(object: ConsensusAminoMsg): Consensus;
+    fromProtoMsg(message: ConsensusProtoMsg): Consensus;
+    toProto(message: Consensus): Uint8Array;
+    toProtoMsg(message: Consensus): ConsensusProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/types.d.ts

@@ -0,0 +1,74 @@
+/**
+* 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.
+*/
+import { IBinaryReader, IBinaryWriter } from "./binary";
+import { Any } from "./google/protobuf/any";
+import { DeliverTxResponse } from "@interchainjs/types";
+export type { DeliverTxResponse };
+export type ProtoMsg = Omit<Any, "typeUrl"> & {
+    typeUrl: any;
+};
+export interface IAminoMsg<Amino> {
+    type: any;
+    value: Amino;
+}
+export interface IProtoType {
+    $typeUrl?: any;
+}
+/**
+ * A type generated by Telescope 1.0.
+ */
+export interface TelescopeGeneratedCodec<T = unknown, SDK = unknown, Amino = unknown> {
+    readonly typeUrl: string;
+    readonly aminoType?: string;
+    is?(o: unknown): o is T;
+    isSDK?(o: unknown): o is SDK;
+    isAmino?(o: unknown): o is Amino;
+    encode: (message: T, writer?: IBinaryWriter | any) => IBinaryWriter | any;
+    decode: (input: IBinaryReader | Uint8Array | any, length?: number) => T;
+    fromPartial: (object: any) => T | any;
+    fromJSON?: (object: any) => T | any;
+    toJSON?: (message: T | any) => any;
+    fromSDK?: (sdk: SDK) => T;
+    fromSDKJSON?: (object: any) => SDK;
+    toSDK?: (message: T) => SDK;
+    fromAmino?: (amino: Amino) => T;
+    toAmino?: (message: T) => Amino;
+    fromAminoMsg?: (aminoMsg: IAminoMsg<Amino>) => T;
+    toAminoMsg?: (message: T) => IAminoMsg<Amino>;
+    toProto?: (message: T) => Uint8Array;
+    fromProtoMsg?: (message: ProtoMsg) => T;
+    toProtoMsg?: (message: T) => Any;
+    registerTypeUrl?: () => void;
+}
+export type TelescopeGeneratedType<T = unknown, SDK = unknown, Amino = unknown> = TelescopeGeneratedCodec<T, SDK, Amino>;
+export type GeneratedType = TelescopeGeneratedCodec;
+/**
+ * Coin defines a token with a denomination and an amount.
+ *
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+interface Coin {
+    denom: string;
+    amount: string;
+}
+export type EncodeObject = Message<any>;
+export interface Message<T> {
+    typeUrl: string;
+    value: T;
+}
+export interface StdFee {
+    amount: Coin[];
+    gas: string;
+    /** The granter address that is used for paying with feegrants */
+    granter?: string;
+    /** The fee payer address. The payer must have signed the transaction. */
+    payer?: string;
+}
+export interface TxRpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+    signAndBroadcast?(signerAddress: string, messages: EncodeObject[], fee: StdFee | "auto" | number, memo: string): Promise<DeliverTxResponse>;
+}

package/dist/types/codegen/utf8.d.ts

@@ -0,0 +1,27 @@
+/**
+* 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.
+*/
+/**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+export declare function utf8Length(str: string): number;
+/**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+export declare function utf8Read(buffer: ArrayLike<number>, start: number, end: number): string;
+/**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+export declare function utf8Write(str: string, buffer: Uint8Array | Array<number>, offset: number): number;

package/dist/types/codegen/varint.d.ts

@@ -0,0 +1,105 @@
+/**
+* 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.
+*/
+/**
+ * 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 declare function varint64read(this: ReaderLike): [number, number];
+/**
+ * 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 declare function varint64write(lo: number, hi: number, bytes: number[]): void;
+/**
+ * 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 declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * 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 declare function int64ToString(lo: number, hi: number): string;
+/**
+ * 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 declare function uInt64ToString(lo: number, hi: number): string;
+/**
+ * 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 declare function varint32write(value: number, bytes: number[]): void;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export declare function varint32read(this: ReaderLike): number;
+type ReaderLike = {
+    buf: Uint8Array;
+    pos: number;
+    len: number;
+    assertBounds(): void;
+};
+/**
+ * encode zig zag
+ */
+export declare function zzEncode(lo: number, hi: number): number[];
+/**
+ * decode zig zag
+ */
+export declare function zzDecode(lo: number, hi: number): number[];
+/**
+ * unsigned int32 without moving pos.
+ */
+export declare function readUInt32(buf: Uint8Array, pos: number): number;
+/**
+ * signed int32 without moving pos.
+ */
+export declare function readInt32(buf: Uint8Array, pos: number): number;
+/**
+ * writing varint32 to pos
+ */
+export declare function writeVarint32(val: number, buf: Uint8Array | number[], pos: number): void;
+/**
+ * writing varint64 to pos
+ */
+export declare function writeVarint64(val: {
+    lo: number;
+    hi: number;
+}, buf: Uint8Array | number[], pos: number): void;
+export declare function int64Length(lo: number, hi: number): 1 | 10 | 3 | 2 | 5 | 6 | 7 | 8 | 4 | 9;
+export declare function writeFixed32(val: number, buf: Uint8Array | number[], pos: number): void;
+export declare function writeByte(val: number, buf: Uint8Array | number[], pos: number): void;
+export {};

package/dist/types/compat/blake3.browser.d.ts

@@ -0,0 +1 @@
+export declare function createHash(): Promise<any>;

package/dist/types/compat/blake3.node.d.ts

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

package/dist/types/compat/zstd.browser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compress bytes at the given zstd level (default 3).
+ * Returns a new Uint8Array containing the compressed payload.
+ */
+export declare function compress(data: ArrayBufferView | ArrayBuffer, level?: number): Promise<Uint8Array>;

package/dist/types/compat/zstd.node.d.ts

@@ -0,0 +1 @@
+export declare function compress(data: ArrayBufferView | ArrayBuffer, level?: number): Promise<Uint8Array>;

package/dist/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Lumera SDK - Main entry point
+ *
+ * @module @lumera-protocol/sdk-js
+ */
+export { LumeraClient, createLumeraClient, CHAIN_PRESETS, type LumeraClientConfig, type ChainPreset, } from "./client";
+export * from "./blockchain/interfaces";
+export { makeBlockchainClient, CosmjsRpcBlockchainClient, type BlockchainClientOptions } from "./blockchain/client";
+export { CosmjsTxClient, type BroadcastResult } from "./blockchain/cosmjs";
+export { buildBatchMessages, estimateGas, calculateCascadeFee, type CascadeActionMetadata, type SenseActionMetadata, } from "./blockchain/messages";
+export { createLumeraRegistry } from "./blockchain/registry";
+export { SNApiClient, type StartCascadeBody, type StartCascadeResponse, type RequestDownloadBody, type RequestDownloadResponse, type Task, type TaskStatus, } from "./cascade/client";
+export type { CascadeChainPort, CascadeActionParams, RequestActionTxInput, TxOutcome, } from "./cascade/ports";
+export { BlockchainActionAdapter } from "./blockchain/adapters/cascade-port";
+export type { BlockchainActionAdapterOptions } from "./blockchain/adapters/cascade-port";
+export { CascadeUploader, type UploadParams, type CascadeUploaderOptions, type SignaturePrompter, type SignaturePromptContext, type CascadeSignatureKind, type PreparedFile, type RegisteredAction, type RegisterActionParams, type SendFileParams, } from "./cascade/uploader";
+export { CascadeDownloader, type DownloadParams, } from "./cascade/downloader";
+export { TaskManager, type TaskManagerOptions, } from "./cascade/task";
+export { HttpClient, type HttpClientConfig, type RequestOptions, HttpError } from "./internal/http";
+export { RaptorQProxy } from "./wasm/raptorq-proxy";
+export type { RaptorQSession, } from "./wasm/raptorq-proxy";
+export { createSingleBlockLayout, generateIds, buildIndexFile, type Layout, type IndexFile, type SourceBlock, } from "./wasm/lep1";
+export { createDefaultSignaturePrompter, createBatchedSignaturePrompter, defaultSignaturePrompter, createDefaultTxPrompter, type TxPrompter, type TxPromptContext, } from "./wallets/prompter";
+export { getKeplrSigner, isKeplrAvailable } from "./wallets/keplr";

package/dist/types/internal/encoding.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 declare function toCanonicalJsonBytes(obj: unknown): Uint8Array;
+/**
+ * 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 declare function toBase64(bytes: Uint8Array): string;
+/**
+ * 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 declare function fromBase64(base64String: string): Uint8Array;
+/**
+ * @deprecated Use toCanonicalJsonBytes instead for canonical JSON serialization
+ */
+export declare function toCanonicalJson(obj: Record<string, unknown>): string;
+/**
+ * @deprecated Use toBase64 instead
+ */
+export declare function toB64(bytes: Uint8Array): string;
+/**
+ * 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 declare function safeJsonStringify(obj: any): string;

package/dist/types/internal/hash.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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)
+ * ```
+ */
+export declare function blake3Hash(data: Uint8Array): Promise<string>;
+/**
+ * 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) [...]
+ * ```
+ */
+export declare function blake3HashBytes(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * 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)
+ * ```
+ */
+export declare function blake3HashStream(stream: ReadableStream<Uint8Array>): Promise<string>;
+/**
+ * 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) [...]
+ * ```
+ */
+export declare function blake3HashStreamBytes(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;