@palliora.org/chainsdk 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -158,12 +158,144 @@ declare const API_TYPES: {
         extra: string;
         types: string;
     };
+    FeePayload: {
+        compute: string;
+        guardian: string;
+        verifier: string;
+    };
+    SilentThresholdParams: {
+        td_params: string;
+        pk_bytes: string;
+        tau_params: string;
+    };
+    ThresholdAlgos: {
+        _enum: {
+            SilentThreshold: string;
+        };
+    };
+    ChaCha20Poly1305Params: {
+        nonce: string;
+    };
+    Aes256GcmParams: {
+        nonce: string;
+    };
+    SymmetricAlgos: {
+        _enum: {
+            ChaCha20Poly1305: string;
+            Aes256Gcm: string;
+        };
+    };
+    CipherSuiteEncrypted: {
+        threshold: string;
+        symmetric: string;
+    };
+    CipherSuite: {
+        _enum: {
+            Plaintext: string;
+            Encrypted: string;
+        };
+    };
+    ConfidentialityLevel: {
+        _enum: string[];
+    };
+    NativeExecuteDA: {
+        _enum: string[];
+    };
+    NativeDataDA: {
+        _enum: string[];
+    };
+    DAInputInline: {
+        data: string;
+    };
+    DAInputChainTransaction: {
+        block_number: string;
+        extrinsic_index: string;
+    };
+    DAInputIpfs: {
+        cid: string;
+        size: string;
+    };
+    DAInputUrl: {
+        url: string;
+        size: string;
+        hash: string;
+    };
+    DAInput: {
+        _enum: {
+            Inline: string;
+            ChainTransaction: string;
+            Ipfs: string;
+            Url: string;
+            NativeExecute: string;
+            NativeData: string;
+        };
+    };
+    ContractType: {
+        _enum: {
+            Dormant: string;
+            Active: string;
+        };
+    };
+    StoreType: {
+        _enum: {
+            Dataset: string;
+            Model: string;
+            Agent: string;
+            Other: string;
+        };
+    };
+    ComputeMetadata: {
+        name: string;
+        description: string;
+        store_type: string;
+        group_id: string;
+    };
+    ComputeInfo: {
+        cipher: string;
+        computer_indices: string;
+        fees: string;
+        deadline: string;
+        confidentiality: string;
+        fee_function: string;
+        program_env: string;
+        input: string;
+        program: string;
+        metadata: string;
+    };
+    Contract: {
+        contract_type: string;
+        guardians: string;
+        pre_check: string;
+        compute: string;
+        post_check: string;
+        result_cipher: string;
+    };
+    AgreementInfo: {
+        status: string;
+        creator: string;
+        index: string;
+    };
     ComputePayload: {
         da_type: string;
         agreement: string;
         verification: string;
         compute: string;
     };
