@arcium-hq/client 0.1.46 → 0.1.47

package/build/index.cjs

@@ -6,6 +6,8 @@ var ed25519 = require('@noble/curves/ed25519');
 var anchor = require('@coral-xyz/anchor');
 var sha3 = require('@noble/hashes/sha3');
 var modular = require('@noble/curves/abstract/modular');
+var utils = require('@noble/hashes/utils');
+var edwards = require('@noble/curves/abstract/edwards');
 var web3_js = require('@solana/web3.js');
 
 function _interopNamespaceDefault(e) {
@@ -27,7 +29,12 @@ function _interopNamespaceDefault(e) {
 
 var anchor__namespace = /*#__PURE__*/_interopNamespaceDefault(anchor);
 
-// Converts a bigint to an array of bits (least significant to most significant, in 2's complement representation).
+/**
+ * Converts a bigint to an array of bits (least significant to most significant, in 2's complement representation).
+ * @param x - The bigint to convert.
+ * @param binSize - The number of bits to use in the representation.
+ * @returns An array of booleans representing the bits of x.
+ */
 function toBinLE(x, binSize) {
     const res = [];
     for (let i = 0; i < binSize; ++i) {
@@ -35,7 +42,11 @@ function toBinLE(x, binSize) {
     }
     return res;
 }
-// Converts an array of bits (least significant to most significant, in 2's complement representation) to a bigint.
+/**
+ * Converts an array of bits (least significant to most significant, in 2's complement representation) to a bigint.
+ * @param xBin - The array of bits to convert.
+ * @returns The bigint represented by the bit array.
+ */
 function fromBinLE(xBin) {
     let res = 0n;
     for (let i = 0; i < xBin.length - 1; ++i) {
@@ -43,8 +54,14 @@ function fromBinLE(xBin) {
     }
     return res - (BigInt(xBin[xBin.length - 1]) << BigInt(xBin.length - 1));
 }
-// Binary adder between x and y (we assume that xBin and yBin are of same length,
-// and that the length is large enough to represent the sum of the two).
+/**
+ * Binary adder between x and y (assumes xBin and yBin are of the same length and large enough to represent the sum).
+ * @param xBin - The first operand as a bit array.
+ * @param yBin - The second operand as a bit array.
+ * @param carryIn - The initial carry-in value.
+ * @param binSize - The number of bits to use in the operation.
+ * @returns The sum as a bit array.
+ */
 function adder(xBin, yBin, carryIn, binSize) {
     const res = [];
     let carry = carryIn;
@@ -59,12 +76,24 @@ function adder(xBin, yBin, carryIn, binSize) {
     }
     return res;
 }
-// Constant time addition.
+/**
+ * Constant-time addition of two bigints, using 2's complement representation.
+ * @param x - The first operand.
+ * @param y - The second operand.
+ * @param binSize - The number of bits to use in the operation.
+ * @returns The sum as a bigint.
+ */
 function ctAdd(x, y, binSize) {
     const resBin = adder(toBinLE(x, binSize), toBinLE(y, binSize), false, binSize);
     return fromBinLE(resBin);
 }
-// Constant time subtraction.
+/**
+ * Constant-time subtraction of two bigints, using 2's complement representation.
+ * @param x - The first operand.
+ * @param y - The second operand.
+ * @param binSize - The number of bits to use in the operation.
+ * @returns The difference as a bigint.
+ */
 function ctSub(x, y, binSize) {
     const yBin = toBinLE(y, binSize);
     const yBinNot = [];
@@ -74,23 +103,44 @@ function ctSub(x, y, binSize) {
     const resBin = adder(toBinLE(x, binSize), yBinNot, true, binSize);
     return fromBinLE(resBin);
 }
-// Constant time sign bit circuit.
+/**
+ * Returns the sign bit of a bigint in constant time.
+ * @param x - The bigint to check.
+ * @param binSize - The bit position to check (typically the highest bit).
+ * @returns True if the sign bit is set, false otherwise.
+ */
 function ctSignBit(x, binSize) {
     return ((x >> binSize) & 1n) === 1n;
 }
-// Constant time less than circuit.
+/**
+ * Constant-time less-than comparison for two bigints.
+ * @param x - The first operand.
+ * @param y - The second operand.
+ * @param binSize - The number of bits to use in the operation.
+ * @returns True if x < y, false otherwise.
+ */
 function ctLt(x, y, binSize) {
     return ctSignBit(ctSub(x, y, binSize), binSize);
 }
-// Constant time select.
+/**
+ * Constant-time select between two bigints based on a boolean condition.
+ * @param b - The condition; if true, select x, otherwise select y.
+ * @param x - The value to select if b is true.
+ * @param y - The value to select if b is false.
+ * @param binSize - The number of bits to use in the operation.
+ * @returns The selected bigint.
+ */
 function ctSelect(b, x, y, binSize) {
     return ctAdd(y, BigInt(b) * (ctSub(x, y, binSize)), binSize);
 }
-// This function returns `true` if -2^binSize <= x < 2^binSize, and `false` otherwise.
-// The function is not constant-time for arbitrary x, but it is so for all inputs
-// for which the function returns `true`. If you assert your inputs to satisfy
-// verifyBinSize(x, binSize), then you need not care about the non constant-timeness
-// of this function.
+/**
+ * Checks if a bigint fits in the range -2^binSize <= x < 2^binSize.
+ * Not constant-time for arbitrary x, but is constant-time for all inputs for which the function returns true.
+ * If you assert your inputs satisfy verifyBinSize(x, binSize), you need not care about the non constant-timeness of this function.
+ * @param x - The bigint to check.
+ * @param binSize - The number of bits to use in the check.
+ * @returns True if x fits in the range, false otherwise.
+ */
 function verifyBinSize(x, binSize) {
     const bin = (x >> binSize).toString(2);
     return bin === '0' || bin === '-1';
@@ -278,10 +328,17 @@ function randMatrix(field, nrows, ncols) {
     return new Matrix(field, data);
 }
 
+/**
+ * Curve25519 base field as an IField instance.
+ */
 const CURVE25519_BASE_FIELD = ed25519.ed25519.CURVE.Fp;
 // hardcode security level to 128 bits
 const SECURITY_LEVEL = 128;
 // We refer to https://tosc.iacr.org/index.php/ToSC/article/view/8695/8287 for more details.
+/**
+ * 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
+ */
 class RescueDesc {
     mode;
     field;
@@ -297,6 +354,12 @@ class RescueDesc {
     mdsMatInverse;
     // The round keys, needed for encryption and decryption.
     roundKeys;
+    /**
+     * 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, mode) {
         this.field = field;
         this.mode = mode;
@@ -342,6 +405,11 @@ class RescueDesc {
             }
         }
     }
+    /**
+     * Samples round constants for the Rescue permutation, using SHAKE256.
+     * @param nRounds - The number of rounds.
+     * @returns An array of round constant matrices.
+     */
     sampleConstants(nRounds) {
         const field = this.field;
         const m = this.m;
@@ -415,9 +483,19 @@ class RescueDesc {
             default: return [];
         }
     }
+    /**
+     * Applies the Rescue permutation to a state matrix.
+     * @param state - The input state matrix.
+     * @returns The permuted state matrix.
+     */
     permute(state) {
         return rescuePermutation(this.mode, this.alpha, this.alphaInverse, this.mdsMat, this.roundKeys, state)[2 * this.nRounds];
     }
+    /**
+     * Applies the inverse Rescue permutation to a state matrix.
+     * @param state - The input state matrix.
+     * @returns The inverse-permuted state matrix.
+     */
     permuteInverse(state) {
         return rescuePermutationInverse(this.mode, this.alpha, this.alphaInverse, this.mdsMatInverse, this.roundKeys, state)[2 * this.nRounds];
     }
@@ -589,7 +667,17 @@ function toVec(data) {
     return dataVec;
 }
 
+/**
+ * Number of mantissa bits for double-precision floating point values.
+ */
 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.
+ */
 function encodeAsRescueEncryptable(v) {
     if (typeof v === 'boolean') {
         return v ? 1n : 0n;
@@ -618,6 +706,13 @@ function encodeAsRescueEncryptable(v) {
 // but typescript kept thinking ixInput: readonly null[] and I can't figure out why, so we do this hack
 // for now.
 // TODO: Revisit and fix the types correctly.
+/**
+ * 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.
+ */
 function secretShareInputs(ixInput, nodeX25519Keys) {
     const shares = [];
     // Need to explicitly tell typescript input can be any of these, else it only thinks {} is possible
@@ -669,9 +764,16 @@ function getBinSize(max) {
     return BigInt(Math.floor(Math.log2(Number(max)))) + 3n;
 }
 
-// Scalar field prime modulus 2^252 + 27742317777372353535851937790883648493
+/**
+ * Scalar field prime modulus for Curve25519: 2^252 + 27742317777372353535851937790883648493
+ */
 const CURVE25519_SCALAR_FIELD_MODULUS = ed25519.ed25519.CURVE.n;
-// High level function for encrypting a value into the format the da layer expects
+/**
+ * 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.
+ */
 function secretShareValue(val, nodeX25519Keys) {
     const rawShares = genRawShares(val, nodeX25519Keys.length, CURVE25519_SCALAR_FIELD_MODULUS);
     return zip(rawShares, nodeX25519Keys).map(([share, key]) => encryptForDA(key, share, CURVE25519_SCALAR_FIELD_MODULUS));
@@ -690,10 +792,10 @@ function newSecretShare(ciphertext, nonce, ephemeralPublicKey) {
 }
 /**
  * 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.
  */
 function genRawShares(secret, n, mod = CURVE25519_SCALAR_FIELD_MODULUS) {
     const shares = [];
@@ -709,11 +811,11 @@ function genRawShares(secret, n, mod = CURVE25519_SCALAR_FIELD_MODULUS) {
 }
 /// ENCRYPTION
 /**
- * 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.
  */
 function encryptForDA(publicKey, valueToEncrypt, modulo = CURVE25519_SCALAR_FIELD_MODULUS) {
     // Check if the value to encrypt is smaller than the modulo
@@ -729,6 +831,12 @@ function encryptForDA(publicKey, valueToEncrypt, modulo = CURVE25519_SCALAR_FIEL
     const { ciphertext, nonce } = aesCtrEncrypt(valueToEncrypt, sharedSecret);
     return newSecretShare(ciphertext, nonce, ephemeralPublicKey);
 }
+/**
+ * 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.
+ */
 function getEncryptionKey(privKey, pubKey) {
     const sharedSecret = ed25519.x25519.getSharedSecret(privKey, pubKey);
     return blake2s.blake2s(sharedSecret);
@@ -762,9 +870,10 @@ function aesCtrEncrypt(val, key) {
 }
 /// HELPERS
 /**
- * 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.
-*/
+ */
 function generateRandomFieldElem(q) {
     const byteLength = (q.toString(2).length + 7) >> 3;
     let r;
@@ -774,10 +883,22 @@ function generateRandomFieldElem(q) {
     } while (r >= q);
     return r;
 }
-// Helper function for positive modulo
+/**
+ * Computes the positive modulo of a over m.
+ * @param a - The dividend.
+ * @param m - The modulus.
+ * @returns The positive remainder of a mod m.
+ */
 function positiveModulo(a, m) {
     return ((a % m) + m) % m;
 }
+/**
+ * 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.
+ */
 function serializeLE(val, lengthInBytes) {
     const result = new Uint8Array(lengthInBytes);
     let tempVal = val;
@@ -790,6 +911,11 @@ function serializeLE(val, lengthInBytes) {
     }
     return result;
 }
+/**
+ * Deserializes a little-endian Uint8Array to a bigint.
+ * @param bytes - The Uint8Array to deserialize.
+ * @returns The deserialized bigint value.
+ */
 function deserializeLE(bytes) {
     let result = BigInt(0);
     for (let i = 0; i < bytes.length; i++) {
@@ -798,6 +924,11 @@ function deserializeLE(bytes) {
     return result;
 }
 // GENERAL
+/**
+ * Computes the SHA-256 hash of an array of Uint8Arrays.
+ * @param byteArrays - The arrays to hash.
+ * @returns The SHA-256 hash as a Buffer.
+ */
 function sha256(byteArrays) {
     const hash = crypto.createHash('sha256');
     byteArrays.forEach((byteArray) => {
@@ -806,19 +937,28 @@ function sha256(byteArrays) {
     return hash.digest();
 }
 
-/// The Rescue-Prime hash funtion, see https://eprint.iacr.org/2020/1143.pdf.
-/// We use it with fixed m = 6 and capacity = 1, hence 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.
+/**
+ * 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.
+ */
 class RescuePrimeHash {
     desc;
     rate;
+    /**
+     * Constructs a RescuePrimeHash instance with m = 6 and capacity = 1.
+     */
     constructor() {
         this.desc = new RescueDesc(CURVE25519_BASE_FIELD, { kind: 'hash', m: 6, capacity: 1 });
         this.rate = 6 - 1;
     }
     // This is Algorithm 1 from https://eprint.iacr.org/2020/1143.pdf, though with the padding (see Algorithm 2).
     // The hash function outputs this.rate elements.
+    /**
+     * 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) {
         message.push(1n);
         while (message.length % this.rate !== 0) {
@@ -848,21 +988,33 @@ class RescuePrimeHash {
     }
 }
 
-/// The HMAC-Rescue-Prime function. Since Rescue-Prime is based on the sponge construction,
-/// the traditional HMAC can be replaced by the simpler MAC, see e.g.
-/// https://keccak.team/files/SpongeFunctions.pdf (Appendix B) or
-/// https://keccak.team/keccak_strengths.html.
+/**
+ * HMACRescuePrime provides a message authentication code (MAC) using the Rescue-Prime hash function.
+ * Rescue-Prime is based on the sponge construction, which allows the use of a simpler MAC in place of the traditional HMAC.
+ * For more details and explanations, see: https://keccak.team/files/SpongeFunctions.pdf (Appendix B) or https://keccak.team/keccak_strengths.html.
+ */
 class HMACRescuePrime {
     hasher;
+    /**
+     * Constructs a new HMACRescuePrime instance.
+     */
     constructor() {
         this.hasher = new RescuePrimeHash();
     }
+    /**
+     * Computes the HMAC (or MAC) digest of a message with a given key using Rescue-Prime.
+     * The key is padded to the hash function's rate, then concatenated with the message.
+     * @param key - The key as an array of bigints.
+     * @param message - The message as an array of bigints.
+     * @returns The MAC digest as an array of bigints.
+     * @throws Error if the key is longer than the hash function's rate.
+     */
     digest(key, message) {
         // HMAC-digest(key, message) = hasher.digest(key || message), since Rescue-Prime is based on
         // the sponge construction.
         // We follow https://datatracker.ietf.org/doc/html/rfc2104, though since Rescue-Prime is not based
         // on the Merkle-Damgard construction we cannot have an exact anology between the
-        // parameters. For our purpose, we set B = L = hasher.rate().
+        // parameters. For our purpose, we set B = L = hasher.rate.
         if (key.length > this.hasher.rate) {
             throw Error(`length of key is supposed to be at most the hash function's rate (found ${key.length} and ${this.hasher.rate})`);
         }
@@ -875,39 +1027,82 @@ class HMACRescuePrime {
     }
 }
 
-/// The HMAC-Rescue-Prime function. Since Rescue-Prime is based on the sponge construction,
-/// the traditional HMAC can be replaced by the simpler MAC, see e.g.
-/// https://keccak.team/files/SpongeFunctions.pdf (Appendix B) or
-/// https://keccak.team/keccak_strengths.html.
+/**
+ * HKDF (HMAC-based Extract-and-Expand Key Derivation Function) using the Rescue-Prime hash function.
+ * Follows RFC 5869. Only supports L = HashLen.
+ */
 class HKDFRescuePrime {
     hmac;
+    /**
+     * Constructs a new HKDFRescuePrime instance.
+     */
     constructor() {
         this.hmac = new HMACRescuePrime();
     }
+    /**
+     * HKDF-Extract step: derives a pseudorandom key (PRK) from the input keying material (IKM) and salt.
+     * @param salt - The salt value as an array of bigints.
+     * @param ikm - The input keying material as an array of bigints.
+     * @returns The pseudorandom key (PRK) as an array of bigints.
+     */
     extract(salt, ikm) {
+        if (salt.length === 0) {
+            // HashLen = hasher.rate for Rescue-Prime
+            for (let i = 0; i < this.hmac.hasher.rate; ++i) {
+                salt.push(0n);
+            }
+        }
         return this.hmac.digest(salt, ikm);
     }
+    /**
+     * HKDF-Expand step: expands the pseudorandom key (PRK) with info to produce output keying material (OKM).
+     * Only supports L = HashLen = 5, i.e. N = 1.
+     * @param prk - The pseudorandom key as an array of bigints.
+     * @param info - The context and application specific information as an array of bigints.
+     * @returns The output keying material (OKM) as an array of bigints.
+     */
     expand(prk, info) {
-        // we go with L = HashLen = 5, i.e. N = 1
+        // we only support L = HashLen = 5, i.e. N = 1
+        // message = empty string | info | 0x01
         info.push(1n);
         return this.hmac.digest(prk, info);
     }
+    /**
+     * Performs the full HKDF (extract and expand) to derive output keying material (OKM).
+     * @param salt - The salt value as an array of bigints.
+     * @param ikm - The input keying material as an array of bigints.
+     * @param info - The context and application specific information as an array of bigints.
+     * @returns The output keying material (OKM) as an array of bigints.
+     */
     okm(salt, ikm, info) {
         const prk = this.extract(salt, ikm);
         return this.expand(prk, info);
     }
 }
 
-/// The Rescue cipher, see https://tosc.iacr.org/index.php/ToSC/article/view/8695/8287.
-/// We use it in Counter (CTR) mode, with a fixed m = 5.
+/**
+ * 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
+ */
 class RescueCipher {
     desc;
+    /**
+     * 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) {
         const hkdf = new HKDFRescuePrime();
-        const rescueKey = hkdf.okm([0n, 0n, 0n, 0n, 0n], [deserializeLE(sharedSecret)], [0n]);
+        const rescueKey = hkdf.okm([], [deserializeLE(sharedSecret)], []);
         this.desc = new RescueDesc(CURVE25519_BASE_FIELD, { kind: 'cipher', key: rescueKey });
     }
-    /// Encrypt the plaintext vector in Counter (CTR) mode.
+    /**
+     * 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, nonce) {
         if (nonce.length !== 16) {
             throw Error(`nonce must be of length 16 (found ${nonce.length})`);
@@ -940,11 +1135,22 @@ class RescueCipher {
         }
         return ciphertext;
     }
-    /// Encrypt the plaintext vector in Counter (CTR) mode and serialize.
+    /**
+     * 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, nonce) {
         return this.encrypt_raw(plaintext, nonce).map((c) => Array.from(serializeLE(c, 32)));
     }
-    /// Decrypt the ciphertext vector in Counter (CTR) mode.
+    /**
+     * 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, nonce) {
         if (nonce.length !== 16) {
             throw Error(`nonce must be of length 16 (found ${nonce.length})`);
@@ -974,7 +1180,12 @@ class RescueCipher {
         }
         return decrypted;
     }
-    /// Deserialize and decrypt the ciphertext vector in Counter (CTR) mode
+    /**
+     * 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, nonce) {
         return this.decrypt_raw(ciphertext.map((c) => {
             if (c.length !== 32) {
@@ -984,6 +1195,12 @@ class RescueCipher {
         }), nonce);
     }
 }
+/**
+ * Generates the counter values for Rescue cipher CTR mode.
+ * @param nonce - The initial nonce as a bigint.
+ * @param nBlocks - The number of blocks to generate counters for.
+ * @returns An array of counter values as bigints.
+ */
 function getCounter(nonce, nBlocks) {
     const counter = [];
     for (let i = 0n; i < nBlocks; ++i) {
@@ -996,10 +1213,203 @@ function getCounter(nonce, nBlocks) {
     return counter;
 }
 
+// The arcisEd25519 signature scheme. This is essentially ed25519 but we use the hash function
+// SHA3-512 instead of SHA-512 since its multiplicative depth is much lower, which
+// makes it much better suited to be evaluated in MPC.
+// Those are the parameters specified [here](https://datatracker.ietf.org/doc/html/rfc8032#section-5.1)
+// (except for the hash function, see above). The below is copied from [here](https://github.com/paulmillr/noble-curves/blob/main/src/ed25519.ts#L111).
+const arcisEd25519Defaults = (() => ({
+    a: BigInt(-1),
+    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
+    Fp: ed25519.ed25519.CURVE.Fp,
+    n: BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989'),
+    h: BigInt(8),
+    Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
+    Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
+    hash: sha3.sha3_512,
+    randomBytes: utils.randomBytes,
+    adjustScalarBytes,
+    uvRatio,
+}))();
+/**
+ * Clamps a 32-byte scalar as required by the Ed25519 signature scheme.
+ * See: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.5
+ * @param bytes - The 32-byte scalar to clamp.
+ * @returns The clamped scalar as a Uint8Array.
+ */
+function adjustScalarBytes(bytes) {
+    const clamped = bytes;
+    clamped[0] &= 248;
+    clamped[31] &= 127;
+    clamped[31] |= 64;
+    return clamped;
+}
+/**
+ * Dummy function for compatibility; not used in the ArcisEd25519 signature scheme.
+ * Always returns { isValid: true, value: 0n }.
+ * @returns An object with isValid: true and value: 0n.
+ */
+function uvRatio() {
+    return { isValid: true, value: 0n };
+}
+/**
+ * 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
+ */
+const arcisEd25519 = (() => edwards.twistedEdwards(arcisEd25519Defaults))();
+
+/**
+ * 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.
+ */
+class Aes128Cipher {
+    key;
+    /**
+     * 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) {
+        const aesKey = crypto.hkdfSync('sha3-256', sharedSecret, new Uint8Array(), new Uint8Array(), 16);
+        this.key = new Uint8Array(aesKey);
+    }
+    /**
+     * 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, nonce) {
+        if (nonce.length !== 8) {
+            throw Error(`nonce must be of length 8 (found ${nonce.length})`);
+        }
+        const paddedNonce = Buffer.concat([nonce, Buffer.alloc(16 - nonce.length, 0)]);
+        const cipher = crypto.createCipheriv('aes-128-ctr', this.key, paddedNonce);
+        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        return new Uint8Array(ciphertext);
+    }
+    /**
+     * 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, nonce) {
+        if (nonce.length !== 8) {
+            throw Error(`nonce must be of length 8 (found ${nonce.length})`);
+        }
+        const paddedNonce = Buffer.concat([nonce, Buffer.alloc(16 - nonce.length, 0)]);
+        const cipher = crypto.createDecipheriv('aes-128-ctr', this.key, paddedNonce);
+        const decrypted = Buffer.concat([cipher.update(ciphertext), cipher.final()]);
+        return new Uint8Array(decrypted);
+    }
+}
+
+/**
+ * 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.
+ */
+class Aes192Cipher {
+    key;
+    /**
+     * 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) {
+        const aesKey = crypto.hkdfSync('sha3-256', sharedSecret, new Uint8Array(), new Uint8Array(), 24);
+        this.key = new Uint8Array(aesKey);
+    }
+    /**
+     * 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, nonce) {
+        if (nonce.length !== 8) {
+            throw Error(`nonce must be of length 8 (found ${nonce.length})`);
+        }
+        const paddedNonce = Buffer.concat([nonce, Buffer.alloc(16 - nonce.length, 0)]);
+        const cipher = crypto.createCipheriv('aes-192-ctr', this.key, paddedNonce);
+        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        return new Uint8Array(ciphertext);
+    }
+    /**
+     * 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, nonce) {
+        if (nonce.length !== 8) {
+            throw Error(`nonce must be of length 8 (found ${nonce.length})`);
+        }
+        const paddedNonce = Buffer.concat([nonce, Buffer.alloc(16 - nonce.length, 0)]);
+        const cipher = crypto.createDecipheriv('aes-192-ctr', this.key, paddedNonce);
+        const decrypted = Buffer.concat([cipher.update(ciphertext), cipher.final()]);
+        return new Uint8Array(decrypted);
+    }
+}
+
+/**
+ * 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.
+ */
+class Aes256Cipher {
+    key;
+    /**
+     * 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) {
+        const aesKey = crypto.hkdfSync('sha3-256', sharedSecret, new Uint8Array(), new Uint8Array(), 32);
+        this.key = new Uint8Array(aesKey);
+    }
+    /**
+     * 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, nonce) {
+        if (nonce.length !== 8) {
+            throw Error(`nonce must be of length 8 (found ${nonce.length})`);
+        }
+        const paddedNonce = Buffer.concat([nonce, Buffer.alloc(16 - nonce.length, 0)]);
+        const cipher = crypto.createCipheriv('aes-256-ctr', this.key, paddedNonce);
+        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        return new Uint8Array(ciphertext);
+    }
+    /**
+     * 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, nonce) {
+        if (nonce.length !== 8) {
+            throw Error(`nonce must be of length 8 (found ${nonce.length})`);
+        }
+        const paddedNonce = Buffer.concat([nonce, Buffer.alloc(16 - nonce.length, 0)]);
+        const cipher = crypto.createDecipheriv('aes-256-ctr', this.key, paddedNonce);
+        const decrypted = Buffer.concat([cipher.update(ciphertext), cipher.final()]);
+        return new Uint8Array(decrypted);
+    }
+}
+
 var address = "BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6";
 var metadata = {
 	name: "arcium",
-	version: "0.1.46",
+	version: "0.1.47",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -11541,32 +11951,75 @@ var ARCIUM_IDL = /*#__PURE__*/Object.freeze({
     types: types
 });
 
+/**
+ * The deployed address of the Arcium program, as specified in the IDL.
+ */
 const ARCIUM_ADDR = address;
 
-// Seed for ClockAccount PDA
+/**
+ * Seed for ClockAccount PDA
+ * @constant {string}
+ */
 const CLOCK_ACC_SEED = 'ClockAccount';
-// Seed for StakingPoolAccount PDA
+/**
+ * Seed for StakingPoolAccount PDA
+ * @constant {string}
+ */
 const POOL_ACC_SEED = 'StakingPoolAccount';
-// Seed for ComputationAccount PDA
+/**
+ * Seed for ComputationAccount PDA
+ * @constant {string}
+ */
 const COMPUTATION_ACC_SEED = 'ComputationAccount';
-// Seed for Mempool PDA
+/**
+ * Seed for Mempool PDA
+ * @constant {string}
+ */
 const MEMPOOL_ACC_SEED = 'Mempool';
-// Seed for ExecutingPoolAccount PDA
+/**
+ * Seed for ExecutingPoolAccount PDA
+ * @constant {string}
+ */
 const EXEC_POOL_ACC_SEED = 'Execpool';
-// Seed for ClusterAccount PDA
+/**
+ * Seed for ClusterAccount PDA
+ * @constant {string}
+ */
 const CLUSTER_ACC_SEED = 'Cluster';
-// Seed for ArxNodeAccount PDA
+/**
+ * Seed for ArxNodeAccount PDA
+ * @constant {string}
+ */
 const ARX_NODE_ACC_SEED = 'ArxNode';
-// Seed for MXEAccAccount PDA
+/**
+ * Seed for MXEAccAccount PDA
+ * @constant {string}
+ */
 const MXE_ACC_ACC_SEED = 'PersistentMXEAccount';
-// Seed for CompDefAccount PDA
+/**
+ * Seed for CompDefAccount PDA
+ * @constant {string}
+ */
 const COMP_DEF_ACC_SEED = 'ComputationDefinitionAccount';
+/**
+ * Maximum number of bytes that can be reallocated per instruction.
+ * @constant {number}
+ */
 const MAX_REALLOC_PER_IX = 10240;
-// Max number of bytes we can upload in a single transaction with the upload instruction
+/**
+ * Maximum number of bytes that can be uploaded in a single transaction with the upload instruction.
+ * @constant {number}
+ */
 const MAX_UPLOAD_PER_TX_BYTES = 814;
-// Max size of an account in bytes
-const MAX_ACCOUNT_SIZE = 10485760; // 10MB = 10 * 1024 * 1024
-// Max number of arcium embiggen instructions we can have in a single transaction (due to CUs)
+/**
+ * Maximum size of an account in bytes (10MB = 10 * 1024 * 1024).
+ * @constant {number}
+ */
+const MAX_ACCOUNT_SIZE = 10485760;
+/**
+ * Maximum number of arcium embiggen instructions allowed in a single transaction (due to compute unit limits).
+ * @constant {number}
+ */
 const MAX_EMBIGGEN_IX_PER_TX = 18;
 
 const TINY_MEMPOOL_ACC_NAME = 'tinyMempool';
@@ -11669,9 +12122,19 @@ const EXECPOOL_DISCRIMINATOR_MAP = {
     [MEDIUM_EXECPOOL_DISCRIMINATOR.toString()]: MEDIUM_EXECPOOL_ACC_NAME,
     [LARGE_EXECPOOL_DISCRIMINATOR.toString()]: LARGE_EXECPOOL_ACC_NAME,
 };
+/**
+ * Returns the public key of the deployed Arcium program on Solana.
+ * @returns The Arcium program's public key.
+ */
 function getArciumProgAddress() {
     return new anchor__namespace.web3.PublicKey(ARCIUM_ADDR);
 }
+/**
+ * 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.
+ */
 async function getClusterDAInfo(provider, clusterAddr) {
     const program = getArciumProgram(provider);
     const clusterAcc = await program.account.cluster.fetch(clusterAddr);
@@ -11682,6 +12145,13 @@ async function getClusterDAInfo(provider, clusterAddr) {
         return { solanaPubkey: nodeAccPubkey, x25519Pubkey: Uint8Array.from(nodeAcc.encryptionPubkey) };
     }));
 }
+/**
+ * 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.
+ */
 async function getMempoolAccData(provider, mempoolAccPubkey) {
     const accData = await provider.connection.getAccountInfo(mempoolAccPubkey);
     if (accData === null) {
@@ -11695,6 +12165,13 @@ async function getMempoolAccData(provider, mempoolAccPubkey) {
     const program = getArciumProgram(provider);
     return program.coder.accounts.decode(accName, accData.data);
 }
+/**
+ * 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.
+ */
 async function getExecutingPoolAccData(provider, executingPoolAccPubkey) {
     const accData = await provider.connection.getAccountInfo(executingPoolAccPubkey);
     if (accData === null) {
@@ -11708,6 +12185,16 @@ async function getExecutingPoolAccData(provider, executingPoolAccPubkey) {
     const program = getArciumProgram(provider);
     return program.coder.accounts.decode(accName, accData.data);
 }
+/**
+ * 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.
+ */
 async function uploadCircuit(provider, circuitName, mxeProgramID, rawCircuit, logging = true, chunkSize = 500) {
     const numAccs = Math.ceil(rawCircuit.length / (MAX_ACCOUNT_SIZE - 9));
     const compDefAccInfo = getCompDefAccInfo(circuitName, mxeProgramID);
@@ -11722,6 +12209,13 @@ async function uploadCircuit(provider, circuitName, mxeProgramID, rawCircuit, lo
     sigs.push(await signAndSendWithBlockhash(provider, finalizeCompDefTx, await provider.connection.getLatestBlockhash()));
     return sigs;
 }
+/**
+ * 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.
+ */
 async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramID) {
     const program = getArciumProgram(provider);
     const compDefOffsetBuffer = Buffer.alloc(4);
@@ -11823,35 +12317,78 @@ async function signAndSendWithBlockhash(provider, tx, block) {
     tx.lastValidBlockHeight = block.lastValidBlockHeight;
     return provider.sendAndConfirm(tx, [], { commitment: 'confirmed' });
 }
+/**
+ * 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.
+ */
 function getArciumAccountBaseSeed(accName) {
     return Buffer.from(accName, 'utf-8');
 }
+/**
+ * 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.
+ */
 function getCompDefAccOffset(circuitName) {
     const hash = new Uint8Array(sha256([Buffer.from(circuitName, 'utf-8')]));
     return hash.slice(0, 4);
 }
+/**
+ * Returns an Anchor program instance for the Arcium program.
+ * @param provider - The Anchor provider to use.
+ * @returns The Anchor program instance for Arcium.
+ */
 function getArciumProgram(provider) {
     return new anchor.Program(ARCIUM_IDL, provider);
 }
+/**
+ * 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.
+ */
 function getArciumProgramReadonly(provider) {
     return new anchor.Program(ARCIUM_IDL, provider);
 }
+/**
+ * Returns the PDA (program-derived address) for an ArxNode account given the program ID and node offset.
+ * @param arciumProgramID - The public key of the Arcium program.
+ * @param nodeOffset - The offset of the node.
+ * @returns The PDA for the ArxNode account.
+ */
 function getArxAccPDA(arciumProgramID, nodeOffset) {
     const nodeOffsetBuffer = Buffer.alloc(4);
     nodeOffsetBuffer.writeUInt32LE(nodeOffset, 0);
     return anchor__namespace.web3.PublicKey.findProgramAddressSync([Buffer.from('ArxNode', 'utf-8'), nodeOffsetBuffer], arciumProgramID)[0];
 }
+/**
+ * Returns the public key and offset for a computation definition account, given the circuit name and MXE program ID.
+ * @param circuitName - The name of the circuit.
+ * @param mxeProgramID - The public key of the MXE program.
+ * @returns An object containing the public key and offset for the computation definition account.
+ */
 function getCompDefAccInfo(circuitName, mxeProgramID) {
     const offset = getCompDefAccOffset(circuitName);
     const pda = getCompDefAccPDA(getArciumProgAddress(), mxeProgramID, offset);
     return { pubkey: pda, offset: Buffer.from(offset).readUInt32LE(0) };
 }
+/**
+ * Returns the PDA for a computation definition account, given the program ID, MXE program ID, and offset.
+ * @param arciumProgramID - The public key of the Arcium program.
+ * @param mxeProgramID - The public key of the MXE program.
+ * @param offset - The offset as a Uint8Array.
+ * @returns The PDA for the computation definition account.
+ */
 function getCompDefAccPDA(arciumProgramID, mxeProgramID, offset) {
     return anchor__namespace.web3.PublicKey.findProgramAddressSync([Buffer.from('ComputationDefinitionAccount', 'utf-8'), mxeProgramID.toBuffer(), offset], arciumProgramID)[0];
 }
 
-// Reads local Arcium env information.
-// Only available in Node.js and when testing locally.
+/**
+ * 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.
+ */
 function getArciumEnv() {
     if (isBrowser()) {
         throw new Error('Arcium local env is not available in browser.');
@@ -12109,12 +12646,29 @@ class LogScanner {
     }
 }
 
+/**
+ * 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.
+ */
 async function awaitComputationFinalization(provider, computationOffset, mxeProgramId, commitment = 'confirmed') {
     const arciumProgram = getArciumProgram(provider);
     const eventListener = new EventManager(arciumProgram.programId, provider, arciumProgram.coder);
     const finalizeComp = await awaitEvent(eventListener, 'finalizeComputationEvent', (e) => mxeProgramId.equals(e.mxeProgramId) && e.computationOffset.eq(computationOffset), commitment);
     return finalizeComp.sig;
 }
+/**
+ * Waits for a specific event to occur, matching a custom check, and returns the event and its signature.
+ * @param eventListener - The EventManager instance to use for listening.
+ * @param eventName - The name of the event to listen for.
+ * @param eventCheck - A predicate function to check if the event matches the desired criteria.
+ * @param commitment - (Optional) The desired finality/commitment level (default: 'confirmed').
+ * @returns An object containing the event and its transaction signature.
+ */
 async function awaitEvent(eventListener, eventName, eventCheck, commitment = 'confirmed') {
     const foundEvent = await new Promise((res) => {
         const listenerId = eventListener.addEventListener(eventName, (event, _slot, signature) => {
@@ -12126,51 +12680,105 @@ async function awaitEvent(eventListener, eventName, eventCheck, commitment = 'co
     return { event: foundEvent[0], sig: foundEvent[1] };
 }
 
+/**
+ * Returns the public key of the deployed Arcium program on Solana.
+ * @returns The Arcium program's public key.
+ */
 function getArciumProgramId() {
     return new web3_js.PublicKey('BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6');
 }
-function getComputationAcc(mxeProgramId, offset) {
+/**
+ * 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.
+ */
+function getComputationAccAddress(mxeProgramId, offset) {
     const seeds = [Buffer.from(COMPUTATION_ACC_SEED), mxeProgramId.toBuffer(), offset.toArrayLike(Buffer, 'le', 8)];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getMempoolAcc(mxeProgramId) {
+/**
+ * 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.
+ */
+function getMempoolAccAddress(mxeProgramId) {
     const seeds = [Buffer.from(MEMPOOL_ACC_SEED), mxeProgramId.toBuffer()];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getExecutingPoolAcc(mxeProgramId) {
+/**
+ * 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.
+ */
+function getExecutingPoolAccAddress(mxeProgramId) {
     const seeds = [Buffer.from(EXEC_POOL_ACC_SEED), mxeProgramId.toBuffer()];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getStakingPoolAcc() {
+/**
+ * Derives the staking pool account address.
+ * @returns The derived staking pool account public key.
+ */
+function getStakingPoolAccAddress() {
     const seeds = [Buffer.from(POOL_ACC_SEED)];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getClockAcc() {
+/**
+ * Derives the clock account address.
+ * @returns The derived clock account public key.
+ */
+function getClockAccAddress() {
     const seeds = [Buffer.from(CLOCK_ACC_SEED)];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getClusterAcc(offset) {
+/**
+ * Derives the cluster account address for a given offset.
+ * @param offset - The cluster offset as a number.
+ * @returns The derived cluster account public key.
+ */
+function getClusterAccAddress(offset) {
     const offsetBuffer = Buffer.alloc(4);
     offsetBuffer.writeUInt32LE(offset, 0);
     const seeds = [Buffer.from(CLUSTER_ACC_SEED), offsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getArxNodeAcc(offset) {
+/**
+ * Derives the ArxNode account address for a given offset.
+ * @param offset - The ArxNode offset as a number.
+ * @returns The derived ArxNode account public key.
+ */
+function getArxNodeAccAddress(offset) {
     const offsetBuffer = Buffer.alloc(4);
     offsetBuffer.writeUInt32LE(offset, 0);
     const seeds = [Buffer.from(ARX_NODE_ACC_SEED), offsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getMXEAccAcc(mxeProgramId) {
+/**
+ * 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.
+ */
+function getMXEAccAddress(mxeProgramId) {
     const seeds = [Buffer.from(MXE_ACC_ACC_SEED), mxeProgramId.toBuffer()];
     return generateArciumPDAFrom(seeds)[0];
 }
-function getCompDefAcc(mxeProgramId, offset) {
+/**
+ * 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.
+ */
+function getCompDefAccAddress(mxeProgramId, offset) {
     const offsetBuffer = Buffer.alloc(4);
     offsetBuffer.writeUInt32LE(offset, 0);
     const seeds = [Buffer.from(COMP_DEF_ACC_SEED), mxeProgramId.toBuffer(), offsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
+/**
+ * Generates a program-derived address (PDA) from the provided seeds and the Arcium program ID.
+ * @param seeds - An array of Buffer seeds used for PDA derivation.
+ * @returns A tuple containing the derived public key and the bump seed.
+ */
 function generateArciumPDAFrom(seeds) {
     const programId = getArciumProgramId();
     return web3_js.PublicKey.findProgramAddressSync(seeds, programId);
@@ -12182,6 +12790,9 @@ Object.defineProperty(exports, "x25519", {
 });
 exports.ARCIUM_ADDR = ARCIUM_ADDR;
 exports.ARCIUM_IDL = ARCIUM_IDL;
+exports.Aes128Cipher = Aes128Cipher;
+exports.Aes192Cipher = Aes192Cipher;
+exports.Aes256Cipher = Aes256Cipher;
 exports.CURVE25519_BASE_FIELD = CURVE25519_BASE_FIELD;
 exports.CURVE25519_SCALAR_FIELD_MODULUS = CURVE25519_SCALAR_FIELD_MODULUS;
 exports.DOUBLE_PRECISION_MANTISSA = DOUBLE_PRECISION_MANTISSA;
@@ -12189,6 +12800,7 @@ exports.Matrix = Matrix;
 exports.RescueCipher = RescueCipher;
 exports.RescueDesc = RescueDesc;
 exports.RescuePrimeHash = RescuePrimeHash;
+exports.arcisEd25519 = arcisEd25519;
 exports.awaitComputationFinalization = awaitComputationFinalization;
 exports.buildFinalizeCompDefTx = buildFinalizeCompDefTx;
 exports.deserializeLE = deserializeLE;
@@ -12202,20 +12814,20 @@ exports.getArciumProgAddress = getArciumProgAddress;
 exports.getArciumProgram = getArciumProgram;
 exports.getArciumProgramId = getArciumProgramId;
 exports.getArciumProgramReadonly = getArciumProgramReadonly;
-exports.getArxNodeAcc = getArxNodeAcc;
-exports.getClockAcc = getClockAcc;
-exports.getClusterAcc = getClusterAcc;
+exports.getArxNodeAccAddress = getArxNodeAccAddress;
+exports.getClockAccAddress = getClockAccAddress;
+exports.getClusterAccAddress = getClusterAccAddress;
 exports.getClusterDAInfo = getClusterDAInfo;
-exports.getCompDefAcc = getCompDefAcc;
+exports.getCompDefAccAddress = getCompDefAccAddress;
 exports.getCompDefAccOffset = getCompDefAccOffset;
-exports.getComputationAcc = getComputationAcc;
+exports.getComputationAccAddress = getComputationAccAddress;
 exports.getEncryptionKey = getEncryptionKey;
-exports.getExecutingPoolAcc = getExecutingPoolAcc;
+exports.getExecutingPoolAccAddress = getExecutingPoolAccAddress;
 exports.getExecutingPoolAccData = getExecutingPoolAccData;
-exports.getMXEAccAcc = getMXEAccAcc;
-exports.getMempoolAcc = getMempoolAcc;
+exports.getMXEAccAddress = getMXEAccAddress;
+exports.getMempoolAccAddress = getMempoolAccAddress;
 exports.getMempoolAccData = getMempoolAccData;
-exports.getStakingPoolAcc = getStakingPoolAcc;
+exports.getStakingPoolAccAddress = getStakingPoolAccAddress;
 exports.positiveModulo = positiveModulo;
 exports.randMatrix = randMatrix;
 exports.secretShareInputs = secretShareInputs;