@arcium-hq/client 0.1.46 → 0.1.47

package/build/index.d.ts

@@ -1,11 +1,24 @@
 import { IField } from '@noble/curves/abstract/modular';
+import { CurveFn } from '@noble/curves/abstract/edwards';
 import * as anchor from '@coral-xyz/anchor';
 import { AnchorProvider, Program, BN } from '@coral-xyz/anchor';
 import { PublicKey, Finality } from '@solana/web3.js';
 export { x25519 } from '@noble/curves/ed25519';
 
+/**
+ * Scalar field prime modulus for Curve25519: 2^252 + 27742317777372353535851937790883648493
+ */
 declare const CURVE25519_SCALAR_FIELD_MODULUS: bigint;
+/**
+ * Encrypts a value into the format expected by the DA layer, using secret sharing and encryption for each node's public key.
+ * @param val - The value to secret-share and encrypt.
+ * @param nodeX25519Keys - The array of node X25519 public keys.
+ * @returns An array of SecretShare objects, one for each node.
+ */
 declare function secretShareValue(val: bigint, nodeX25519Keys: Uint8Array[]): SecretShare[];
+/**
+ * Structure representing a secret share, including ciphertext, nonce, and ephemeral public key.
+ */
 type SecretShare = {
     ciphertext: Uint8Array;
     nonce: Uint8Array;
@@ -13,29 +26,59 @@ type SecretShare = {
 };
 /**
  * Generates secret shares for a given value in the Curve25519 field.
- * @param secret The secret value to be shared (as a BigInt)
- * @param n The number of shares to generate
- * @param mod The modulo of the field over which to generate shares
- * @returns An array of n secret shares
+ * @param secret - The secret value to be shared (as a BigInt).
+ * @param n - The number of shares to generate.
+ * @param mod - The modulo of the field over which to generate shares (default: CURVE25519_SCALAR_FIELD_MODULUS).
+ * @returns An array of n secret shares as bigints.
  */
 declare function genRawShares(secret: bigint, n: number, mod?: bigint): bigint[];
 /**
- * Encrypts a field element for the DA layer.
- * @param publicKey The recipient's x25519 public key
- * @param valueToEncrypt The bigint value to encrypt
- * @param modulo Bound on the value
- * @returns An object containing the ciphertext and ephemeral public key. Always pads to 32 bytes.
+ * Encrypts a field element for the DA layer using the recipient's x25519 public key.
+ * @param publicKey - The recipient's x25519 public key.
+ * @param valueToEncrypt - The bigint value to encrypt.
+ * @param modulo - Bound on the value (default: CURVE25519_SCALAR_FIELD_MODULUS).
+ * @returns An object containing the ciphertext, nonce, and ephemeral public key.
  */
 declare function encryptForDA(publicKey: Uint8Array, valueToEncrypt: bigint, modulo?: bigint): SecretShare;
+/**
+ * Computes a shared encryption key using ECDH (x25519) and hashes it with blake2s.
+ * @param privKey - The private key as a Uint8Array.
+ * @param pubKey - The public key as a Uint8Array.
+ * @returns The derived encryption key as a Uint8Array.
+ */
 declare function getEncryptionKey(privKey: Uint8Array, pubKey: Uint8Array): Uint8Array;
 /**
- * Generates a random val within the field bound by q.
+ * Generates a random value within the field bound by q.
+ * @param q - The upper bound (exclusive) for the random value.
  * @returns A random bigint value between 0 and q-1.
-*/
+ */
 declare function generateRandomFieldElem(q: bigint): bigint;
+/**
+ * Computes the positive modulo of a over m.
+ * @param a - The dividend.
+ * @param m - The modulus.
+ * @returns The positive remainder of a mod m.
+ */
 declare function positiveModulo(a: bigint, m: bigint): bigint;
+/**
+ * Serializes a bigint to a little-endian Uint8Array of the specified length.
+ * @param val - The bigint value to serialize.
+ * @param lengthInBytes - The desired length of the output array.
+ * @returns The serialized value as a Uint8Array.
+ * @throws Error if the value is too large for the specified length.
+ */
 declare function serializeLE(val: bigint, lengthInBytes: number): Uint8Array;
+/**
+ * Deserializes a little-endian Uint8Array to a bigint.
+ * @param bytes - The Uint8Array to deserialize.
+ * @returns The deserialized bigint value.
+ */
 declare function deserializeLE(bytes: Uint8Array): bigint;
+/**
+ * Computes the SHA-256 hash of an array of Uint8Arrays.
+ * @param byteArrays - The arrays to hash.
+ * @returns The SHA-256 hash as a Buffer.
+ */
 declare function sha256(byteArrays: Uint8Array[]): Buffer;
 
 /**
@@ -80,8 +123,18 @@ type HashFunction = {
     m: number;
     capacity: number;
 };
+/**
+ * Field type for Curve25519 base field.
+ */
 type FpField = IField<bigint>;
+/**
+ * Curve25519 base field as an IField instance.
+ */
 declare const CURVE25519_BASE_FIELD: FpField;
+/**
+ * Description and parameters for the Rescue cipher or hash function, including round constants, MDS matrix, and key schedule.
+ * See: https://tosc.iacr.org/index.php/ToSC/article/view/8695/8287
+ */
 declare class RescueDesc {
     mode: RescueMode;
     field: FpField;
@@ -92,29 +145,195 @@ declare class RescueDesc {
     mdsMat: Matrix;
     mdsMatInverse: Matrix;
     roundKeys: Matrix[];
+    /**
+     * Constructs a RescueDesc for a given field and mode (cipher or hash).
+     * Initializes round constants, MDS matrix, and key schedule.
+     * @param field - The field to use (e.g., CURVE25519_BASE_FIELD).
+     * @param mode - The mode: block cipher or hash function.
+     */
     constructor(field: FpField, mode: RescueMode);
+    /**
+     * Samples round constants for the Rescue permutation, using SHAKE256.
+     * @param nRounds - The number of rounds.
+     * @returns An array of round constant matrices.
+     */
     sampleConstants(nRounds: number): Matrix[];
+    /**
+     * Applies the Rescue permutation to a state matrix.
+     * @param state - The input state matrix.
+     * @returns The permuted state matrix.
+     */
     permute(state: Matrix): Matrix;
+    /**
+     * Applies the inverse Rescue permutation to a state matrix.
+     * @param state - The input state matrix.
+     * @returns The inverse-permuted state matrix.
+     */
     permuteInverse(state: Matrix): Matrix;
 }
 declare function toVec(data: bigint[]): bigint[][];
 
+/**
+ * The Rescue cipher in Counter (CTR) mode, with a fixed block size m = 5.
+ * See: https://tosc.iacr.org/index.php/ToSC/article/view/8695/8287
+ */
 declare class RescueCipher {
     desc: RescueDesc;
+    /**
+     * Constructs a RescueCipher instance using a shared secret.
+     * The key is derived using HKDF-RescuePrime and used to initialize the RescueDesc.
+     * @param sharedSecret - The shared secret to derive the cipher key from.
+     */
     constructor(sharedSecret: Uint8Array);
+    /**
+     * Encrypts the plaintext vector in Counter (CTR) mode (raw, returns bigints).
+     * @param plaintext - The array of plaintext bigints to encrypt.
+     * @param nonce - A 16-byte nonce for CTR mode.
+     * @returns The ciphertext as an array of bigints.
+     * @throws Error if the nonce is not 16 bytes long.
+     */
     encrypt_raw(plaintext: bigint[], nonce: Uint8Array): bigint[];
+    /**
+     * Encrypts the plaintext vector in Counter (CTR) mode and serializes each block.
+     * @param plaintext - The array of plaintext bigints to encrypt.
+     * @param nonce - A 16-byte nonce for CTR mode.
+     * @returns The ciphertext as an array of arrays of numbers (each 32 bytes).
+     */
     encrypt(plaintext: bigint[], nonce: Uint8Array): number[][];
+    /**
+     * Decrypts the ciphertext vector in Counter (CTR) mode (raw, expects bigints).
+     * @param ciphertext - The array of ciphertext bigints to decrypt.
+     * @param nonce - A 16-byte nonce for CTR mode.
+     * @returns The decrypted plaintext as an array of bigints.
+     * @throws Error if the nonce is not 16 bytes long.
+     */
     decrypt_raw(ciphertext: bigint[], nonce: Uint8Array): bigint[];
+    /**
+     * Deserializes and decrypts the ciphertext vector in Counter (CTR) mode.
+     * @param ciphertext - The array of arrays of numbers (each 32 bytes) to decrypt.
+     * @param nonce - A 16-byte nonce for CTR mode.
+     * @returns The decrypted plaintext as an array of bigints.
+     */
     decrypt(ciphertext: number[][], nonce: Uint8Array): bigint[];
 }
 
+/**
+ * The Rescue-Prime hash function, as described in https://eprint.iacr.org/2020/1143.pdf.
+ * Used with fixed m = 6 and capacity = 1 (rate = 5). According to Section 2.2, this offers log2(CURVE25519_BASE_FIELD.ORDER) / 2 bits of security against collision, preimage, and second-preimage attacks.
+ * See the referenced paper for further details.
+ */
 declare class RescuePrimeHash {
     desc: RescueDesc;
     rate: number;
+    /**
+     * Constructs a RescuePrimeHash instance with m = 6 and capacity = 1.
+     */
     constructor();
+    /**
+     * Computes the Rescue-Prime hash of a message, with padding as described in Algorithm 2 of the paper.
+     * @param message - The input message as an array of bigints.
+     * @returns The hash output as an array of bigints (length = rate).
+     */
     digest(message: bigint[]): bigint[];
 }
 
+/**
+ * Ed25519 curve instance using SHA3-512 for hashing, suitable for MPC (ArcisEd25519 signature scheme).
+ * This is essentially Ed25519 but with SHA3-512 instead of SHA-512 for lower multiplicative depth.
+ * See: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1
+ */
+declare const arcisEd25519: CurveFn;
+
+/**
+ * AES-128 cipher in Counter (CTR) mode, using HKDF-SHA3-256 to derive the key from a shared secret.
+ * See: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf (Section 6.5) for details on CTR mode.
+ */
+declare class Aes128Cipher {
+    key: Uint8Array;
+    /**
+     * Constructs an AES-128 cipher instance using a shared secret.
+     * The key is derived using HKDF-SHA3-256.
+     * @param sharedSecret - The shared secret to derive the AES key from.
+     */
+    constructor(sharedSecret: Uint8Array);
+    /**
+     * Encrypts the plaintext array in Counter (CTR) mode.
+     * @param plaintext - The data to encrypt.
+     * @param nonce - An 8-byte nonce for CTR mode.
+     * @returns The encrypted ciphertext as a Uint8Array.
+     * @throws Error if the nonce is not 8 bytes long.
+     */
+    encrypt(plaintext: Uint8Array, nonce: Uint8Array): Uint8Array;
+    /**
+     * Decrypts the ciphertext array in Counter (CTR) mode.
+     * @param ciphertext - The data to decrypt.
+     * @param nonce - An 8-byte nonce for CTR mode.
+     * @returns The decrypted plaintext as a Uint8Array.
+     * @throws Error if the nonce is not 8 bytes long.
+     */
+    decrypt(ciphertext: Uint8Array, nonce: Uint8Array): Uint8Array;
+}
+
+/**
+ * AES-192 cipher in Counter (CTR) mode, using HKDF-SHA3-256 to derive the key from a shared secret.
+ * See: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf (Section 6.5) for details on CTR mode.
+ */
+declare class Aes192Cipher {
+    key: Uint8Array;
+    /**
+     * Constructs an AES-192 cipher instance using a shared secret.
+     * The key is derived using HKDF-SHA3-256.
+     * @param sharedSecret - The shared secret to derive the AES key from.
+     */
+    constructor(sharedSecret: Uint8Array);
+    /**
+     * Encrypts the plaintext array in Counter (CTR) mode.
+     * @param plaintext - The data to encrypt.
+     * @param nonce - An 8-byte nonce for CTR mode.
+     * @returns The encrypted ciphertext as a Uint8Array.
+     * @throws Error if the nonce is not 8 bytes long.
+     */
+    encrypt(plaintext: Uint8Array, nonce: Uint8Array): Uint8Array;
+    /**
+     * Decrypts the ciphertext array in Counter (CTR) mode.
+     * @param ciphertext - The data to decrypt.
+     * @param nonce - An 8-byte nonce for CTR mode.
+     * @returns The decrypted plaintext as a Uint8Array.
+     * @throws Error if the nonce is not 8 bytes long.
+     */
+    decrypt(ciphertext: Uint8Array, nonce: Uint8Array): Uint8Array;
+}
+
+/**
+ * AES-256 cipher in Counter (CTR) mode, using HKDF-SHA3-256 to derive the key from a shared secret.
+ * See: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf (Section 6.5) for details on CTR mode.
+ */
+declare class Aes256Cipher {
+    key: Uint8Array;
+    /**
+     * Constructs an AES-256 cipher instance using a shared secret.
+     * The key is derived using HKDF-SHA3-256.
+     * @param sharedSecret - The shared secret to derive the AES key from.
+     */
+    constructor(sharedSecret: Uint8Array);
+    /**
+     * Encrypts the plaintext array in Counter (CTR) mode.
+     * @param plaintext - The data to encrypt.
+     * @param nonce - An 8-byte nonce for CTR mode.
+     * @returns The encrypted ciphertext as a Uint8Array.
+     * @throws Error if the nonce is not 8 bytes long.
+     */
+    encrypt(plaintext: Uint8Array, nonce: Uint8Array): Uint8Array;
+    /**
+     * Decrypts the ciphertext array in Counter (CTR) mode.
+     * @param ciphertext - The data to decrypt.
+     * @param nonce - An 8-byte nonce for CTR mode.
+     * @returns The decrypted plaintext as a Uint8Array.
+     * @throws Error if the nonce is not 8 bytes long.
+     */
+    decrypt(ciphertext: Uint8Array, nonce: Uint8Array): Uint8Array;
+}
+
 /**
  * Program IDL in camelCase format in order to be used in JS/TS.
  *
@@ -125,7 +344,7 @@ type Arcium = {
     'address': 'BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6';
     'metadata': {
         'name': 'arcium';
-        'version': '0.1.46';
+        'version': '0.1.47';
         'spec': '0.1.0';
         'description': 'The Arcium program';
     };
@@ -10646,7 +10865,7 @@ type Arcium = {
 var address = "BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6";
 var metadata = {
 	name: "arcium",
-	version: "0.1.46",
+	version: "0.1.47",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -21187,6 +21406,9 @@ declare namespace arcium$1 {
   export { arcium$1_accounts as accounts, arcium$1_address as address, arcium as default, arcium$1_errors as errors, arcium$1_events as events, arcium$1_instructions as instructions, arcium$1_metadata as metadata, arcium$1_types as types };
 }
 
+/**
+ * The deployed address of the Arcium program, as specified in the IDL.
+ */
 declare const ARCIUM_ADDR: "BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6";
 
 type NodeDAInfo = {
@@ -21195,22 +21417,96 @@ type NodeDAInfo = {
 };
 type MempoolAcc = anchor.IdlTypes<Arcium>['tinyMempool'] | anchor.IdlTypes<Arcium>['smallMempool'] | anchor.IdlTypes<Arcium>['mediumMempool'] | anchor.IdlTypes<Arcium>['largeMempool'];
 type ExecpoolAcc = anchor.IdlTypes<Arcium>['tinyExecPool'] | anchor.IdlTypes<Arcium>['smallExecPool'] | anchor.IdlTypes<Arcium>['mediumExecPool'] | anchor.IdlTypes<Arcium>['largeExecPool'];
+/**
+ * Returns the public key of the deployed Arcium program on Solana.
+ * @returns The Arcium program's public key.
+ */
 declare function getArciumProgAddress(): anchor.web3.PublicKey;
+/**
+ * Fetches the DA (Data Availability) info for all nodes in a cluster.
+ * @param provider - The Anchor provider to use for fetching accounts.
+ * @param clusterAddr - The public key of the cluster account.
+ * @returns An array of NodeDAInfo objects for each node in the cluster.
+ */
 declare function getClusterDAInfo(provider: AnchorProvider, clusterAddr: anchor.web3.PublicKey): Promise<NodeDAInfo[]>;
+/**
+ * Fetches and decodes the mempool account data for any mempool account size.
+ * @param provider - The Anchor provider to use for fetching accounts.
+ * @param mempoolAccPubkey - The public key of the mempool account.
+ * @returns The decoded mempool account data.
+ * @throws Error if the account cannot be fetched or the discriminator is unknown.
+ */
 declare function getMempoolAccData(provider: AnchorProvider, mempoolAccPubkey: anchor.web3.PublicKey): Promise<MempoolAcc>;
+/**
+ * Fetches and decodes the executing pool account data for any pool size.
+ * @param provider - The Anchor provider to use for fetching accounts.
+ * @param executingPoolAccPubkey - The public key of the executing pool account.
+ * @returns The decoded executing pool account data.
+ * @throws Error if the account cannot be fetched or the discriminator is unknown.
+ */
 declare function getExecutingPoolAccData(provider: AnchorProvider, executingPoolAccPubkey: anchor.web3.PublicKey): Promise<ExecpoolAcc>;
+/**
+ * Uploads a circuit to the blockchain, splitting it into multiple accounts if necessary.
+ * @param provider - The Anchor provider to use for transactions.
+ * @param circuitName - The name of the circuit.
+ * @param mxeProgramID - The public key of the MXE program.
+ * @param rawCircuit - The raw circuit data as a Uint8Array.
+ * @param logging - Whether to log progress (default: true).
+ * @param chunkSize - The number of upload transactions to send in parallel (default: 500).
+ * @returns An array of transaction signatures for all upload and finalize transactions.
+ */
 declare function uploadCircuit(provider: AnchorProvider, circuitName: string, mxeProgramID: anchor.web3.PublicKey, rawCircuit: Uint8Array, logging?: boolean, chunkSize?: number): Promise<string[]>;
+/**
+ * Builds a transaction to finalize a computation definition.
+ * @param provider - The Anchor provider to use for transactions.
+ * @param compDefOffset - The offset of the computation definition.
+ * @param mxeProgramID - The public key of the MXE program.
+ * @returns The transaction to finalize the computation definition.
+ */
 declare function buildFinalizeCompDefTx(provider: AnchorProvider, compDefOffset: number, mxeProgramID: anchor.web3.PublicKey): Promise<anchor.web3.Transaction>;
+/**
+ * Returns the base seed for an Arcium account, given its name.
+ * @param accName - The name of the account.
+ * @returns The base seed as a Uint8Array.
+ */
 declare function getArciumAccountBaseSeed(accName: string): Uint8Array;
+/**
+ * Computes the offset for a computation definition account, based on the circuit name.
+ * @param circuitName - The name of the circuit.
+ * @returns The offset as a 4-byte Uint8Array.
+ */
 declare function getCompDefAccOffset(circuitName: string): Uint8Array;
+/**
+ * Returns an Anchor program instance for the Arcium program.
+ * @param provider - The Anchor provider to use.
+ * @returns The Anchor program instance for Arcium.
+ */
 declare function getArciumProgram(provider: AnchorProvider): Program<Arcium>;
+/**
+ * Returns a read-only Anchor program instance for the Arcium program.
+ * @param provider - The Anchor provider to use.
+ * @returns The Anchor program instance for Arcium.
+ */
 declare function getArciumProgramReadonly(provider: AnchorProvider): Program<Arcium>;
 
 type MScalar = bigint | '_mscalar';
 type MFloat = number | '_mfloat';
 type MBoolean = boolean | '_mboolean';
+/**
+ * Number of mantissa bits for double-precision floating point values.
+ */
 declare const DOUBLE_PRECISION_MANTISSA = 52;
+/**
+ * Encodes a value as a bigint suitable for Rescue encryption, handling booleans, bigints, and numbers.
+ * The encoding is performed in constant-time to avoid leaking information through timing side-channels.
+ * Throws if the value is out of the supported range for the field.
+ * @param v - The value to encode (MScalar, MFloat, or MBoolean).
+ * @returns The encoded value as a bigint.
+ */
 declare function encodeAsRescueEncryptable(v: MScalar | MFloat | MBoolean): bigint;
+/**
+ * Describes a value type for circuit interface arguments and outputs.
+ */
 type Value = {
     type: 'mscalar';
     size_in_bits: number;
@@ -21249,6 +21545,9 @@ type Value = {
     type: 'struct';
     content: readonly Value[];
 };
+/**
+ * Describes an argument to a circuit interface, including its value type and whether it is a raw input or object reference.
+ */
 type Argument = {
     value: Value;
     type: {
@@ -21256,17 +21555,29 @@ type Argument = {
         is_mutable?: boolean;
     };
 };
+/**
+ * Describes the interface for a confidential computation circuit, including its name, inputs, and output count.
+ */
 type CircuitInterface = {
     name: string;
     inputs: readonly Argument[];
     output_count: number;
 };
+/**
+ * Converts a struct value definition to a TypeScript type.
+ */
 type JsonToStruct<C> = {
     [K in keyof C]: C[K] extends Value ? JsonToValue<C[K]> : never;
 };
+/**
+ * Converts an array value definition to a TypeScript type.
+ */
 type JsonToArray<C> = {
     [K in keyof C]: C[K] extends Value ? JsonToValue<C[K]> : never;
 };
+/**
+ * Converts a Value type to its corresponding TypeScript type.
+ */
 type JsonToValue<T extends Value> = T extends {
     type: 'struct';
     content: infer C;
@@ -21296,6 +21607,9 @@ type JsonToValue<T extends Value> = T extends {
 } ? MBoolean : T extends {
     type: 'bool';
 } ? boolean : never;
+/**
+ * Converts an Argument type to its corresponding TypeScript type, handling raw inputs and object references.
+ */
 type JsonToArgument<T extends Argument> = T['type'] extends {
     type: 'raw_input';
 } ? {
@@ -21306,48 +21620,143 @@ type JsonToArgument<T extends Argument> = T['type'] extends {
     value: JsonToValue<T['value']>;
     isMutable: T['type']['is_mutable'];
 } : never;
+/**
+ * Converts an Argument type to its corresponding TypeScript type, filtering only raw input data objects.
+ */
 type JsonToArgumentFilteredDataObjs<T extends Argument> = T['type'] extends {
     type: 'raw_input';
 } ? {
     value: JsonToValue<T['value']>;
 } : never;
+/**
+ * Converts an array of Argument types to their corresponding TypeScript types.
+ */
 type JsonToInputArr<T extends readonly Argument[]> = {
     [K in keyof T]: JsonToArgument<T[K]>;
 };
+/**
+ * Converts an array of Argument types to their corresponding TypeScript types, filtering only raw input data objects.
+ */
 type JsonToInputArrFilteredDataObjs<T extends readonly Argument[]> = T extends [] ? [] : T extends [infer H extends Argument, ...infer R extends readonly Argument[]] ? H['type'] extends {
     'type': 'object_reference';
 } ? JsonToInputArrFilteredDataObjs<R> : [JsonToArgumentFilteredDataObjs<H>, ...JsonToInputArrFilteredDataObjs<R>] : T;
+/**
+ * Converts a CircuitInterface type to a TypeScript type representing its name, inputs, and output count.
+ */
 type JsonToCircuitInterface<T extends CircuitInterface> = {
     name: T['name'];
     inputs: JsonToInputArr<T['inputs']>;
     outputCount: T['output_count'];
 };
+/**
+ * Type alias for a confidential instruction, based on a circuit interface.
+ */
 type ConfidentialInstruction<T extends CircuitInterface> = JsonToCircuitInterface<T>;
+/**
+ * Type alias for the raw confidential instruction inputs, filtering only raw input data objects.
+ */
 type RawConfidentialInstructionInputs<T extends CircuitInterface> = JsonToInputArrFilteredDataObjs<T['inputs']>;
+/**
+ * Secret-shares the inputs for a confidential instruction, encoding each value as needed and splitting it for each node's public key.
+ * @param ixInput - The array of input values to secret-share.
+ * @param nodeX25519Keys - The array of node X25519 public keys to share with.
+ * @returns A 2D array of SecretShare objects, one array per input value.
+ * @throws Error if an input type cannot be parsed.
+ */
 declare function secretShareInputs(ixInput: readonly ({
     value: readonly (MScalar | MFloat | MBoolean)[];
 } | {
     value: MScalar | MFloat | MBoolean;
 } | never)[], nodeX25519Keys: Uint8Array[]): SecretShare[][];
 
+/**
+ * Structure representing the local Arcium environment variables required for local development or testing.
+ */
 type ArciumLocalEnv = {
     arciumClusterPubkey: PublicKey;
     callbackServerPubkey: PublicKey;
 };
+/**
+ * Reads local Arcium environment information from environment variables.
+ * Only available in Node.js and when testing locally.
+ * @returns The local Arcium environment configuration.
+ * @throws Error if called in a browser or if required environment variables are missing or invalid.
+ */
 declare function getArciumEnv(): ArciumLocalEnv;
 
+/**
+ * Represents possible error messages that can occur during computation processing or transaction handling.
+ */
 type ComputationErrorType = `Transaction ${string} not found` | 'Transaction inner instructions not found' | `Transaction failed with error: ${string}` | 'No log messages found' | 'No queue computation instruction found' | `Invalid computation offset: ${string}` | 'Computation not found in executing pool, might have already executed' | `Error fetching transactions: ${string}` | `Instruction at index ${number} not found` | 'Account keys or program ID index not found' | `No Program ID found for instruction at index ${number}` | 'Max retries reached while searching for transaction';
+/**
+ * Waits for the finalization of a computation by listening for the finalizeComputationEvent.
+ * Resolves with the transaction signature once the computation is finalized.
+ * @param provider - The Anchor provider to use for event listening.
+ * @param computationOffset - The offset of the computation to wait for.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @param commitment - (Optional) The desired finality/commitment level (default: 'confirmed').
+ * @returns The transaction signature of the finalization event.
+ */
 declare function awaitComputationFinalization(provider: AnchorProvider, computationOffset: BN, mxeProgramId: PublicKey, commitment?: Finality): Promise<string>;
 
+/**
+ * Returns the public key of the deployed Arcium program on Solana.
+ * @returns The Arcium program's public key.
+ */
 declare function getArciumProgramId(): PublicKey;
-declare function getComputationAcc(mxeProgramId: PublicKey, offset: anchor.BN): PublicKey;
-declare function getMempoolAcc(mxeProgramId: PublicKey): PublicKey;
-declare function getExecutingPoolAcc(mxeProgramId: PublicKey): PublicKey;
-declare function getStakingPoolAcc(): PublicKey;
-declare function getClockAcc(): PublicKey;
-declare function getClusterAcc(offset: number): PublicKey;
-declare function getArxNodeAcc(offset: number): PublicKey;
-declare function getMXEAccAcc(mxeProgramId: PublicKey): PublicKey;
-declare function getCompDefAcc(mxeProgramId: PublicKey, offset: number): PublicKey;
+/**
+ * Derives the computation account address for a given MXE program ID and offset.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @param offset - The computation offset as an anchor.BN.
+ * @returns The derived computation account public key.
+ */
+declare function getComputationAccAddress(mxeProgramId: PublicKey, offset: anchor.BN): PublicKey;
+/**
+ * Derives the mempool account address for a given MXE program ID.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @returns The derived mempool account public key.
+ */
+declare function getMempoolAccAddress(mxeProgramId: PublicKey): PublicKey;
+/**
+ * Derives the executing pool account address for a given MXE program ID.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @returns The derived executing pool account public key.
+ */
+declare function getExecutingPoolAccAddress(mxeProgramId: PublicKey): PublicKey;
+/**
+ * Derives the staking pool account address.
+ * @returns The derived staking pool account public key.
+ */
+declare function getStakingPoolAccAddress(): PublicKey;
+/**
+ * Derives the clock account address.
+ * @returns The derived clock account public key.
+ */
+declare function getClockAccAddress(): PublicKey;
+/**
+ * Derives the cluster account address for a given offset.
+ * @param offset - The cluster offset as a number.
+ * @returns The derived cluster account public key.
+ */
+declare function getClusterAccAddress(offset: number): PublicKey;
+/**
+ * Derives the ArxNode account address for a given offset.
+ * @param offset - The ArxNode offset as a number.
+ * @returns The derived ArxNode account public key.
+ */
+declare function getArxNodeAccAddress(offset: number): PublicKey;
+/**
+ * Derives the MXE account address for a given MXE program ID.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @returns The derived MXE account public key.
+ */
+declare function getMXEAccAddress(mxeProgramId: PublicKey): PublicKey;
+/**
+ * Derives the computation definition account address for a given MXE program ID and offset.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @param offset - The computation definition offset as a number.
+ * @returns The derived computation definition account public key.
+ */
+declare function getCompDefAccAddress(mxeProgramId: PublicKey, offset: number): PublicKey;
 
-export { ARCIUM_ADDR, arcium$1 as ARCIUM_IDL, type Arcium as ArciumIdlType, type ArciumLocalEnv, CURVE25519_BASE_FIELD, CURVE25519_SCALAR_FIELD_MODULUS, type CircuitInterface, type ComputationErrorType, type ConfidentialInstruction, DOUBLE_PRECISION_MANTISSA, type FpField, type JsonToArgument, type JsonToArgumentFilteredDataObjs, type JsonToCircuitInterface, type JsonToInputArr, type JsonToInputArrFilteredDataObjs, type JsonToValue, type MBoolean, type MFloat, type MScalar, Matrix, type NodeDAInfo, type RawConfidentialInstructionInputs, RescueCipher, RescueDesc, RescuePrimeHash, type SecretShare, awaitComputationFinalization, buildFinalizeCompDefTx, deserializeLE, encodeAsRescueEncryptable, encryptForDA, genRawShares, generateRandomFieldElem, getArciumAccountBaseSeed, getArciumEnv, getArciumProgAddress, getArciumProgram, getArciumProgramId, getArciumProgramReadonly, getArxNodeAcc, getClockAcc, getClusterAcc, getClusterDAInfo, getCompDefAcc, getCompDefAccOffset, getComputationAcc, getEncryptionKey, getExecutingPoolAcc, getExecutingPoolAccData, getMXEAccAcc, getMempoolAcc, getMempoolAccData, getStakingPoolAcc, positiveModulo, randMatrix, secretShareInputs, secretShareValue, serializeLE, sha256, toVec, uploadCircuit };
+export { ARCIUM_ADDR, arcium$1 as ARCIUM_IDL, Aes128Cipher, Aes192Cipher, Aes256Cipher, type Arcium as ArciumIdlType, type ArciumLocalEnv, CURVE25519_BASE_FIELD, CURVE25519_SCALAR_FIELD_MODULUS, type CircuitInterface, type ComputationErrorType, type ConfidentialInstruction, DOUBLE_PRECISION_MANTISSA, type FpField, type JsonToArgument, type JsonToArgumentFilteredDataObjs, type JsonToCircuitInterface, type JsonToInputArr, type JsonToInputArrFilteredDataObjs, type JsonToValue, type MBoolean, type MFloat, type MScalar, Matrix, type NodeDAInfo, type RawConfidentialInstructionInputs, RescueCipher, RescueDesc, RescuePrimeHash, type SecretShare, arcisEd25519, awaitComputationFinalization, buildFinalizeCompDefTx, deserializeLE, encodeAsRescueEncryptable, encryptForDA, genRawShares, generateRandomFieldElem, getArciumAccountBaseSeed, getArciumEnv, getArciumProgAddress, getArciumProgram, getArciumProgramId, getArciumProgramReadonly, getArxNodeAccAddress, getClockAccAddress, getClusterAccAddress, getClusterDAInfo, getCompDefAccAddress, getCompDefAccOffset, getComputationAccAddress, getEncryptionKey, getExecutingPoolAccAddress, getExecutingPoolAccData, getMXEAccAddress, getMempoolAccAddress, getMempoolAccData, getStakingPoolAccAddress, positiveModulo, randMatrix, secretShareInputs, secretShareValue, serializeLE, sha256, toVec, uploadCircuit };