+    ComputePrefs: {
+        trusted: string;
+        tee: string;
+        mpc: string;
+        fhe: string;
+        zkp: string;
+    };
+    GuardianPrefs: {
+        pubKey: string;
+        guardian: string;
+        verifier: string;
+        compute: string;
+        computePrefs: string;
+        feeThreshold: string;
+    };
     BlockLengthColumns: string;
     BlockLengthRows: string;
     BlockLength: {
@@ -339,70 +471,6 @@ declare const FileFromMetadataRef: (mcryptApi: any, metadataRef: any) => Promise
  *   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()
  *
@@ -417,9 +485,11 @@ declare class RpcApi {
  *   cause the process to exit so that an external supervisor can restart the
  *   process.
  *
+ * @param cb - Optional callback function to attach to the "disconnected" event.
+ *
  * @returns The singleton {@link ApiPromise} instance (or `undefined` if no provider).
  */
-declare function getApi(): Promise<ApiPromise | undefined>;
+declare function getApi(cb?: () => void): Promise<ApiPromise | undefined>;
 /**
  * getKeyring()
  *
@@ -461,12 +531,6 @@ declare function getKeyring(): Promise<Keyring>;
  * @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: {
@@ -489,10 +553,151 @@ declare const getGuardianNwParams: () => Promise<any>;
 
 declare const provider: WsProvider;
 
-declare function createAgreement(): Promise<void>;
+declare function createAgreement(contract: any, account: any): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    agreementId?: string;
+}>;
+declare function createSimpleAgreement(): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    agreementId?: string;
+}>;
+
+declare const PALI_SYMBOL = "PALI";
+declare const PALI_DECIMALS = 18;
+interface TokenProperties {
+    symbol: string;
+    decimals: number;
+}
+type PaliAmountInput = string | number;
+type AtomicPaliAmount = bigint;
+declare const toAtomicPaliAmount: (amount: PaliAmountInput) => AtomicPaliAmount;
+declare const fromAtomicPaliAmount: (amount: bigint) => string;
+declare const formatPaliAmount: (amount: bigint, symbol?: string) => string;
+/**
+ * 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 | bigint): Promise<string>;
+declare const tokenToBigint: (amount: PaliAmountInput) => AtomicPaliAmount;
+
+interface DataContractParams {
+    /** URL pointing to the data to store. */
+    url: string;
+    /** Guardian account IDs that participate in this contract. */
+    guardians: {
+        peerid: string;
+        address: string;
+    }[];
+    /** Fee offered for the contract in PALI. Defaults to 0. */
+    fees?: PaliAmountInput;
+    /** Block number deadline. Defaults to 0 (no deadline). */
+    deadline?: number;
+    /** Trusted guardian index in the guardians list. Defaults to 0. */
+    trustIndex?: number;
+}
+/**
+ * Submits a dormant data-store contract on-chain via `compute.agreement`.
+ *
+ * - No encryption (Plaintext cipher suite)
+ * - Trusted confidentiality mode
+ * - Input fetched from a URL
+ * - No pre-check or post-check verifications
+ * - Plain (unencrypted) result
+ */
+declare function dataContract(params: DataContractParams): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    agreementId?: string;
+}>;
+
+interface InferenceComputeParams {
+    /** Raw input data — string will be UTF-8 encoded, Uint8Array used as-is. */
+    input: Uint8Array | string;
+    /** Guardian account IDs that participate in this compute. */
+    guardians: {
+        peerid: string;
+        address: string;
+    }[];
+    /** Fee offered for the compute step in PALI. Defaults to 0. */
+    fees?: PaliAmountInput;
+    /** Block number deadline for the compute step. Defaults to 0 (no deadline). */
+    deadline?: number;
+}
+/**
+ * Submits a plain (unencrypted, no-confidentiality) inference compute request
+ * on-chain via the `compute.agreement` extrinsic.
+ *
+ * - Input is sent inline (no DA layer indirection).
+ * - Program is the native `Inference` executor.
+ * - Pre-check and post-check are no-ops (no verification).
+ * - Cipher fields carry zero-value placeholders (unused in the trusted path).
+ * - Result is returned in plain (no re-encryption).
+ */
+declare function inferenceCompute(params: InferenceComputeParams): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    agreementId?: string;
+}>;
 
 declare function getGuardianParticipants(): Promise<any>;
 
