@palliora.org/chainsdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,811 @@
+import * as _polkadot_util_crypto_types from '@polkadot/util-crypto/types';
+import { ApiPromise, Keyring, WsProvider } from '@polkadot/api';
+export { ApiPromise, HttpProvider, WsProvider } from '@polkadot/api';
+import * as _noble_curves_abstract_weierstrass from '@noble/curves/abstract/weierstrass';
+import { ProjPointType } from '@noble/curves/abstract/weierstrass';
+import { Fp, Fp2, Fp12 } from '@noble/curves/abstract/tower';
+export * from '@polkadot/util';
+import * as utilCrypto from '@polkadot/util-crypto';
+export { utilCrypto };
+import * as wasmCrypto from '@polkadot/wasm-crypto';
+export { wasmCrypto };
+
+declare enum CryptoType {
+    SR25519 = "sr25519",
+    ED25519 = "ed25519",
+    ECDSA = "ecdsa"
+}
+declare enum AccountSourceType {
+    PRIVATE_KEY = "privateKey",
+    SEED = "seed",
+    MNEMONIC = "mnemonic",
+    DERIVED = "derived",
+    ADDRESS = "address"
+}
+
+/**
+ * Creates a Substrate account from a private key, seed, or mnemonic.
+ * @param input - The input string (private key hex, seed hex, or mnemonic phrase).
+ * @param type - The type of input: 'privateKey', 'seed', or 'mnemonic'.
+ * @param cryptoType - The crypto type: 'sr25519' | 'ed25519' | 'ecdsa' (default: 'sr25519').
+ * @returns The keypair object.
+ */
+declare function createAccount(input: any, type: AccountSourceType, name?: string, cryptoType?: CryptoType): Promise<any>;
+declare function pairFromPrivateKeyHex(privateKeyHex: string, cryptoType: CryptoType): _polkadot_util_crypto_types.Keypair;
+
+declare const API_RPC: {
+    kate: {
+        queryRows: {
+            description: string;
+            params: ({
+                name: string;
+                type: string;
+                isOptional?: undefined;
+            } | {
+                name: string;
+                type: string;
+                isOptional: boolean;
+            })[];
+            type: string;
+        };
+        queryProof: {
+            description: string;
+            params: ({
+                name: string;
+                type: string;
+                isOptional?: undefined;
+            } | {
+                name: string;
+                type: string;
+                isOptional: boolean;
+            })[];
+            type: string;
+        };
+        blockLength: {
+            description: string;
+            params: {
+                name: string;
+                type: string;
+                isOptional: boolean;
+            }[];
+            type: string;
+        };
+        queryDataProof: {
+            description: string;
+            params: ({
+                name: string;
+                type: string;
+                isOptional?: undefined;
+            } | {
+                name: string;
+                type: string;
+                isOptional: boolean;
+            })[];
+            type: string;
+        };
+    };
+    guardian: {
+        runtimeInfo: {
+            description: string;
+            params: {
+                name: string;
+                type: string;
+                isOptional: boolean;
+            }[];
+            type: string;
+        };
+        guardianList: {
+            description: string;
+            params: never[];
+            type: string;
+        };
+        guardianNwParams: {
+            description: string;
+            params: never[];
+            type: string;
+        };
+    };
+};
+declare const API_TYPES: {
+    GuardianInfo: {
+        active: string;
+        maximum: string;
+    };
+    GuardianNwParams: {
+        kzg: string;
+        agg_key: string;
+    };
+    AppId: string;
+    DataLookupItem: {
+        appId: string;
+        start: string;
+    };
+    CompactDataLookup: {
+        size: string;
+        index: string;
+    };
+    KateCommitment: {
+        rows: string;
+        cols: string;
+        commitment: string;
+        dataRoot: string;
+    };
+    V3HeaderExtension: {
+        appLookup: string;
+        commitment: string;
+    };
+    HeaderExtension: {
+        _enum: {
+            V1: null;
+            V2: null;
+            V3: string;
+        };
+    };
+    DaHeader: {
+        parentHash: string;
+        number: string;
+        stateRoot: string;
+        extrinsicsRoot: string;
+        digest: string;
+        extension: string;
+    };
+    Header: string;
+    CheckAppIdExtra: {
+        appId: string;
+    };
+    CheckAppIdTypes: {};
+    CheckAppId: {
+        extra: string;
+        types: string;
+    };
+    ComputePayload: {
+        da_type: string;
+        agreement: string;
+        verification: string;
+        compute: string;
+    };
+    BlockLengthColumns: string;
+    BlockLengthRows: string;
+    BlockLength: {
+        max: string;
+        cols: string;
+        rows: string;
+        chunkSize: string;
+    };
+    PerDispatchClass: {
+        normal: string;
+        operational: string;
+        mandatory: string;
+    };
+    TxDataRoots: {
+        dataRoot: string;
+        blobRoot: string;
+        bridgeRoot: string;
+    };
+    DataProof: {
+        roots: string;
+        proof: string;
+        numberOfLeaves: string;
+        leafIndex: string;
+        leaf: string;
+    };
+    ProofResponse: {
+        dataProof: string;
+        message: string;
+    };
+    AddressedMessage: {
+        message: string;
+        from: string;
+        to: string;
+        originDomain: string;
+        destinationDomain: string;
+        id: string;
+    };
+    Message: {
+        _enum: {
+            ArbitraryMessage: string;
+            FungibleToken: string;
+        };
+    };
+    FungibleToken: {
+        assetId: string;
+        amount: string;
+    };
+    BoundedData: string;
+    ArbitraryMessage: string;
+    Cell: {
+        row: string;
+        col: string;
+    };
+    GRawScalar: string;
+    GProof: string;
+    GRow: string;
+    GDataProof: string;
+};
+declare const DEFAULT_COMPUTE_PAYLOAD: {
+    compute: {
+        da_type: number;
+        verification: number;
+        compute: number;
+    };
+};
+declare const DEFAULT_EMPTY_PAYLOAD: {
+    compute: {
+        da_type: number;
+        verification: number;
+        compute: number;
+        agreement: never[];
+    };
+};
+declare const API_EXTENSIONS: {
+    CheckAppId: {
+        extrinsic: {
+            appId: string;
+        };
+        payload: {};
+    };
+    CheckCompute: {
+        extrinsic: {
+            compute: string;
+        };
+        payload: {};
+    };
+};
+
+type OnChainFileOptions = {
+    file: File;
+    filePath: string;
+    fileName: string;
+    description: string;
+    baseCost: bigint;
+    ownerL2Address: string;
+    guardianInfo: any;
+};
+declare class MCryptFs {
+    _api: any;
+    _init: boolean;
+    _metaRef: any;
+    _metadata: any;
+    _chunkRefs: any;
+    _startRef: any;
+    constructor(mcryptApi: any, metadataRef: any, metadata: any);
+    static dummyInstance(mcryptApi: any): MCryptFs;
+    isValid(): void;
+    getMetadata(): any;
+}
+declare class MCryptFsWriter {
+    _file: File;
+    _filePath: string;
+    _description: string;
+    _chunkSize: number;
+    _fileKey: string;
+    _fileName: string;
+    _baseCost: bigint;
+    _ownerL2Address: string;
+    _guardianInfo: any;
+    _api: any;
+    _account: any;
+    _chunkRefs: any[];
+    _blockNumber: number;
+    _extrinsicIndex: number;
+    _progress: {
+        iFileSize: number;
+        iBlocksWritten: number;
+    };
+    _error: any;
+    constructor(fileOptions: OnChainFileOptions, chunkSize: number | undefined, mcryptApi: any, account: any);
+    prependMetadata(chunk: any): Blob;
+    writeChunk(chunk: any): Promise<unknown>;
+    submitKey(account: any, data: any): Promise<{
+        blockNumber: any;
+        index: any;
+        hash: any;
+        tx_result: any;
+    }>;
+    writeMetadata(): Promise<{
+        blockNumber: any;
+        index: any;
+        hash: any;
+        tx_result: any;
+    }>;
+    writeFile(): Promise<MCryptFs>;
+}
+declare class MCryptFsReader {
+    _filename: string;
+    _api: any;
+    _onChainFile: any;
+    constructor(filename: string, mcryptApi: any, onChainFile: any);
+    downloadFile(): Promise<Blob>;
+}
+declare const FileFromMetadataRef: (mcryptApi: any, metadataRef: any) => Promise<MCryptFs>;
+
+/**
+ * Module providing singleton access to Polkadot API, WebSocket provider, and keyring.
+ *
+ * This module ensures that only one instance of the WsProvider, ApiPromise and Keyring
+ * are created and reused across the application. It exposes a class-based wrapper
+ * (RpcApi) for managed connect/disconnect flows and convenience functions for directly
+ * obtaining the singleton instances.
+ *
+ * Notes:
+ * - The API is created with custom RPC, types and signed extensions provided by
+ *   {@link API_RPC}, {@link API_TYPES} and {@link API_EXTENSIONS}.
+ * - In non-test environments, the module attaches fatal handlers to the API that call
+ *   `process.exit(0)` on error/disconnect to allow an external supervisor to restart
+ *   the process.
+ * - The keyring is created for `sr25519` keys. The convenience getter populates a
+ *   default development account derived from the well-known dev URI `//Bob`
+ *   (named "Bob default"). This is a development-only seed and MUST NOT be used
+ *   in production.
+ */
+
+/**
+ * Lightweight manager that holds and controls the lifecycle of the singleton
+ * WsProvider, ApiPromise and Keyring instances.
+ *
+ * @remarks
+ * - Instances are created lazily when {@link RpcApi.connect} is called.
+ * - The class maintains simple connection state via `isConnected`, `isConnecting`,
+ *   and `error` fields so callers can inspect the status without directly
+ *   interrogating the underlying API/provider.
+ * - Event handlers are attached to both the provider and the API to update `error`
+ *   and `isConnected` appropriately when runtime errors or disconnects occur.
+ *
+ * @example
+ * const rpc = getRpcApi();
+ * await rpc.connect("wss://example.com");
+ * const { api, keyring } = await rpc.getApi();
+ *
+ * @public
+ */
+declare class RpcApi {
+    isConnected: boolean;
+    isConnecting: boolean;
+    error: string | null;
+    constructor();
+    /**
+     * Establishes a connection to a node at `endpoint` and returns the singleton
+     * API and Keyring instances.
+     *
+     * @param endpoint - WebSocket endpoint URL to connect to (e.g. "wss://...").
+     * @returns A promise resolving to an object containing the singleton {@link ApiPromise}
+     *          instance and the singleton {@link Keyring} instance.
+     *
+     * @remarks
+     * - If a connection already exists (`isConnected === true`) the method returns
+     *   the already-initialized instances without recreating them.
+     * - The method sets `isConnecting` to true while establishing the connection and
+     *   clears it in a `finally` block.
+     * - Provider and API event listeners update the instance `error` and `isConnected`
+     *   fields on runtime errors and disconnects.
+     * - The Keyring created here uses `sr25519` keys. If the standalone `getKeyring`
+     *   helper is used elsewhere, it will additionally add a default development
+     *   account derived from the well-known dev URI `//Bob` (named "Bob default").
+     *
+     * @throws Will re-throw underlying errors encountered while creating the provider
+     *         or API. In that case `error` will contain the textual error message.
+     */
+    connect(endpoint: string): Promise<{
+        api: ApiPromise | null;
+        keyring: Keyring | null;
+    }>;
+    /**
+     * Gracefully disconnects and nullifies the singleton API, provider and keyring
+     * instances managed by this RpcApi instance.
+     *
+     * @remarks
+     * - The method calls `api.disconnect()` and `wsProvider.disconnect()` if they
+     *   exist, then sets the internal singletons to `null` and `isConnected` to false.
+     * - Any error during disconnect is captured in `error`.
+     */
+    disconnect(): Promise<void>;
+    getApi(): ApiPromise | null;
+    getKeyring(): Keyring | null;
+    getEncKeyring(): Keyring | null;
+}
+/**
+ * getApi()
+ *
+ * Returns the singleton {@link ApiPromise} instance, creating it if necessary.
+ *
+ * @remarks
+ * - If no underlying `provider` is configured (the module-level `provider`
+ *   imported from "./wsProvider"), this function returns `undefined`.
+ * - When creating the API, the configured `rpc`, `types` and `signedExtensions`
+ *   are applied.
+ * - In non-test environments, top-level API `error` and `disconnected` events
+ *   cause the process to exit so that an external supervisor can restart the
+ *   process.
+ *
+ * @returns The singleton {@link ApiPromise} instance (or `undefined` if no provider).
+ */
+declare function getApi(): Promise<ApiPromise | undefined>;
+/**
+ * getKeyring()
+ *
+ * Returns the singleton {@link Keyring} instance, creating it if necessary.
+ *
+ * @remarks
+ * - Ensures {@link waitReady} has resolved before constructing the keyring so
+ *   that WASM crypto is initialized.
+ * - The keyring is created with `type: "sr25519"`.
+ * - The function also adds a default development account from the dev seed URI
+ *   `//Bob` and labels it "Bob default".
+ *
+ * @important
+ * The seed URI `//Bob` is a well-known development seed. It is convenient for
+ * local testing but is insecure for any real funds or production use. Replace
+ * or remove this default account when deploying to production.
+ *
+ * @returns The singleton {@link Keyring} instance.
+ */
+declare function getKeyring(): Promise<Keyring>;
+/**
+ * getEncKeyring()
+ *
+ * Returns the singleton encryption-focused {@link Keyring} instance, creating it
+ * if necessary.
+ *
+ * @remarks
+ * - Ensures {@link waitReady} has resolved before constructing the keyring so
+ *   that WASM crypto is initialized.
+ * - The keyring is created with `type: "sr25519"` and a development default
+ *   account derived from the dev seed URI `//Bob` is added and labeled
+ *   "Bob default (enc)".
+ *
+ * @important
+ * The seed URI `//Bob` is a well-known development seed and MUST NOT be used
+ * in production for real funds. Replace or remove this default when deploying
+ * to production.
+ *
+ * @returns The singleton {@link Keyring} instance used for encryption keys.
+ */
+declare function getEncKeyring(): Promise<Keyring>;
+/**
+ * Returns the singleton {@link RpcApi} manager instance, creating it on first use.
+ *
+ * @returns The singleton {@link RpcApi}.
+ */
+declare function getRpcApi(): RpcApi;
+
+declare const signAndSend: (request: any, account: any, opts?: {
+    compute: {
+        da_type: number;
+        verification: number;
+        compute: number;
+    };
+}) => Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    tx_result: any;
+}>;
+declare const getFileMetadataCall: (api: any, metadataRef: [number, number]) => Promise<any>;
+declare const getGuardianAddress: () => Promise<{
+    peerid: string;
+    address: string;
+}[]>;
+declare const getGuardianNwParams: () => Promise<any>;
+
+declare const provider: WsProvider;
+
+declare function createAgreement(): Promise<void>;
+
+declare function getGuardianParticipants(): Promise<any>;
+
+declare const gen_stretched_key: (input: Uint8Array) => Uint8Array<ArrayBufferLike>;
+declare const gen_shared_key: (key: Uint8Array, pk: Uint8Array) => Uint8Array<ArrayBufferLike>;
+declare const encrypt$1: (plaintext: Uint8Array, key: Uint8Array) => {
+    ciphertext: Uint8Array<ArrayBufferLike>;
+    nonce: Uint8Array<ArrayBuffer>;
+};
+declare const decrypt: (ciphertext: Uint8Array, key: Uint8Array, nonce: Uint8Array) => Uint8Array<ArrayBufferLike> | null;
+
+/**
+ * Summary of porting the Silent Threshold encryption scheme from Rust to JavaScript.
+ *
+ * The Silent Threshold encryption scheme is a threshold encryption scheme that uses BLS12-381 as the underlying elliptic curve.
+ * The scheme is based on the BLS signature scheme and uses the BLS pairing to encrypt and decrypt data.
+ *
+ * The types ported from the original Rust implementation are:
+ * - E::ScalarField -> BigInt
+ * - QuadExtField   -> Fp2
+ * - CubicExtField  -> Fp6
+ * - E::G1          -> ProjPointType<Fp>
+ * - E::G2          -> ProjPointType<Fp2>
+ * - PairingOutput  -> ProjPointType<Fp12>
+ */
+/**
+ * @typedef {Object} PublicKey
+ * @property {number} id - The identifier for the public key.
+ * @property {ProjPointType<Fp>} bls_pk - The BLS public key.
+ * @property {ProjPointType<Fp>} sk_li - The secret key component li.
+ * @property {ProjPointType<Fp>} sk_li_minus0 - The secret key component li minus 0.
+ * @property {ProjPointType<Fp>} sk_li_x - The secret key component li x.
+ * @property {Array<ProjPointType<Fp>>} sk_li_lj_z - The secret key components li lj z.
+ */
+type PublicKey = {
+    id: number;
+    bls_pk: ProjPointType<Fp>;
+    sk_li: ProjPointType<Fp>;
+    sk_li_minus0: ProjPointType<Fp>;
+    sk_li_lj_z: Array<ProjPointType<Fp>>;
+    sk_li_x: ProjPointType<Fp>;
+};
+/**
+ * @typedef {Object} AggregateKey
+ * @property {Array<PublicKey>} pk - The array of public keys.
+ * @property {Array<ProjPointType<Fp>>} agg_sk_li_lj_z - The aggregated secret key components li lj z.
+ * @property {ProjPointType<Fp>} ask - The aggregated secret key.
+ * @property {ProjPointType<Fp2>} z_g2 - The z_g2 component.
+ * @property {ProjPointType<Fp2>} h_minus1 - The h_minus1 component.
+ * @property {PairingOutput} e_gh - The preprocessed pairing output.
+ */
+type AggregateKey = {
+    pk: Array<PublicKey>;
+    agg_sk_li_lj_z: Array<ProjPointType<Fp>>;
+    ask: ProjPointType<Fp>;
+    z_g2: ProjPointType<Fp2>;
+    h_minus1: ProjPointType<Fp2>;
+    e_gh: Fp12;
+};
+/**
+ * @typedef {Object} Ciphertext
+ * @property {ProjPointType<Fp2>} gamma_g2 - The gamma_g2 component.
+ * @property {Array<ProjPointType<Fp>>} sa1 - The sa1 components (2 elements).
+ * @property {Array<ProjPointType<Fp2>>} sa2 - The sa2 components (6 elements).
+ * @property {PairingOutput} enc_key - The encryption key.
+ * @property {number} t - The threshold value.
+ */
+type Ciphertext = {
+    gamma_g2: ProjPointType<Fp2>;
+    sa1: ProjPointType<Fp>[];
+    sa2: ProjPointType<Fp2>[];
+    enc_key: Fp12;
+    t: number;
+};
+/**
+ * @typedef {Object} PowersOfTau
+ * @property {ArrayLike<ProjPointType<Fp>>} powers_of_g - The powers of g.
+ * @property {ArrayLike<ProjPointType<Fp2>>} powers_of_h - The powers of h.
+ */
+type PowersOfTau = {
+    powers_of_g: ArrayLike<ProjPointType<Fp>>;
+    powers_of_h: ArrayLike<ProjPointType<Fp2>>;
+};
+/**
+ * Encrypts data using the provided parameters and aggregate public key.
+ *
+ * @param params - The PowersOfTau parameters containing powers of g and h.
+ * @param apk - The AggregateKey containing the aggregated public key and preprocessed values.
+ * @param t - The threshold value for encryption.
+ * @returns A Ciphertext object containing the encrypted data.
+ */
+declare const encrypt: (params: PowersOfTau, apk: AggregateKey, t: number) => {
+    gamma_g2: _noble_curves_abstract_weierstrass.WeierstrassPoint<Fp2>;
+    sa1: _noble_curves_abstract_weierstrass.WeierstrassPoint<bigint>[];
+    sa2: ProjPointType<Fp2>[];
+    enc_key: Fp12;
+    t: number;
+};
+/**
+ * Decodes a hex string into a PowersOfTau object.
+ *
+ * @param input - The hex string to decode.
+ * @returns A PowersOfTau object containing the decoded data.
+ */
+declare const decodePowersOfTau: (input: string) => PowersOfTau;
+/**
+ * Decodes a hex string into an AggregateKey object.
+ *
+ * @param input - The hex string to decode.
+ * @returns An AggregateKey object containing the decoded data.
+ */
+declare const decodeAggregateKey: (input: string) => AggregateKey;
+/**
+ * Encode a Ciphertext object into a hex string.
+ *
+ * @param input - The Ciphertext object to encode.
+ * @returns A hex string containing the encoded data.
+ */
+declare const encodeCiphertext: (input: Ciphertext) => string;
+declare const testCrypt: (kzg: string, agg_key: string) => {
+    encoded: string;
+    ikm: string;
+    ciph: Ciphertext;
+};
+
+/**
+ * Generates random bytes of the specified length.
+ * Uses Web Crypto API (crypto.getRandomValues) - available in all modern browsers
+ * and Node.js 18+.
+ *
+ * @param length Number of bytes.
+ * @returns Uint8Array containing random bytes.
+ */
+declare function generateRandomBytes(length?: number): Uint8Array;
+
+interface OnChainRef {
+    blockNumber: number;
+    index: number;
+}
+interface GuardianGroupInfo {
+    groupId: string;
+    guardians: any[];
+    tauParams: string;
+    aggKey: string;
+    groupPk: string;
+}
+interface UploadOptions {
+    name: string;
+    description: string;
+    price: string;
+    type: "model" | "dataset" | "agent";
+    guardianGroupInfo: GuardianGroupInfo;
+    ref?: string;
+    filePath?: string;
+}
+
+declare function writeMetadata(account: any, name: string, description: string, ref: OnChainRef, price: bigint, dataType: number, l2Owner: string, groupId: string): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    tx_result: any;
+}>;
+
+declare function submitData(account: any, data: string): Promise<void>;
+declare function submitTEData(account: any, data: string, chosenGuardians: any[], tau_params: string, agg_key: string, group_pk: string): Promise<OnChainRef>;
+
+declare function uploadData(options: UploadOptions): Promise<void>;
+
+declare const getGuardianList: () => Promise<string[]>;
+
+declare const createGuardianGroup: (account: any, selectedGuardians: any) => Promise<void>;
+
+declare function joinGuardian(account: any, prefs: any): Promise<void>;
+
+declare function addStake(account: any, amount: bigint): Promise<void>;
+
+declare function joinIdleStaker(account: any): Promise<void>;
+
+declare function newStake(account: any, amount: bigint, rewardDestination?: string): Promise<void>;
+
+declare function payoutStake(account: any, eras: Array<number>, address?: string): Promise<void>;
+
+declare function reduceStake(account: any, amount: bigint): Promise<void>;
+
+declare function removeStake(account: any): Promise<void>;
+
+declare function withdrawStake(account: any): Promise<void>;
+
+declare function fundAccount(account: any, amount: bigint, address?: string): Promise<void>;
+
+declare function transfer(account: any, amount: bigint, address: string): Promise<void>;
+
+type Hex = `0x${string}`;
+
+/**
+ * Converts a token amount expressed in milliPALI into the smallest PALI denomination (10^-18 PALI) as a bigint.
+ *
+ * The function takes milliPALI denomination and returns the bigint value in the lowest denomination of the PALI token which is 10^-18.
+ *
+ * @param arg - The token amount to convert. Can be a string, number, or bigint representing an amount in milliPALI.
+ * @returns The token amount converted to the smallest PALI unit (10^-18 PALI) as a bigint.
+ *
+ * @example
+ * // 1 milliPALI => 10^15 lowest-denomination units
+ * tokenToBigint("1"); // => 1000000000000000n
+ */
+declare const tokenToBigint: (arg: string | number | bigint) => bigint;
+/**
+ * Converts a hex string into a Uint8Array.
+ *
+ * @param hex - A hex-encoded string (must contain only hexadecimal characters, without any 0x prefix).
+ * @returns A Uint8Array containing the byte values represented by the hex string.
+ * @throws {Error} If the provided hex string has an odd length (invalid hex string).
+ *
+ * @example
+ * hexToUint8Array("ff00a1"); // => Uint8Array [255, 0, 161]
+ */
+declare function hexToUint8Array(hex: Hex): Uint8Array<ArrayBuffer>;
+/**
+ * Encodes a Uint8Array into a Base64 string using the browser btoa API.
+ *
+ * Note: This implementation builds a binary string via String.fromCharCode for each byte and then calls btoa.
+ * It is intended for browser environments where btoa is available. For very large arrays consider alternative approaches to avoid high memory usage.
+ *
+ * @param uint8Array - The bytes to encode as Base64.
+ * @returns A Base64-encoded string representing the input bytes.
+ *
+ * @example
+ * uint8ArrayToBase64(new Uint8Array([72, 101, 108, 108, 111])); // => "SGVsbG8="
+ */
+declare function uint8ArrayToBase64(uint8Array: Uint8Array): string;
+/**
+ * Decodes a Base64 (or URL-safe Base64) string into a Uint8Array.
+ *
+ * This function normalizes URL-safe base64 by replacing '-' with '+' and '_' with '/', and it adds padding if missing
+ * before decoding with atob. Works in browser environments where atob is available.
+ *
+ * @param base64 - A Base64 or URL-safe Base64 encoded string.
+ * @returns The decoded bytes as a Uint8Array.
+ *
+ * @example
+ * base64ToUint8Array("SGVsbG8="); // => Uint8Array [72, 101, 108, 108, 111]
+ */
+declare const base64ToUint8Array: (base64: string) => Uint8Array;
+/**
+ * Decodes a Base64-encoded field into a Uint8Array and handles possible double-encoding.
+ *
+ * If expectedLength is provided and the decoded byte length does not match, this helper checks whether the decoded result
+ * is exactly twice the expected length. If so, it treats the decoded bytes as a UTF-8 string containing another Base64 value,
+ * decodes that second Base64 string, and returns it if it matches the expected length. Otherwise the initially decoded bytes are returned.
+ *
+ * @param field - The Base64 (or URL-safe Base64) encoded field to decode.
+ * @param expectedLength - Optional expected length of the final decoded byte array. When provided, enables the double-decoding heuristic.
+ * @returns The decoded bytes as a Uint8Array. If double-encoding is detected and validated, the inner decoded bytes are returned.
+ *
+ * @example
+ * // Single-encoded
+ * decodeField("SGVsbG8=", 5); // => Uint8Array [72, 101, 108, 108, 111]
+ *
+ * @example
+ * // Double-encoded: base64(base64(bytes))
+ * decodeField("U0dWc2JHOGU=", 5); // => Uint8Array [72, 101, 108, 108, 111]
+ */
+declare const decodeField: (field: string, expectedLength?: number) => Uint8Array;
+/**
+ * Conditional debug logging utility.
+ * Only logs when DEBUG flag is enabled in config.
+ *
+ * @param message - The message to log
+ * @param optionalParams - Additional parameters to log
+ */
+declare const debugLog: (message?: any, ...optionalParams: any[]) => void;
+
+interface TokenProperties {
+    symbol: string;
+    decimals: number;
+}
+/**
+ * Fetch token name and decimals from RPC system properties
+ * Results are cached for subsequent calls
+ * @param rpc - RPC provider instance with system.properties method
+ * @returns Promise<TokenProperties> with symbol and decimals
+ */
+declare function fetchTokenProperties(): Promise<TokenProperties>;
+/**
+ * Get cached token properties without making an RPC call
+ * @returns TokenProperties or null if not yet cached
+ */
+declare function getCachedTokenProperties(): TokenProperties | null;
+/**
+ * Clear the token properties cache
+ */
+declare function clearTokenCache(): void;
+/**
+ * Format balance using cached token properties
+ * @param balance - The balance value to format
+ * @returns Formatted balance string
+ */
+declare function formatBalanceWithTokenProperties(balance: string | number): Promise<string>;
+
+declare function joinValidator(account: any, commission: number): Promise<void>;
+
+declare let PALLIORA_WS: string;
+declare let PALLIORA_RPC_URL: string;
+declare let DEBUG: boolean;
+declare let TX_WAIT_FINALIZATION: boolean;
+declare function configure(opts: {
+    pallioraWs?: string;
+    pallioraRpcUrl?: string;
+    debug?: boolean;
+    txWaitFinalization?: boolean;
+}): void;
+
+declare function setIdentity(account: any, { display }: any): Promise<void>;
+
+declare function rotateAndSetKeys(account: any): Promise<void>;
+declare function setWorker(account: any): Promise<void>;
+
+export { API_EXTENSIONS, API_RPC, API_TYPES, AccountSourceType, CryptoType, DEBUG, DEFAULT_COMPUTE_PAYLOAD, DEFAULT_EMPTY_PAYLOAD, FileFromMetadataRef, type GuardianGroupInfo, MCryptFs, MCryptFsReader, MCryptFsWriter, type OnChainRef, PALLIORA_RPC_URL, PALLIORA_WS, RpcApi, TX_WAIT_FINALIZATION, type UploadOptions, addStake, base64ToUint8Array, clearTokenCache, configure, createAccount, createAgreement, createGuardianGroup, debugLog, decodeAggregateKey, decodeField, decodePowersOfTau, decrypt, encrypt as ecncryptTest, encodeCiphertext, encrypt$1 as encrypt, fetchTokenProperties, formatBalanceWithTokenProperties, fundAccount, gen_shared_key, gen_stretched_key, generateRandomBytes, getApi, getCachedTokenProperties, getEncKeyring, getFileMetadataCall, getGuardianAddress, getGuardianList, getGuardianNwParams, getGuardianParticipants, getKeyring, getRpcApi, hexToUint8Array, joinGuardian, joinIdleStaker, joinValidator, newStake, pairFromPrivateKeyHex, payoutStake, provider, reduceStake, removeStake, rotateAndSetKeys, setIdentity, setWorker, signAndSend, submitData, submitTEData, testCrypt, tokenToBigint, transfer, uint8ArrayToBase64, uploadData, withdrawStake, writeMetadata };