@palliora.org/chainsdk 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,6 +1,12 @@
 import * as _polkadot_util_crypto_types from '@polkadot/util-crypto/types';
+import { KeyringPair } from '@polkadot/keyring/types';
+import * as _polkadot_types_types from '@polkadot/types/types';
+import { ISubmittableResult } from '@polkadot/types/types';
 import { ApiPromise, Keyring, WsProvider } from '@polkadot/api';
 export { ApiPromise, HttpProvider, WsProvider } from '@polkadot/api';
+import * as _polkadot_types_interfaces from '@polkadot/types/interfaces';
+import { SignedBlock, EventRecord } from '@polkadot/types/interfaces';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
 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';
@@ -30,7 +36,7 @@ declare enum AccountSourceType {
  * @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 createAccount(input: string, type: AccountSourceType, name?: string, cryptoType?: CryptoType): Promise<KeyringPair>;
 declare function pairFromPrivateKeyHex(privateKeyHex: string, cryptoType: CryptoType): _polkadot_util_crypto_types.Keypair;
 
 declare const API_RPC: {
@@ -158,12 +164,182 @@ 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;
+    };
+    ThresholdParams: {
+        _enum: {
+            SilentThreshold: string;
+        };
+    };
+    ChaCha20Poly1305Params: {
+        nonce: string;
+    };
+    Aes256GcmParams: {
+        nonce: string;
+    };
+    SymmetricParams: {
+        _enum: {
+            ChaCha20Poly1305: string;
+            Aes256Gcm: string;
+        };
+    };
+    KdfParams: {
+        _enum: {
+            HkdfSha256: string;
+            HkdfSha512: string;
+        };
+    };
+    Secp256k1Params: {
+        recipient_public_key: string;
+        ephemeral_public_key: string;
+        compressed: string;
+        kdf: string;
+        salt: string;
+        info: string;
+    };
+    Ed25519Params: {
+        recipient_public_key: string;
+        ephemeral_public_key: string;
+        kdf: string;
+        salt: string;
+        info: string;
+    };
+    AsymmetricParams: {
+        _enum: {
+            Secp256k1: string;
+            Ed25519: string;
+        };
+    };
+    ThresholdHybridParams: {
+        threshold_params: string;
+        symmetric_params: string;
+    };
+    AsymmetricHybridParams: {
+        asymmetric_params: string;
+        symmetric_params: string;
+    };
+    CipherSuite: {
+        _enum: {
+            Plaintext: string;
+            ThresholdHybrid: string;
+            AsymmetricHybrid: string;
+        };
+    };
+    ConfidentialityLevel: {
+        _enum: {
+            Trusted: string;
+            TEE: string;
+            FHE: string;
+            SMPC: 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: {
+            Null: string;
+            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: {
@@ -252,6 +428,143 @@ declare const API_EXTENSIONS: {
     };
 };
 
+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;
+
+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 ThresholdParams = {
+    SilentThreshold: SilentThresholdParams;
+};
+type SymmetricParams = {
+    ChaCha20Poly1305: {
+        nonce: number[];
+    };
+} | {
+    Aes256Gcm: {
+        nonce: number[];
+    };
+};
+type KdfParams = "HkdfSha256" | "HkdfSha512";
+interface Secp256k1Params {
+    recipient_public_key: number[];
+    ephemeral_public_key?: number[] | null;
+    compressed: boolean;
+    kdf: KdfParams;
+    salt?: number[] | null;
+    info?: number[] | null;
+}
+interface Ed25519Params {
+    recipient_public_key: number[];
+    ephemeral_public_key?: number[] | null;
+    kdf: KdfParams;
+    salt?: number[] | null;
+    info?: number[] | null;
+}
+type AsymmetricParams = {
+    Secp256k1: Secp256k1Params;
+} | {
+    Ed25519: Ed25519Params;
+};
+interface ThresholdHybridParams {
+    threshold_params: ThresholdParams;
+    symmetric_params: SymmetricParams;
+}
+interface AsymmetricHybridParams {
+    asymmetric_params: AsymmetricParams;
+    symmetric_params: SymmetricParams;
+}
+/** Mirrors the on-chain CipherSuite enum from spec.ts. */
+type CipherSuite = "Plaintext" | {
+    ThresholdHybrid: ThresholdHybridParams;
+} | {
+    AsymmetricHybrid: AsymmetricHybridParams;
+};
+interface SubmitTEDataResult {
+    ref: OnChainRef;
+    cipher: CipherSuite;
+}
+type GuardianAddress = string;
+interface GuardianGroupInfo {
+    groupId: string;
+    guardians: GuardianAddress[];
+    tauParams: string;
+    aggKey: string;
+    groupPk: string;
+}
+interface UploadOptions {
+    name: string;
+    description: 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;
+    };
+}
+
 type OnChainFileOptions = {
     file: File;
     filePath: string;
@@ -259,19 +572,27 @@ type OnChainFileOptions = {
     description: string;
     baseCost: bigint;
     ownerL2Address: string;
-    guardianInfo: any;
+    guardianInfo: GuardianGroupInfo;
+};
+type ChunkRef = {
+    blockNumber: number;
+    extrinsicIndex: number;
+};
+type FileMetadata = {
+    name: string;
+    description: string;
+    startRef: [number, number];
 };
 declare class MCryptFs {
     _api: any;
     _init: boolean;
-    _metaRef: any;
-    _metadata: any;
-    _chunkRefs: any;
-    _startRef: any;
-    constructor(mcryptApi: any, metadataRef: any, metadata: any);
+    _metaRef: [number, number] | null;
+    _metadata: FileMetadata | null;
+    _chunkRefs: ChunkRef[];
+    constructor(mcryptApi: any, metadataRef: [number, number] | null, metadata: FileMetadata | null);
     static dummyInstance(mcryptApi: any): MCryptFs;
     isValid(): void;
-    getMetadata(): any;
+    getMetadata(): FileMetadata | null;
 }
 declare class MCryptFsWriter {
     _file: File;
@@ -282,42 +603,45 @@ declare class MCryptFsWriter {
     _fileName: string;
     _baseCost: bigint;
     _ownerL2Address: string;
-    _guardianInfo: any;
+    _guardianInfo: GuardianGroupInfo;
     _api: any;
-    _account: any;
-    _chunkRefs: any[];
+    _account: KeyringPair;
+    _chunkRefs: ChunkRef[];
     _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;
+    _error: Error | null;
+    constructor(fileOptions: OnChainFileOptions, chunkSize: number | undefined, mcryptApi: any, account: KeyringPair);
+    prependMetadata(chunk: Blob): Blob;
+    writeChunk(chunk: Blob): Promise<{
+        blockNumber: number;
+        index: number;
+    }>;
+    submitKey(account: KeyringPair, data: string): Promise<{
+        blockNumber: number;
+        index: number;
+        hash: `0x${string}`;
+        tx_result: _polkadot_types_types.ISubmittableResult;
     }>;
     writeMetadata(): Promise<{
-        blockNumber: any;
-        index: any;
-        hash: any;
-        tx_result: any;
+        blockNumber: number;
+        index: number;
+        hash: `0x${string}`;
+        tx_result: _polkadot_types_types.ISubmittableResult;
     }>;
     writeFile(): Promise<MCryptFs>;
 }
 declare class MCryptFsReader {
     _filename: string;
     _api: any;
-    _onChainFile: any;
-    constructor(filename: string, mcryptApi: any, onChainFile: any);
+    _onChainFile: MCryptFs;
+    constructor(filename: string, mcryptApi: any, onChainFile: MCryptFs);
     downloadFile(): Promise<Blob>;
 }
-declare const FileFromMetadataRef: (mcryptApi: any, metadataRef: any) => Promise<MCryptFs>;
+declare const FileFromMetadataRef: (mcryptApi: any, metadataRef: [number, number]) => Promise<MCryptFs>;
 
 /**
  * Module providing singleton access to Polkadot API, WebSocket provider, and keyring.
@@ -339,70 +663,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 +677,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,37 +723,222 @@ 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: {
-        da_type: number;
-        verification: number;
-        compute: number;
-    };
-}) => Promise<{
-    blockNumber: any;
-    index: any;
-    hash: any;
-    tx_result: any;
+/** On-chain proof that a result extrinsic was included in a block. */
+interface SubmissionReceipt {
+    /** Hash of the result extrinsic (hex-encoded, "0x..."). */
+    extrinsicHash: string;
+    /** Block height at which the result extrinsic was included. */
+    blockHeight: number;
+    /** Zero-based index of the result extrinsic within the block. */
+    extrinsicIndex: number;
+}
+
+declare const signAndSend: (request: SubmittableExtrinsic<"promise">, account: KeyringPair, opts?: Record<string, unknown>) => Promise<{
+    blockNumber: number;
+    index: number;
+    hash: `0x${string}`;
+    tx_result: ISubmittableResult;
 }>;
-declare const getFileMetadataCall: (api: any, metadataRef: [number, number]) => Promise<any>;
+declare const getFileMetadataCall: (api: ApiPromise, metadataRef: [number, number]) => Promise<_polkadot_types_types.CallBase<_polkadot_types_types.AnyTuple, _polkadot_types_interfaces.FunctionMetadataLatest>>;
 declare const getGuardianAddress: () => Promise<{
     peerid: string;
     address: string;
 }[]>;
-declare const getGuardianNwParams: () => Promise<any>;
+declare const getGuardianNwParams: () => Promise<string>;
+/**
+ * Fetches the block at `blockHeight`, extracts the extrinsic at
+ * `extrinsicIndex`, and returns both the raw codec object and its human-readable
+ * decoded form.
+ *
+ * Throws if the block cannot be found or the index is out of range.
+ */
+declare function fetchAndDecodeExtrinsic(blockHeight: number, extrinsicIndex: number): Promise<{
+    raw: any;
+    decoded: Record<string, unknown>;
+}>;
+type BlockScanFilter = {
+    /** Pallet name, e.g. "dataAvailability" (case-insensitive) */
+    section: string;
+    /** Event name, e.g. "DaccGuardianGroup" (case-insensitive) */
+    method: string;
+    predicate?: never;
+} | {
+    /**
+     * Custom predicate called for every event record in each scanned block.
+     * The full signed block is pre-fetched before any predicate call.
+     * Return true to accept the match and resolve, false to skip and keep scanning.
+     */
+    predicate: (block: SignedBlock, event: EventRecord['event'], phase: EventRecord['phase']) => boolean | Promise<boolean>;
+    section?: never;
+    method?: never;
+};
+type BlockScanResult = {
+    blockHash: string;
+    blockNumber: number;
+    /** Index of the extrinsic that emitted the event, or null for inherents */
+    extrinsicIndex: number | null;
+    /** Returns the full signed block; cached when predicate mode was used */
+    block: () => Promise<SignedBlock>;
+    /** All event records for this block */
+    events: EventRecord[];
+};
+/**
+ * Subscribes to new block headers and resolves with a match descriptor as soon
+ * as a qualifying event is found.
+ *
+ * Supply exactly one of:
+ * - `section` + `method` — lightweight name match, no block fetch
+ * - `predicate(block, event, phase)` — full control; block is pre-fetched
+ *
+ * @param api        Connected ApiPromise instance
+ * @param filter     Either a name filter or a predicate (mutually exclusive)
+ * @param startBlock Ignore blocks with a number strictly below this value
+ * @param maxBlocks  Reject after scanning this many blocks; pass 0 to wait indefinitely (default 20)
+ */
+declare const scanForBlockEvent: (api: ApiPromise, filter: BlockScanFilter, startBlock?: number, maxBlocks?: number) => Promise<BlockScanResult>;
+/**
+ * Subscribes to new block headers and scans each block's extrinsics until a
+ * `compute.result` extrinsic matching `requestId` is found.  Resolves with the
+ * {@link SubmissionReceipt} (extrinsic hash, block height, and extrinsic index).
+ *
+ * The result-relay submits the extrinsic asynchronously, so this watcher may
+ * need to observe several blocks before the tx lands.
+ *
+ * @param requestId  - The hex-encoded request ID to match (e.g. "0xabc123…").
+ * @param timeoutMs  - Milliseconds to wait before giving up (default: 10 min).
+ */
+declare function watchForSubmissionReceipt(requestId: string, timeoutMs?: number): Promise<SubmissionReceipt>;
+/**
+ * Fetches block events at `blockHeight` and returns the request ID from the
+ * `compute.AgreementCreated` event emitted by the extrinsic at `extrinsicIndex`.
+ * Returns `null` if no matching event is found for that extrinsic.
+ */
+declare function getAgreementCreatedRequestId(blockHeight: number, extrinsicIndex: number): Promise<string | null>;
 
 declare const provider: WsProvider;
 
-declare function createAgreement(): Promise<void>;
+interface ComputeContract {
+    contract_type: "Active" | "Dormant";
+    guardians: GuardianAddress[];
+    pre_check?: unknown;
+    compute: Record<string, unknown>;
+    post_check?: unknown;
+    result_cipher: unknown;
+}
+declare function createAgreement(contract: ComputeContract, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    agreementId?: string;
+}>;
+declare function createSimpleAgreement(): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    agreementId?: string;
+}>;
+
+interface DataContractParams {
+    /** URL pointing to the data to store. */
+    url: string;
+    /** Guardian account IDs that participate in this contract. */
+    guardians: 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, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    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: 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, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    agreementId?: string;
+}>;
+
+interface GuardianParticipants {
+    nwState: {
+        localPeerId: string | undefined;
+        worker: unknown;
+        currentEra: unknown;
+        guardians: string | null;
+        nextGuardians: string | null;
+        currentIndex: unknown;
+        nextIndex: number;
+    };
+    currentGuardians: unknown[];
+    upcomingGuardians: unknown[];
+}
+declare function getGuardianParticipants(): Promise<GuardianParticipants>;
 
-declare function getGuardianParticipants(): Promise<any>;
+interface SimpleComputeParams {
+    /** Guardian account IDs that participate in this compute. */
+    guardians: 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, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    agreementId?: string;
+}>;
 
 declare const gen_stretched_key: (input: Uint8Array) => Uint8Array<ArrayBufferLike>;
 declare const gen_shared_key: (key: Uint8Array, pk: Uint8Array) => Uint8Array<ArrayBufferLike>;
@@ -625,78 +1072,120 @@ declare const testCrypt: (kzg: string, agg_key: string) => {
  */
 declare function generateRandomBytes(length?: number): Uint8Array;
 
-interface OnChainRef {
+declare function writeMetadata(account: KeyringPair, name: string, description: string, ref: OnChainRef, price: bigint, dataType: number, l2Owner: string, groupId: string): Promise<{
     blockNumber: number;
     index: number;
-}
-interface GuardianGroupInfo {
-    groupId: string;
-    guardians: any[];
-    tauParams: string;
-    aggKey: string;
-    groupPk: string;
-}
-interface UploadOptions {
+    hash: `0x${string}`;
+    tx_result: _polkadot_types_types.ISubmittableResult;
+}>;
+interface DataAgreementMetadata {
     name: string;
     description: string;
-    price: string;
-    type: "model" | "dataset" | "agent";
-    guardianGroupInfo: GuardianGroupInfo;
-    ref?: string;
-    filePath?: 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: 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: KeyringPair, params: DataAgreementParams): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    agreementId?: 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 runAgent(account: KeyringPair, agentRef: OnChainRef, nonce: Uint8Array, ciphertext: Uint8Array, tdParams: Uint8Array, pkBytes: Uint8Array, tauParams: Uint8Array, baseModel: OnChainRef, publicKey: Uint8Array, guardians: Uint8Array[], guardian?: Uint8Array, agreementId?: Uint8Array): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: `0x${string}`;
+    tx_result: _polkadot_types_types.ISubmittableResult;
 }>;
 
-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 submitData(account: KeyringPair, data: string): Promise<void>;
+declare function submitTEData(account: KeyringPair, data: string, chosenGuardians: string[], 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: KeyringPair, data: string, chosenGuardians: string[], 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[]>;
 
-declare const createGuardianGroup: (account: any, selectedGuardians: any) => Promise<void>;
-
-declare function joinGuardian(account: any, prefs: any): Promise<void>;
+declare const createGuardianGroup: (account: KeyringPair, selectedGuardians: GuardianAddress[]) => Promise<{
+    blockNumber: number;
+    index: number;
+    hash: `0x${string}`;
+    tx_result: _polkadot_types_types.ISubmittableResult;
+}>;
+/**
+ * Creates a guardian group with exactly 3 guardians, waits for tx confirmation,
+ * then watches incoming blocks for the `DaccGuardianGroup` event (emitted by a
+ * subsequent `daccGuardianGroupInfo` extrinsic) and returns the decoded args.
+ *
+ * @param account    Signing account
+ * @param guardians  Exactly 3 guardian addresses / peer-ids
+ * @param maxBlocks  Give up waiting for the event after this many blocks; 0 = indefinite (default 20)
+ */
+declare const createGuardianGroupAndWatch: (account: KeyringPair, guardians: GuardianAddress[], maxBlocks?: number) => Promise<GuardianGroupInfo>;
 
-declare function addStake(account: any, amount: bigint): Promise<void>;
+interface GuardianJoinPrefs {
+    compute?: string;
+    fee?: bigint | string | number;
+    standard?: boolean;
+    verifier?: boolean;
+}
+declare function joinGuardian(account: KeyringPair, prefs: GuardianJoinPrefs): Promise<void>;
 
-declare function joinIdleStaker(account: any): Promise<void>;
+declare function addStake(account: KeyringPair, amountBaseUnits: bigint): Promise<void>;
 
-declare function newStake(account: any, amount: bigint, rewardDestination?: string): Promise<void>;
+declare function joinIdleStaker(account: KeyringPair): Promise<void>;
 
-declare function payoutStake(account: any, eras: Array<number>, address?: string): Promise<void>;
+declare function newStake(account: KeyringPair, amountBaseUnits: bigint, rewardDestination?: string): Promise<void>;
 
-declare function reduceStake(account: any, amount: bigint): Promise<void>;
+declare function payoutStake(account: KeyringPair, eras: Array<number>, address?: string): Promise<void>;
 
-declare function removeStake(account: any): Promise<void>;
+declare function reduceStake(account: KeyringPair, amountBaseUnits: bigint): Promise<void>;
 
-declare function withdrawStake(account: any): Promise<void>;
+declare function removeStake(account: KeyringPair): Promise<void>;
 
-declare function fundAccount(account: any, amount: bigint, address?: string): Promise<void>;
+declare function withdrawStake(account: KeyringPair): Promise<void>;
 
-declare function transfer(account: any, amount: bigint, address: string): Promise<void>;
+declare function fundAccount(account: KeyringPair, amountBaseUnits: bigint, address?: string): Promise<void>;
 
-type Hex = `0x${string}`;
+declare function transfer(account: KeyringPair, 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,34 +1252,7 @@ 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 function joinValidator(account: KeyringPair, commission: number): Promise<void>;
 
 declare let PALLIORA_WS: string;
 declare let PALLIORA_RPC_URL: string;
@@ -803,9 +1265,12 @@ declare function configure(opts: {
     txWaitFinalization?: boolean;
 }): void;
 
-declare function setIdentity(account: any, { display }: any): Promise<void>;
+interface IdentityFields {
+    display?: string;
+}
+declare function setIdentity(account: KeyringPair, { display }: IdentityFields): Promise<void>;
 
-declare function rotateAndSetKeys(account: any): Promise<void>;
-declare function setWorker(account: any): Promise<void>;
+declare function rotateAndSetKeys(account: KeyringPair): Promise<void>;
+declare function setWorker(account: KeyringPair): 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 AsymmetricHybridParams, type AsymmetricParams, type AtomicPaliAmount, type BlockScanFilter, type BlockScanResult, type CipherSuite, type ComputeContract, CryptoType, DEBUG, DEFAULT_COMPUTE_PAYLOAD, DEFAULT_EMPTY_PAYLOAD, type DataAgreementMetadata, type DataAgreementParams, type DataContractParams, type Ed25519Params, FileFromMetadataRef, type GuardianAddress, type GuardianGroupInfo, type GuardianJoinPrefs, type GuardianParticipants, type IdentityFields, type InferenceComputeParams, type KdfParams, MCryptFs, MCryptFsReader, MCryptFsWriter, type OnChainRef, PALI_DECIMALS, PALI_SYMBOL, PALLIORA_RPC_URL, PALLIORA_WS, type PaliAmountInput, type Secp256k1Params, type SilentThresholdParams, type SimpleComputeParams, type SubmissionReceipt, type SubmitTEDataResult, type SymmetricParams, TX_WAIT_FINALIZATION, type ThresholdHybridParams, type ThresholdParams, type UploadOptions, addStake, base64ToUint8Array, clearTokenCache, configure, createAccount, createAgreement, createGuardianGroup, createGuardianGroupAndWatch, createSimpleAgreement, dataContract, debugLog, decodeAggregateKey, decodeField, decodePowersOfTau, decrypt, encrypt as ecncryptTest, encodeCiphertext, encrypt$1 as encrypt, fetchAndDecodeExtrinsic, fetchTokenProperties, formatBalanceWithTokenProperties, formatPaliAmount, fromAtomicPaliAmount, fundAccount, gen_shared_key, gen_stretched_key, generateRandomBytes, getAgreementCreatedRequestId, getApi, getCachedTokenProperties, getEncKeyring, getFileMetadataCall, getGuardianAddress, getGuardianList, getGuardianNwParams, getGuardianParticipants, getKeyring, hexToUint8Array, inferenceCompute, joinGuardian, joinIdleStaker, joinValidator, newStake, pairFromPrivateKeyHex, payoutStake, provider, reduceStake, registerDataAgreement, removeStake, rotateAndSetKeys, runAgent, scanForBlockEvent, setIdentity, setWorker, signAndSend, simpleCompute, submitData, submitTEData, submitTEDataWithCipher, testCrypt, toAtomicPaliAmount, tokenToBigint, transfer, uint8ArrayToBase64, uploadData, uploadDataLegacy, watchForSubmissionReceipt, withdrawStake, writeMetadata };