+interface SimpleComputeParams {
+    /** Guardian account IDs that participate in this compute. */
+    guardians: {
+        peerid: string;
+        address: string;
+    }[];
+    /** Input reference block number from which to read the tx payload. */
+    inputBlockNumber: number;
+    /** Input reference extrinsic index within the input block. */
+    inputExtrinsicIndex: number;
+    /** Program location as URL. */
+    programUrl: string;
+    /** Fee offered for the compute step in PALI. Defaults to 0. */
+    fees?: PaliAmountInput;
+    /** Block number deadline for the compute step. Defaults to 0 (no deadline). */
+    deadline?: number;
+    /** Trusted guardian index in the guardians list. Defaults to 0. */
+    trustIndex?: number;
+}
+/**
+ * Submits a minimal trusted compute agreement:
+ * - no encryption (plaintext cipher)
+ * - trusted confidentiality mode
+ * - input from chain transaction reference
+ * - program fetched from URL
+ * - no pre/post verification
+ */
+declare function simpleCompute(params: SimpleComputeParams): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    agreementId?: string;
+}>;
+
 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) => {
@@ -625,10 +830,59 @@ declare const testCrypt: (kzg: string, agg_key: string) => {
  */
 declare function generateRandomBytes(length?: number): Uint8Array;
 
+type Hex = `0x${string}`;
+/**
+ * Mirrors the on-chain ComputePayload SCALE type (CheckCompute signed extension).
+ * `agreement` is an array of 32-byte guardian peer-ID keys, obtained by
+ * base58-decoding the peer ID and stripping the first 6 multiaddr prefix bytes.
+ */
+interface ComputePayload {
+    /** DA type: 0 = none, 1 = DA. */
+    da_type: number;
+    /** Guardian agreement keys. Each element is a 32-byte Uint8Array or number[]. */
+    agreement?: Uint8Array[] | number[][];
+    /** Verification mode. */
+    verification: number;
+    /** Compute mode. */
+    compute: number;
+}
+
 interface OnChainRef {
     blockNumber: number;
     index: number;
 }
+interface SilentThresholdParams {
+    /** Encoded threshold ciphertext bytes (from encodeCiphertext). */
+    td_params: number[];
+    /** Guardian group aggregate public key bytes. */
+    pk_bytes: number[];
+    /** KZG powers-of-tau bytes. */
+    tau_params: number[];
+}
+type ThresholdAlgos = {
+    SilentThreshold: SilentThresholdParams;
+};
+type SymmetricAlgos = {
+    ChaCha20Poly1305: {
+        nonce: number[];
+    };
+} | {
+    Aes256Gcm: {
+        nonce: number[];
+    };
+};
+interface CipherSuiteEncrypted {
+    threshold: ThresholdAlgos;
+    symmetric: SymmetricAlgos;
+}
+/** Mirrors the on-chain CipherSuite enum from spec.ts. */
+type CipherSuite = "Plaintext" | {
+    Encrypted: CipherSuiteEncrypted;
+};
+interface SubmitTEDataResult {
+    ref: OnChainRef;
+    cipher: CipherSuite;
+}
 interface GuardianGroupInfo {
     groupId: string;
     guardians: any[];
@@ -639,11 +893,15 @@ interface GuardianGroupInfo {
 interface UploadOptions {
     name: string;
     description: string;
-    price: string;
+    price: PaliAmountInput;
     type: "model" | "dataset" | "agent";
     guardianGroupInfo: GuardianGroupInfo;
     ref?: string;
     filePath?: string;
+    /** Options forwarded to signAndSend. Defaults to dormant DA payload (da_type=1, compute=0). */
+    opts?: {
+        compute: ComputePayload;
+    };
 }
 
 declare function writeMetadata(account: any, name: string, description: string, ref: OnChainRef, price: bigint, dataType: number, l2Owner: string, groupId: string): Promise<{
@@ -652,11 +910,71 @@ declare function writeMetadata(account: any, name: string, description: string,
     hash: any;
     tx_result: any;
 }>;
+interface DataAgreementMetadata {
+    name: string;
+    description: string;
+    /** Maps to the on-chain StoreType enum. */
+    storeType: "Dataset" | "Model" | "Agent" | "Other";
+    /** H256 group identifier. */
+    groupId: string;
+}
+interface DataAgreementParams {
+    /** DA blob reference returned by submitTEData. */
+    ref: OnChainRef;
+    /** Guardian account IDs that participate in this agreement. */
+    guardians: {
+        peerid: string;
+        address: string;
+    }[];
+    /** Fee for the agreement in PALI atomic units. */
+    fees: bigint;
+    /** If provided, populates ComputeInfo.metadata in the contract. */
+    metadata?: DataAgreementMetadata;
+    /** Block number deadline. Defaults to 0 (no deadline). */
+    deadline?: number;
+    /** Trusted guardian index in the guardians list. Defaults to 0. */
+    trustIndex?: number;
+    /**
+     * CipherSuite for the compute step input. Defaults to "Plaintext".
+     * Pass the `cipher` from submitTEDataWithCipher for the threshold-encrypted path.
+     */
+    cipher?: CipherSuite;
+    /**
+     * CipherSuite for the agreement result. Defaults to "Plaintext".
+     */
+    resultCipher?: CipherSuite;
+}
+declare function registerDataAgreement(account: any, params: DataAgreementParams): Promise<{
+    blockNumber: any;
+    index: any;
+    hash: any;
+    agreementId?: string;
+}>;
+
+declare function runAgent(account: any, agentRef: OnChainRef, nonce: Uint8Array, ciphertext: Uint8Array, tdParams: Uint8Array, pkBytes: Uint8Array, tauParams: Uint8Array, baseModel: OnChainRef, publicKey: Uint8Array, guardians: Uint8Array[], guardian?: Uint8Array, agreementId?: Uint8Array): 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>;
+/**
+ * Identical to submitTEData but additionally returns the populated CipherSuite
+ * so callers can pass it directly to registerDataAgreement without
+ * re-deriving the cipher parameters.
+ */
+declare function submitTEDataWithCipher(account: any, data: string, chosenGuardians: any[], tau_params: string, agg_key: string, group_pk: string): Promise<SubmitTEDataResult>;
 
 declare function uploadData(options: UploadOptions): Promise<void>;
+/**
+ * Legacy upload: uses submitTEData (returns only OnChainRef) and registers
+ * the agreement with Plaintext cipher and no ComputePayload opts.
+ * Kept for backward compatibility with callers that do not need cipher
+ * parameters surfaced in the on-chain agreement.
+ */
+declare function uploadDataLegacy(options: Omit<UploadOptions, "opts">): Promise<void>;
 
 declare const getGuardianList: () => Promise<string[]>;
 
@@ -664,39 +982,24 @@ declare const createGuardianGroup: (account: any, selectedGuardians: any) => Pro
 
 declare function joinGuardian(account: any, prefs: any): Promise<void>;
 
-declare function addStake(account: any, amount: bigint): Promise<void>;
+declare function addStake(account: any, amountBaseUnits: bigint): Promise<void>;
 
 declare function joinIdleStaker(account: any): Promise<void>;
 
-declare function newStake(account: any, amount: bigint, rewardDestination?: string): Promise<void>;
+declare function newStake(account: any, amountBaseUnits: 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 reduceStake(account: any, amountBaseUnits: 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>;
+declare function fundAccount(account: any, amountBaseUnits: bigint, address?: string): Promise<void>;
 
-type Hex = `0x${string}`;
+declare function transfer(account: any, amountBaseUnits: bigint, address: string): Promise<void>;
 
-/**
- * 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.
  *
@@ -763,33 +1066,6 @@ declare const decodeField: (field: string, expectedLength?: number) => Uint8Arra
  */
 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;
@@ -808,4 +1084,4 @@ 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 };
+export { API_EXTENSIONS, API_RPC, API_TYPES, AccountSourceType, type AtomicPaliAmount, type CipherSuite, type CipherSuiteEncrypted, CryptoType, DEBUG, DEFAULT_COMPUTE_PAYLOAD, DEFAULT_EMPTY_PAYLOAD, type DataAgreementMetadata, type DataAgreementParams, type DataContractParams, FileFromMetadataRef, type GuardianGroupInfo, type InferenceComputeParams, MCryptFs, MCryptFsReader, MCryptFsWriter, type OnChainRef, PALI_DECIMALS, PALI_SYMBOL, PALLIORA_RPC_URL, PALLIORA_WS, type PaliAmountInput, type SilentThresholdParams, type SimpleComputeParams, type SubmitTEDataResult, type SymmetricAlgos, TX_WAIT_FINALIZATION, type ThresholdAlgos, type UploadOptions, addStake, base64ToUint8Array, clearTokenCache, configure, createAccount, createAgreement, createGuardianGroup, createSimpleAgreement, dataContract, debugLog, decodeAggregateKey, decodeField, decodePowersOfTau, decrypt, encrypt as ecncryptTest, encodeCiphertext, encrypt$1 as encrypt, fetchTokenProperties, formatBalanceWithTokenProperties, formatPaliAmount, fromAtomicPaliAmount, fundAccount, gen_shared_key, gen_stretched_key, generateRandomBytes, getApi, getCachedTokenProperties, getEncKeyring, getFileMetadataCall, getGuardianAddress, getGuardianList, getGuardianNwParams, getGuardianParticipants, getKeyring, hexToUint8Array, inferenceCompute, joinGuardian, joinIdleStaker, joinValidator, newStake, pairFromPrivateKeyHex, payoutStake, provider, reduceStake, registerDataAgreement, removeStake, rotateAndSetKeys, runAgent, setIdentity, setWorker, signAndSend, simpleCompute, submitData, submitTEData, submitTEDataWithCipher, testCrypt, toAtomicPaliAmount, tokenToBigint, transfer, uint8ArrayToBase64, uploadData, uploadDataLegacy, withdrawStake, writeMetadata };