@palliora.org/chainsdk 0.2.0 → 0.3.1

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: {
@@ -168,7 +174,7 @@ declare const API_TYPES: {
         pk_bytes: string;
         tau_params: string;
     };
-    ThresholdAlgos: {
+    ThresholdParams: {
         _enum: {
             SilentThreshold: string;
         };
@@ -179,24 +185,61 @@ declare const API_TYPES: {
     Aes256GcmParams: {
         nonce: string;
     };
-    SymmetricAlgos: {
+    SymmetricParams: {
         _enum: {
             ChaCha20Poly1305: string;
             Aes256Gcm: string;
         };
     };
-    CipherSuiteEncrypted: {
-        threshold: string;
-        symmetric: 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;
-            Encrypted: string;
+            ThresholdHybrid: string;
+            AsymmetricHybrid: string;
         };
     };
     ConfidentialityLevel: {
-        _enum: string[];
+        _enum: {
+            Trusted: string;
+            TEE: string;
+            FHE: string;
+            SMPC: string;
+        };
     };
     NativeExecuteDA: {
         _enum: string[];
@@ -222,6 +265,7 @@ declare const API_TYPES: {
     };
     DAInput: {
         _enum: {
+            Null: string;
             Inline: string;
             ChainTransaction: string;
             Ipfs: string;
@@ -384,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;
@@ -391,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;
@@ -414,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.
@@ -532,83 +724,124 @@ declare function getKeyring(): Promise<Keyring>;
  */
 declare function getEncKeyring(): Promise<Keyring>;
 
-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 provider: WsProvider;
-
-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;
+declare const getGuardianNwParams: () => Promise<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
+ * 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 fetchTokenProperties(): Promise<TokenProperties>;
+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[];
+};
 /**
- * Get cached token properties without making an RPC call
- * @returns TokenProperties or null if not yet cached
+ * 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 function getCachedTokenProperties(): TokenProperties | null;
+declare const scanForBlockEvent: (api: ApiPromise, filter: BlockScanFilter, startBlock?: number, maxBlocks?: number) => Promise<BlockScanResult>;
 /**
- * Clear the token properties cache
+ * 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 clearTokenCache(): void;
+declare function watchForSubmissionReceipt(requestId: string, timeoutMs?: number): Promise<SubmissionReceipt>;
 /**
- * Format balance using cached token properties
- * @param balance - The balance value to format
- * @returns Formatted balance string
+ * 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 formatBalanceWithTokenProperties(balance: string | number | bigint): Promise<string>;
-declare const tokenToBigint: (amount: PaliAmountInput) => AtomicPaliAmount;
+declare function getAgreementCreatedRequestId(blockHeight: number, extrinsicIndex: number): Promise<string | null>;
+
+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: {
-        peerid: string;
-        address: string;
-    }[];
+    guardians: string[];
     /** Fee offered for the contract in PALI. Defaults to 0. */
     fees?: PaliAmountInput;
     /** Block number deadline. Defaults to 0 (no deadline). */
@@ -625,10 +858,10 @@ interface DataContractParams {
  * - No pre-check or post-check verifications
  * - Plain (unencrypted) result
  */
-declare function dataContract(params: DataContractParams): Promise<{
-    blockNumber: any;
-    index: any;
-    hash: any;
+declare function dataContract(params: DataContractParams, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
     agreementId?: string;
 }>;
 
@@ -636,10 +869,7 @@ 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;
-    }[];
+    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). */
@@ -655,25 +885,35 @@ interface InferenceComputeParams {
  * - 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;
+declare function inferenceCompute(params: InferenceComputeParams, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
     agreementId?: string;
 }>;
 
-declare function getGuardianParticipants(): Promise<any>;
+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>;
 
 interface SimpleComputeParams {
     /** Guardian account IDs that participate in this compute. */
-    guardians: {
-        peerid: string;
-        address: string;
-    }[];
+    guardians: string[];
     /** Input reference block number from which to read the tx payload. */
-    inputBlockNumber: number;
+    inputBlockNumber?: number;
     /** Input reference extrinsic index within the input block. */
-    inputExtrinsicIndex: number;
+    inputExtrinsicIndex?: number;
     /** Program location as URL. */
     programUrl: string;
     /** Fee offered for the compute step in PALI. Defaults to 0. */
@@ -691,10 +931,10 @@ interface SimpleComputeParams {
  * - program fetched from URL
  * - no pre/post verification
  */
-declare function simpleCompute(params: SimpleComputeParams): Promise<{
-    blockNumber: any;
-    index: any;
-    hash: any;
+declare function simpleCompute(params: SimpleComputeParams, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
     agreementId?: string;
 }>;
 
@@ -830,85 +1070,11 @@ 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 {
+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 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[];
-    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;
-    };
-}
-
-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;
+    hash: `0x${string}`;
+    tx_result: _polkadot_types_types.ISubmittableResult;
 }>;
 interface DataAgreementMetadata {
     name: string;
@@ -922,10 +1088,7 @@ interface DataAgreementParams {
     /** DA blob reference returned by submitTEData. */
     ref: OnChainRef;
     /** Guardian account IDs that participate in this agreement. */
-    guardians: {
-        peerid: string;
-        address: string;
-    }[];
+    guardians: string[];
     /** Fee for the agreement in PALI atomic units. */
     fees: bigint;
     /** If provided, populates ComputeInfo.metadata in the contract. */
@@ -944,28 +1107,28 @@ interface DataAgreementParams {
      */
     resultCipher?: CipherSuite;
 }
-declare function registerDataAgreement(account: any, params: DataAgreementParams): Promise<{
-    blockNumber: any;
-    index: any;
-    hash: any;
+declare function registerDataAgreement(account: KeyringPair, params: DataAgreementParams): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
     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 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: any, data: string, chosenGuardians: any[], tau_params: string, agg_key: string, group_pk: string): Promise<SubmitTEDataResult>;
+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>;
 /**
@@ -978,27 +1141,48 @@ declare function uploadDataLegacy(options: Omit<UploadOptions, "opts">): Promise
 
 declare const getGuardianList: () => Promise<string[]>;
 
-declare const createGuardianGroup: (account: any, selectedGuardians: 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 joinGuardian(account: any, prefs: any): 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 addStake(account: any, amountBaseUnits: bigint): Promise<void>;
+declare function addStake(account: KeyringPair, amountBaseUnits: bigint): Promise<void>;
 
-declare function joinIdleStaker(account: any): Promise<void>;
+declare function joinIdleStaker(account: KeyringPair): Promise<void>;
 
-declare function newStake(account: any, amountBaseUnits: bigint, rewardDestination?: string): Promise<void>;
+declare function newStake(account: KeyringPair, amountBaseUnits: bigint, rewardDestination?: string): Promise<void>;
 
-declare function payoutStake(account: any, eras: Array<number>, address?: string): Promise<void>;
+declare function payoutStake(account: KeyringPair, eras: Array<number>, address?: string): Promise<void>;
 
-declare function reduceStake(account: any, amountBaseUnits: bigint): Promise<void>;
+declare function reduceStake(account: KeyringPair, amountBaseUnits: bigint): Promise<void>;
 
-declare function removeStake(account: any): Promise<void>;
+declare function removeStake(account: KeyringPair): Promise<void>;
 
-declare function withdrawStake(account: any): Promise<void>;
+declare function withdrawStake(account: KeyringPair): Promise<void>;
 
-declare function fundAccount(account: any, amountBaseUnits: bigint, address?: string): Promise<void>;
+declare function fundAccount(account: KeyringPair, amountBaseUnits: bigint, address?: string): Promise<void>;
 
-declare function transfer(account: any, amountBaseUnits: bigint, address: string): Promise<void>;
+declare function transfer(account: KeyringPair, amountBaseUnits: bigint, address: string): Promise<void>;
 
 /**
  * Converts a hex string into a Uint8Array.
@@ -1066,12 +1250,13 @@ declare const decodeField: (field: string, expectedLength?: number) => Uint8Arra
  */
 declare const debugLog: (message?: any, ...optionalParams: any[]) => void;
 
-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;
 declare let DEBUG: boolean;
 declare let TX_WAIT_FINALIZATION: boolean;
+declare let provider: WsProvider;
 declare function configure(opts: {
     pallioraWs?: string;
     pallioraRpcUrl?: string;
@@ -1079,9 +1264,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, 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 };
+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 };