@arcium-hq/client 0.4.0 → 0.5.0

package/build/index.cjs

@@ -100,6 +100,92 @@ function sha256(byteArrays) {
     return hash.digest();
 }
 
+/**
+ * Seed for ClockAccount PDA
+ * @constant {string}
+ */
+const CLOCK_ACC_SEED = 'ClockAccount';
+/**
+ * Seed for FeePool PDA
+ * @constant {string}
+ */
+const POOL_ACC_SEED = 'FeePool';
+/**
+ * Seed for ComputationAccount PDA
+ * @constant {string}
+ */
+const COMPUTATION_ACC_SEED = 'ComputationAccount';
+/**
+ * Seed for Mempool PDA
+ * @constant {string}
+ */
+const MEMPOOL_ACC_SEED = 'Mempool';
+/**
+ * Seed for ExecutingPoolAccount PDA
+ * @constant {string}
+ */
+const EXEC_POOL_ACC_SEED = 'Execpool';
+/**
+ * Seed for ClusterAccount PDA
+ * @constant {string}
+ */
+const CLUSTER_ACC_SEED = 'Cluster';
+/**
+ * Seed for ArxNodeAccount PDA
+ * @constant {string}
+ */
+const ARX_NODE_ACC_SEED = 'ArxNode';
+/**
+ * Seed for MXE Account PDA
+ * @constant {string}
+ */
+const MXE_ACCOUNT_SEED = 'MXEAccount';
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Size of account discriminator in bytes.
+ * @constant {number}
+ */
+const DISCRIMINATOR_SIZE = 8;
+/**
+ * Size of offset buffer in bytes (u32).
+ * @constant {number}
+ */
+const OFFSET_BUFFER_SIZE = 4;
+/**
+ * Size of computation definition offset slice in bytes.
+ * @constant {number}
+ */
+const COMP_DEF_OFFSET_SIZE = 4;
+/**
+ * Size of a uint128 in bytes.
+ * @constant {number}
+ */
+const UINT128_BYTE_SIZE = 16;
+
 /**
  * Converts a bigint to an array of bits (least significant to most significant, in 2's complement representation).
  * @param x - The bigint to convert.
@@ -217,17 +303,32 @@ function verifyBinSize(x, binSize) {
     return bin === '0' || bin === '-1';
 }
 
+/**
+ * Checks if code is running in a browser environment.
+ * @returns true if window object exists, false otherwise
+ */
 function isBrowser() {
     return (
     // eslint-disable-next-line no-prototype-builtins
     typeof window !== 'undefined' && !window.process?.hasOwnProperty('type'));
 }
+/**
+ * Conditionally logs a message if logging is enabled.
+ * @param log - Whether to output the log
+ * @param args - Arguments to pass to console.log
+ */
 function optionalLog(log, ...args) {
     if (log) {
         // eslint-disable-next-line no-console
         console.log(...args);
     }
 }
+/**
+ * Calculates the minimum number of bits needed to represent a value.
+ * Formula: floor(log2(max)) + 1 for unsigned, +1 for signed, +1 for diff of two negatives.
+ * @param max - The bigint value to measure
+ * @returns Number of bits required
+ */
 function getBinSize(max) {
     // floor(log2(max)) + 1 to represent unsigned elements, a +1 for signed elements
     // and another +1 to account for the diff of two negative elements
@@ -243,12 +344,12 @@ function getBinSize(max) {
  * @throws Error if the input length is not a multiple of 16.
  */
 function compressUint128(bytes) {
-    if (bytes.length % 16 !== 0) {
-        throw Error(`bytes.length must be a multiple of 16 (found ${bytes.length})`);
+    if (bytes.length % UINT128_BYTE_SIZE !== 0) {
+        throw Error(`bytes.length must be a multiple of ${UINT128_BYTE_SIZE} (found ${bytes.length})`);
     }
     const res = [];
-    for (let n = 0; n < bytes.length / 16; ++n) {
-        res.push(deserializeLE(bytes.slice(n * 16, (n + 1) * 16)));
+    for (let n = 0; n < bytes.length / UINT128_BYTE_SIZE; ++n) {
+        res.push(deserializeLE(bytes.slice(n * UINT128_BYTE_SIZE, (n + 1) * UINT128_BYTE_SIZE)));
     }
     return res;
 }
@@ -269,10 +370,20 @@ function decompressUint128(compressed) {
     });
     const res = [];
     for (let n = 0; n < compressed.length; ++n) {
-        res.push(...serializeLE(compressed[n], 16));
+        res.push(...serializeLE(compressed[n], UINT128_BYTE_SIZE));
     }
     return new Uint8Array(res);
 }
+/**
+ * Checks if a computation reference is null (all zeros).
+ * @param ref - The computation reference to check
+ * @returns true if the reference is null, false otherwise
+ */
+function isNullRef(ref) {
+    const bigZero = new anchor__namespace.BN(0);
+    return (ref.computationOffset === bigZero
+        && ref.priorityFee === bigZero);
+}
 
 /**
  * Matrix class over FpField. Data is row-major.
@@ -460,8 +571,10 @@ function randMatrix(field, nrows, ncols) {
  * 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;
+// Security level for the block cipher.
+const SECURITY_LEVEL_BLOCK_CIPHER = 128;
+// Security level for the hash function.
+const SECURITY_LEVEL_HASH_FUNCTION = 256;
 // 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.
@@ -584,7 +697,7 @@ class RescueDesc {
                 return roundConstants;
             }
             case 'hash': {
-                hasher.update(`Rescue-XLIX(${this.field.ORDER},${m},${this.mode.capacity},${SECURITY_LEVEL})`);
+                hasher.update(`Rescue-XLIX(${this.field.ORDER},${m},${this.mode.capacity},${SECURITY_LEVEL_HASH_FUNCTION})`);
                 // this.permute requires an odd number of round keys
                 // prepending a 0 matrix makes it equivalent to Algorithm 3 from https://eprint.iacr.org/2020/1143.pdf
                 const zeros = [];
@@ -628,6 +741,13 @@ class RescueDesc {
         return rescuePermutationInverse(this.mode, this.alpha, this.alphaInverse, this.mdsMatInverse, this.roundKeys, state)[2 * this.nRounds];
     }
 }
+/**
+ * Finds the smallest prime alpha that does not divide p-1, and computes its inverse modulo p-1.
+ * The alpha parameter is used in the Rescue permutation for exponentiation operations.
+ * @param p - The field modulus (prime number)
+ * @returns A tuple [alpha, alphaInverse] where alpha is the prime and alphaInverse is its modular inverse
+ * @throws Error if no suitable prime alpha is found
+ */
 function getAlphaAndInverse(p) {
     const pMinusOne = p - 1n;
     let alpha = 0n;
@@ -643,6 +763,16 @@ function getAlphaAndInverse(p) {
     const alphaInverse = modular.invert(alpha, pMinusOne);
     return [alpha, alphaInverse];
 }
+/**
+ * Calculates the number of rounds required for the Rescue permutation based on security analysis.
+ * The number of rounds is determined by analyzing resistance to differential and algebraic attacks.
+ * See: https://tosc.iacr.org/index.php/ToSC/article/view/8695/8287 for the security analysis.
+ * @param p - The field modulus
+ * @param mode - The Rescue mode (cipher or hash)
+ * @param alpha - The prime alpha parameter
+ * @param m - The state size (block size for cipher, total size for hash)
+ * @returns The number of rounds (will be doubled for the full permutation)
+ */
 function getNRounds(p, mode, alpha, m) {
     function dcon(n) {
         return Math.floor(0.5 * (Number(alpha) - 1) * m * (n - 1) + 2.0);
@@ -661,20 +791,20 @@ function getNRounds(p, mode, alpha, m) {
     }
     switch (mode.kind) {
         case 'cipher': {
-            const l0 = Math.ceil((2 * SECURITY_LEVEL) / ((m + 1) * (Math.log2(Number(p)) - Math.log2(Number(alpha) - 1))));
+            const l0 = Math.ceil((2 * SECURITY_LEVEL_BLOCK_CIPHER) / ((m + 1) * (Math.log2(Number(p)) - Math.log2(Number(alpha) - 1))));
             let l1 = 0;
             if (alpha === 3n) {
-                l1 = Math.ceil((SECURITY_LEVEL + 2) / (4 * m));
+                l1 = Math.ceil((SECURITY_LEVEL_BLOCK_CIPHER + 2) / (4 * m));
             }
             else {
-                l1 = Math.ceil((SECURITY_LEVEL + 3) / (5.5 * m));
+                l1 = Math.ceil((SECURITY_LEVEL_BLOCK_CIPHER + 3) / (5.5 * m));
             }
             return 2 * Math.max(l0, l1, 5);
         }
         case 'hash': {
             // get number of rounds for Groebner basis attack
             const rate = m - mode.capacity;
-            const target = 1n << BigInt(SECURITY_LEVEL);
+            const target = 1n << BigInt(SECURITY_LEVEL_HASH_FUNCTION);
             let l1 = 1;
             let tmp = binomial(v(l1, rate) + dcon(l1), v(l1, rate));
             while (tmp * tmp <= target && l1 <= 23) {
@@ -687,6 +817,14 @@ function getNRounds(p, mode, alpha, m) {
         default: return 0;
     }
 }
+/**
+ * Builds a Cauchy matrix for use as an MDS (Maximum Distance Separable) matrix.
+ * A Cauchy matrix is guaranteed to be invertible and provides optimal diffusion properties.
+ * The matrix is constructed using the formula: M[i][j] = 1/(i + j) for i, j in [1, size].
+ * @param field - The finite field over which to construct the matrix
+ * @param size - The size of the square matrix
+ * @returns A Cauchy matrix of the specified size
+ */
 function buildCauchy(field, size) {
     const data = [];
     for (let i = 1n; i <= size; ++i) {
@@ -698,6 +836,13 @@ function buildCauchy(field, size) {
     }
     return new Matrix(field, data);
 }
+/**
+ * Builds the inverse of a Cauchy matrix for use as the inverse MDS matrix.
+ * The inverse is computed using a closed-form formula for Cauchy matrix inversion.
+ * @param field - The finite field over which to construct the matrix
+ * @param size - The size of the square matrix
+ * @returns The inverse of the Cauchy matrix
+ */
 function buildInverseCauchy(field, size) {
     function product(arr) {
         return arr.reduce((acc, curr) => field.mul(acc, field.create(curr)), field.ONE);
@@ -751,6 +896,19 @@ function exponentForOdd(mode, alpha, alphaInverse) {
         default: return 0n;
     }
 }
+/**
+ * Core Rescue permutation function implementing the cryptographic primitive.
+ * Applies alternating rounds of exponentiation and MDS matrix multiplication with round keys.
+ * The permutation alternates between using alpha and alphaInverse as exponents based on round parity.
+ * This is the fundamental building block for both Rescue cipher and Rescue-Prime hash.
+ * @param mode - The Rescue mode (cipher or hash) determining exponent selection
+ * @param alpha - The prime exponent for even rounds
+ * @param alphaInverse - The inverse exponent for odd rounds
+ * @param mdsMat - The Maximum Distance Separable matrix for diffusion
+ * @param subkeys - Array of round key matrices
+ * @param state - The initial state matrix to permute
+ * @returns Array of all intermediate states during the permutation
+ */
 function rescuePermutation(mode, alpha, alphaInverse, mdsMat, subkeys, state) {
     const exponentEven = exponentForEven(mode, alpha, alphaInverse);
     const exponentOdd = exponentForOdd(mode, alpha, alphaInverse);
@@ -796,41 +954,49 @@ function toVec(data) {
 }
 
 /**
- * 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.
+ * The Rescue-Prime hash function, as described in https://eprint.iacr.org/2020/1143.pdf, offering 256 bits
+ * of security against collision, preimage and second-preimage attacks for any field of size at least 102 bits.
+ * We use the sponge construction with fixed rate = 7 and capacity = 5 (i.e., m = 12), and truncate the
+ * output to 5 field elements.
  */
 class RescuePrimeHash {
     desc;
     rate;
+    digestLength;
     /**
-     * Constructs a RescuePrimeHash instance with m = 6 and capacity = 1.
+     * Constructs a RescuePrimeHash instance with rate = 7 and capacity = 5.
      */
     constructor() {
-        this.desc = new RescueDesc(CURVE25519_BASE_FIELD, { kind: 'hash', m: 6, capacity: 1 });
-        this.rate = 6 - 1;
+        this.desc = new RescueDesc(CURVE25519_BASE_FIELD, { kind: 'hash', m: 12, capacity: 5 });
+        this.rate = 7;
+        this.digestLength = 5;
     }
     // 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.
+    // The hash is truncated to digestLength elements.
+    // According to Section 2.2, this offers min(log2(CURVE25519_BASE_FIELD.ORDER) / 2 * min(digestLength, capacity), s)
+    // bits of security against collision, preimage and second-preimage attacks.
+    // The security level is thus of the order of 256 bits for any field of size at least 102 bits.
+    // The rate and capacity are chosen to achieve minimal number of rounds 8.
     /**
      * 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).
+     * @returns The hash output as an array of bigints (length = digestLength).
      */
     digest(message) {
-        message.push(1n);
-        while (message.length % this.rate !== 0) {
-            message.push(0n);
+        // Create a copy and pad message to avoid mutating input parameter
+        const paddedMessage = [...message, 1n];
+        while (paddedMessage.length % this.rate !== 0) {
+            paddedMessage.push(0n);
         }
         const zeros = [];
         for (let i = 0; i < this.desc.m; ++i) {
             zeros.push([0n]);
         }
         let state = new Matrix(this.desc.field, zeros);
-        for (let r = 0; r < message.length / this.rate; ++r) {
+        for (let r = 0; r < paddedMessage.length / this.rate; ++r) {
             const data = [];
             for (let i = 0; i < this.rate; ++i) {
-                data[i] = [message[r * this.rate + i]];
+                data[i] = [paddedMessage[r * this.rate + i]];
             }
             for (let i = this.rate; i < this.desc.m; ++i) {
                 data[i] = [0n];
@@ -839,7 +1005,7 @@ class RescuePrimeHash {
             state = this.desc.permute(state.add(s, true));
         }
         const res = [];
-        for (let i = 0; i < this.rate; ++i) {
+        for (let i = 0; i < this.digestLength; ++i) {
             res.push(state.data[i][0]);
         }
         return res;
@@ -847,101 +1013,10 @@ class RescuePrimeHash {
 }
 
 /**
- * HMACRescuePrime provides a message authentication code (MAC) using the Rescue-Prime hash function.
- * We refer to https://datatracker.ietf.org/doc/html/rfc2104 for more details.
- */
-class HMACRescuePrime {
-    hasher;
-    /**
-     * Constructs a new HMACRescuePrime instance.
-     */
-    constructor() {
-        this.hasher = new RescuePrimeHash();
-    }
-    /**
-     * Computes the HMAC digest of a message with a given key using Rescue-Prime.
-     * @param key - The key as an array of bigints.
-     * @param message - The message as an array of bigints.
-     * @returns The HMAC digest as an array of bigints.
-     * @throws Error if the key is longer than the hash function's rate.
-     */
-    digest(key, message) {
-        // 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.
-        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})`);
-        }
-        const ipad = deserializeLE(new Uint8Array(32).fill(0x36));
-        const opad = deserializeLE(new Uint8Array(32).fill(0x5c));
-        // the key is first extended to length B
-        for (let i = 0; i < this.hasher.rate - key.length; ++i) {
-            key.push(0n);
-        }
-        // inner padding
-        const keyPlusIpad = key.map((k) => k + ipad);
-        keyPlusIpad.push(...message);
-        const innerDigest = this.hasher.digest(keyPlusIpad);
-        // outer padding
-        const keyPlusOpad = key.map((k) => k + opad);
-        keyPlusOpad.push(...innerDigest);
-        return this.hasher.digest(keyPlusOpad);
-    }
-}
-
-/**
- * HKDF (HMAC-based Extract-and-Expand Key Derivation Function) using the Rescue-Prime hash function.
- * Follows RFC 5869. Only supports L = HashLen.
+ * Block size m for Rescue cipher operations.
+ * Rescue operates on 5-element blocks of field elements.
  */
-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 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);
-    }
-}
-
+const RESCUE_CIPHER_BLOCK_SIZE = 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
@@ -950,12 +1025,21 @@ class RescueCipher {
     desc;
     /**
      * Constructs a RescueCipher instance using a shared secret.
-     * The key is derived using HKDF-RescuePrime and used to initialize the RescueDesc.
+     * The key is derived using RescuePrimeHash 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([], [deserializeLE(sharedSecret)], []);
+        const hasher = new RescuePrimeHash();
+        // We follow [Section 4, Option 1.](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Cr2.pdf).
+        // For our choice of hash function, we have:
+        // - H_outputBits = hasher.digestLength = RESCUE_CIPHER_BLOCK_SIZE
+        // - max_H_inputBits = arbitrarily long, as the Rescue-Prime hash function is built upon the
+        //   sponge construction
+        // - L = RESCUE_CIPHER_BLOCK_SIZE.
+        // Build the vector `counter || Z || FixedInfo` (we only have i = 1, since reps = 1).
+        // For the FixedInfo we simply take L.
+        const counter = [1n, deserializeLE(sharedSecret), BigInt(RESCUE_CIPHER_BLOCK_SIZE)];
+        const rescueKey = hasher.digest(counter);
         this.desc = new RescueDesc(CURVE25519_BASE_FIELD, { kind: 'cipher', key: rescueKey });
     }
     /**
@@ -971,8 +1055,8 @@ class RescueCipher {
         }
         const binSize = getBinSize(this.desc.field.ORDER - 1n);
         function encryptBatch(desc, ptxt, cntr) {
-            if (cntr.length !== 5) {
-                throw Error(`counter must be of length 5 (found ${cntr.length})`);
+            if (cntr.length !== RESCUE_CIPHER_BLOCK_SIZE) {
+                throw Error(`counter must be of length ${RESCUE_CIPHER_BLOCK_SIZE} (found ${cntr.length})`);
             }
             const encryptedCounter = desc.permute(new Matrix(desc.field, toVec(cntr)));
             const ciphertext = [];
@@ -985,12 +1069,12 @@ class RescueCipher {
             }
             return ciphertext;
         }
-        const nBlocks = Math.ceil(plaintext.length / 5);
+        const nBlocks = Math.ceil(plaintext.length / RESCUE_CIPHER_BLOCK_SIZE);
         const counter = getCounter(deserializeLE(nonce), nBlocks);
         const ciphertext = [];
         for (let i = 0; i < nBlocks; ++i) {
-            const cnt = 5 * i;
-            const newCiphertext = encryptBatch(this.desc, plaintext.slice(cnt, Math.min(cnt + 5, plaintext.length)), counter.slice(cnt, cnt + 5));
+            const cnt = RESCUE_CIPHER_BLOCK_SIZE * i;
+            const newCiphertext = encryptBatch(this.desc, plaintext.slice(cnt, Math.min(cnt + RESCUE_CIPHER_BLOCK_SIZE, plaintext.length)), counter.slice(cnt, cnt + RESCUE_CIPHER_BLOCK_SIZE));
             for (let j = 0; j < newCiphertext.length; ++j) {
                 ciphertext.push(newCiphertext[j]);
             }
@@ -1019,8 +1103,8 @@ class RescueCipher {
         }
         const binSize = getBinSize(this.desc.field.ORDER - 1n);
         function decryptBatch(desc, ctxt, cntr) {
-            if (cntr.length !== 5) {
-                throw Error(`counter must be of length 5 (found ${cntr.length})`);
+            if (cntr.length !== RESCUE_CIPHER_BLOCK_SIZE) {
+                throw Error(`counter must be of length ${RESCUE_CIPHER_BLOCK_SIZE} (found ${cntr.length})`);
             }
             const encryptedCounter = desc.permute(new Matrix(desc.field, toVec(cntr)));
             const decrypted = [];
@@ -1030,12 +1114,12 @@ class RescueCipher {
             }
             return decrypted;
         }
-        const nBlocks = Math.ceil(ciphertext.length / 5);
+        const nBlocks = Math.ceil(ciphertext.length / RESCUE_CIPHER_BLOCK_SIZE);
         const counter = getCounter(deserializeLE(nonce), nBlocks);
         const decrypted = [];
         for (let i = 0; i < nBlocks; ++i) {
-            const cnt = 5 * i;
-            const newDecrypted = decryptBatch(this.desc, ciphertext.slice(cnt, Math.min(cnt + 5, ciphertext.length)), counter.slice(cnt, cnt + 5));
+            const cnt = RESCUE_CIPHER_BLOCK_SIZE * i;
+            const newDecrypted = decryptBatch(this.desc, ciphertext.slice(cnt, Math.min(cnt + RESCUE_CIPHER_BLOCK_SIZE, ciphertext.length)), counter.slice(cnt, cnt + RESCUE_CIPHER_BLOCK_SIZE));
             for (let j = 0; j < newDecrypted.length; ++j) {
                 decrypted.push(newDecrypted[j]);
             }
@@ -1068,9 +1152,10 @@ function getCounter(nonce, nBlocks) {
     for (let i = 0n; i < nBlocks; ++i) {
         counter.push(nonce);
         counter.push(i);
-        counter.push(0n);
-        counter.push(0n);
-        counter.push(0n);
+        // Pad to RESCUE_CIPHER_BLOCK_SIZE elements per counter block
+        for (let j = 2; j < RESCUE_CIPHER_BLOCK_SIZE; ++j) {
+            counter.push(0n);
+        }
     }
     return counter;
 }
@@ -1161,19 +1246,43 @@ function uvRatio(u, v) {
 }
 
 /**
- * AES-128 cipher in Counter (CTR) mode, using HKDF-SHA3-256 to derive the key from a shared secret.
+ * Mapping from key bits to key byte length.
+ */
+const KEY_BYTES = { 128: 16, 192: 24, 256: 32 };
+/**
+ * Generic AES cipher in Counter (CTR) mode, using 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 {
+class AesCtrCipher {
     key;
+    keyBits;
     /**
-     * Constructs an AES-128 cipher instance using a shared secret.
-     * The key is derived using HKDF-SHA3-256.
+     * Constructs an AES cipher instance using a shared secret.
+     * The key is derived using SHA3-256.
      * @param sharedSecret - The shared secret to derive the AES key from.
+     * @param keyBits - The AES key size in bits (128, 192, or 256).
      */
-    constructor(sharedSecret) {
-        const aesKey = crypto.hkdfSync('sha3-256', sharedSecret, new Uint8Array(), new Uint8Array(), 16);
-        this.key = new Uint8Array(aesKey);
+    constructor(sharedSecret, keyBits) {
+        this.keyBits = keyBits;
+        const hasher = crypto.createHash('sha3-256');
+        // We follow [Section 4, Option 1.](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Cr2.pdf).
+        // For our choice of hash function, we have:
+        // - H_outputBits = 256
+        // - max_H_inputBits = arbitrarily long, as SHA3 is built upon the sponge
+        //   construction
+        // - L = keyBits (128, 192, or 256).
+        // Build the vector `counter || Z || FixedInfo` (we only have i = 1, since reps = 1).
+        // the counter is a big-endian 4-byte unsigned integer
+        const counter = [0, 0, 0, 1];
+        for (let i = 0; i < sharedSecret.length; ++i) {
+            counter.push(sharedSecret[i]);
+        }
+        // For the FixedInfo we simply take L. We represent L as a big-endian 2-byte
+        // unsigned integer.
+        counter.push(Math.floor(keyBits / 256));
+        counter.push(keyBits % 256);
+        hasher.update(new Uint8Array(counter));
+        this.key = new Uint8Array(hasher.digest()).slice(0, KEY_BYTES[keyBits]);
     }
     /**
      * Encrypts the plaintext array in Counter (CTR) mode.
@@ -1187,7 +1296,7 @@ class Aes128Cipher {
             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 cipher = crypto.createCipheriv(`aes-${this.keyBits}-ctr`, this.key, paddedNonce);
         const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
         return new Uint8Array(ciphertext);
     }
@@ -1203,114 +1312,61 @@ class Aes128Cipher {
             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 cipher = crypto.createDecipheriv(`aes-${this.keyBits}-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.
+ * AES-128 cipher in Counter (CTR) mode, using 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;
+class Aes128Cipher extends AesCtrCipher {
     /**
-     * Constructs an AES-192 cipher instance using a shared secret.
-     * The key is derived using HKDF-SHA3-256.
+     * Constructs an AES-128 cipher instance using a shared secret.
+     * The key is derived using 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);
+        super(sharedSecret, 128);
     }
+}
+
+/**
+ * AES-192 cipher in Counter (CTR) mode, using 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 extends AesCtrCipher {
     /**
-     * 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.
+     * Constructs an AES-192 cipher instance using a shared secret.
+     * The key is derived using SHA3-256.
+     * @param sharedSecret - The shared secret to derive the AES key from.
      */
-    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);
+    constructor(sharedSecret) {
+        super(sharedSecret, 192);
     }
 }
 
 /**
- * AES-256 cipher in Counter (CTR) mode, using HKDF-SHA3-256 to derive the key from a shared secret.
+ * AES-256 cipher in Counter (CTR) mode, using 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;
+class Aes256Cipher extends AesCtrCipher {
     /**
      * Constructs an AES-256 cipher instance using a shared secret.
-     * The key is derived using HKDF-SHA3-256.
+     * The key is derived using 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);
+        super(sharedSecret, 256);
     }
 }
 
 var address = "Bv3Fb9VjzjWGfX18QTUcVycAfeLoQ5zZN6vv2g3cTZxp";
 var metadata = {
 	name: "arcium",
-	version: "0.4.0",
+	version: "0.5.0",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -1663,8 +1719,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						},
 						{
 							kind: "arg",
@@ -1691,8 +1748,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -1716,8 +1774,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -1811,16 +1870,16 @@ var instructions = [
 		]
 	},
 	{
-		name: "claim_failure_append",
+		name: "claim_computation_rent",
 		discriminator: [
-			92,
-			52,
-			184,
-			203,
-			76,
-			221,
-			128,
-			69
+			215,
+			218,
+			1,
+			166,
+			81,
+			218,
+			16,
+			151
 		],
 		accounts: [
 			{
@@ -1829,38 +1888,111 @@ var instructions = [
 				signer: true
 			},
 			{
-				name: "failure_acc",
+				name: "comp",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								70,
-								97,
-								105,
-								108,
-								117,
-								114,
-								101,
 								67,
-								108,
+								111,
+								109,
+								112,
+								117,
+								116,
 								97,
+								116,
 								105,
-								109,
+								111,
+								110,
 								65,
 								99,
 								99,
 								111,
 								117,
 								110,
-								116,
-								72,
-								101,
-								97,
-								100,
-								101,
-								114
+								116
+							]
+						},
+						{
+							kind: "arg",
+							path: "_cluster_offset"
+						},
+						{
+							kind: "arg",
+							path: "_comp_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "comp_offset",
+				type: "u64"
+			},
+			{
+				name: "cluster_offset",
+				type: "u32"
+			}
+		]
+	},
+	{
+		name: "claim_failure_append",
+		discriminator: [
+			92,
+			52,
+			184,
+			203,
+			76,
+			221,
+			128,
+			69
+		],
+		accounts: [
+			{
+				name: "signer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "failure_acc",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								70,
+								97,
+								105,
+								108,
+								117,
+								114,
+								101,
+								67,
+								108,
+								97,
+								105,
+								109,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116,
+								72,
+								101,
+								97,
+								100,
+								101,
+								114
 							]
 						},
 						{
@@ -1984,8 +2116,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -2008,8 +2141,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -2043,8 +2177,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						},
 						{
 							kind: "arg",
@@ -2240,8 +2375,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						},
 						{
 							kind: "arg",
@@ -2432,7 +2568,7 @@ var instructions = [
 				}
 			},
 			{
-				name: "cluster_acc_0",
+				name: "cluster_acc",
 				optional: true,
 				pda: {
 					seeds: [
@@ -2450,15 +2586,40 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "arx_node_acc.cluster_memberships",
-							account: "ArxNode"
+							path: "arx_node_acc"
 						}
 					]
 				}
+			}
+		],
+		args: [
+			{
+				name: "node_offset",
+				type: "u32"
+			}
+		]
+	},
+	{
+		name: "deactivate_cluster",
+		discriminator: [
+			13,
+			42,
+			182,
+			159,
+			184,
+			10,
+			212,
+			178
+		],
+		accounts: [
+			{
+				name: "authority",
+				writable: true,
+				signer: true
 			},
 			{
-				name: "cluster_acc_1",
-				optional: true,
+				name: "cluster_acc",
+				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -2474,16 +2635,14 @@ var instructions = [
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(1).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_id"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_2",
-				optional: true,
+				name: "clock",
 				pda: {
 					seeds: [
 						{
@@ -2491,355 +2650,106 @@ var instructions = [
 							value: [
 								67,
 								108,
+								111,
+								99,
+								107,
+								65,
+								99,
+								99,
+								111,
 								117,
-								115,
-								116,
-								101,
-								114
+								110,
+								116
 							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(2).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_3",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(3).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "cluster_id",
+				type: "u32"
+			},
+			{
+				name: "deactivation_epoch",
+				type: {
+					defined: {
+						name: "Epoch"
+					}
 				}
+			}
+		]
+	},
+	{
+		name: "dummy_instruction",
+		docs: [
+			"Only present so the mempool and execpool accounts are actually included in the idl, since we",
+			"don't explicitly declare them in the accounts section of the other instructions."
+		],
+		discriminator: [
+			57,
+			4,
+			200,
+			151,
+			58,
+			19,
+			120,
+			9
+		],
+		accounts: [
+			{
+				name: "tiny_mempool"
 			},
 			{
-				name: "cluster_acc_4",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(4).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
-				}
-			},
-			{
-				name: "cluster_acc_5",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(5).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
-				}
-			},
-			{
-				name: "cluster_acc_6",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(6).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
-				}
-			},
-			{
-				name: "cluster_acc_7",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(7).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
-				}
-			},
-			{
-				name: "cluster_acc_8",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(8).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
-				}
-			},
-			{
-				name: "cluster_acc_9",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(9).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
-						}
-					]
-				}
-			}
-		],
-		args: [
-			{
-				name: "node_offset",
-				type: "u32"
-			}
-		]
-	},
-	{
-		name: "deactivate_cluster",
-		discriminator: [
-			13,
-			42,
-			182,
-			159,
-			184,
-			10,
-			212,
-			178
-		],
-		accounts: [
-			{
-				name: "authority",
-				writable: true,
-				signer: true
-			},
-			{
-				name: "cluster_acc",
-				writable: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "arg",
-							path: "_id"
-						}
-					]
-				}
-			},
-			{
-				name: "clock",
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								111,
-								99,
-								107,
-								65,
-								99,
-								99,
-								111,
-								117,
-								110,
-								116
-							]
-						}
-					]
-				}
-			},
-			{
-				name: "system_program",
-				address: "11111111111111111111111111111111"
-			}
-		],
-		args: [
-			{
-				name: "cluster_id",
-				type: "u32"
-			},
-			{
-				name: "deactivation_epoch",
-				type: {
-					defined: {
-						name: "Epoch"
-					}
-				}
-			}
-		]
-	},
-	{
-		name: "dummy_instruction",
-		docs: [
-			"Only present so the mempool and execpool accounts are actually included in the idl, since we",
-			"don't explicitly declare them in the accounts section of the other instructions."
-		],
-		discriminator: [
-			57,
-			4,
-			200,
-			151,
-			58,
-			19,
-			120,
-			9
-		],
-		accounts: [
-			{
-				name: "tiny_mempool"
-			},
-			{
-				name: "tiny_execpool"
-			},
-			{
-				name: "small_mempool"
-			},
-			{
-				name: "small_execpool"
-			},
-			{
-				name: "medium_mempool"
-			},
-			{
-				name: "medium_execpool"
-			},
-			{
-				name: "large_mempool"
-			},
-			{
-				name: "large_execpool"
-			}
-		],
-		args: [
-		]
-	},
-	{
-		name: "embiggen_raw_circuit_acc",
-		discriminator: [
-			92,
-			195,
-			192,
-			21,
-			193,
-			242,
-			135,
-			194
-		],
-		accounts: [
-			{
-				name: "signer",
-				writable: true,
-				signer: true
-			},
-			{
-				name: "comp_def_acc",
+				name: "tiny_execpool"
+			},
+			{
+				name: "small_mempool"
+			},
+			{
+				name: "small_execpool"
+			},
+			{
+				name: "medium_mempool"
+			},
+			{
+				name: "medium_execpool"
+			},
+			{
+				name: "large_mempool"
+			},
+			{
+				name: "large_execpool"
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "embiggen_raw_circuit_acc",
+		discriminator: [
+			92,
+			195,
+			192,
+			21,
+			193,
+			242,
+			135,
+			194
+		],
+		accounts: [
+			{
+				name: "signer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "comp_def_acc",
 				pda: {
 					seeds: [
 						{
@@ -3148,21 +3058,22 @@ var instructions = [
 							]
 						},
 						{
-							kind: "account",
-							path: "mxe_program"
+							kind: "arg",
+							path: "_cluster_offset"
 						}
 					]
 				}
 			},
-			{
-				name: "mxe_program"
-			},
 			{
 				name: "system_program",
 				address: "11111111111111111111111111111111"
 			}
 		],
 		args: [
+			{
+				name: "cluster_offset",
+				type: "u32"
+			}
 		]
 	},
 	{
@@ -3357,6 +3268,14 @@ var instructions = [
 				name: "cu_capacity_claim",
 				type: "u64"
 			},
+			{
+				name: "bls_pubkey",
+				type: {
+					defined: {
+						name: "BN254G2BLSPublicKey"
+					}
+				}
+			},
 			{
 				name: "metadata",
 				type: {
@@ -3386,20 +3305,75 @@ var instructions = [
 				signer: true
 			},
 			{
-				name: "cluster_acc",
+				name: "cluster_acc",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "_id"
+						}
+					]
+				}
+			},
+			{
+				name: "authority"
+			},
+			{
+				name: "mempool",
+				docs: [
+					"function"
+				],
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								77,
+								101,
+								109,
+								112,
+								111,
+								111,
+								108
+							]
+						},
+						{
+							kind: "arg",
+							path: "_id"
+						}
+					]
+				}
+			},
+			{
+				name: "execpool",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
+								69,
+								120,
 								101,
-								114
+								99,
+								112,
+								111,
+								111,
+								108
 							]
 						},
 						{
@@ -3409,9 +3383,6 @@ var instructions = [
 					]
 				}
 			},
-			{
-				name: "authority"
-			},
 			{
 				name: "pool_account",
 				pda: {
@@ -3465,6 +3436,14 @@ var instructions = [
 				name: "cluster_id",
 				type: "u32"
 			},
+			{
+				name: "mempool_size",
+				type: {
+					defined: {
+						name: "MempoolSize"
+					}
+				}
+			},
 			{
 				name: "max_size",
 				type: "u32"
@@ -3677,19 +3656,17 @@ var instructions = [
 				}
 			},
 			{
-				name: "mempool",
-				docs: [
-					"function"
-				],
+				name: "executing_pool",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								77,
+								69,
+								120,
 								101,
-								109,
+								99,
 								112,
 								111,
 								111,
@@ -3697,24 +3674,23 @@ var instructions = [
 							]
 						},
 						{
-							kind: "account",
-							path: "mxe_program"
+							kind: "arg",
+							path: "cluster_offset"
 						}
 					]
 				}
 			},
 			{
-				name: "execpool",
+				name: "mempool",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								69,
-								120,
+								77,
 								101,
-								99,
+								109,
 								112,
 								111,
 								111,
@@ -3722,8 +3698,8 @@ var instructions = [
 							]
 						},
 						{
-							kind: "account",
-							path: "mxe_program"
+							kind: "arg",
+							path: "cluster_offset"
 						}
 					]
 				}
@@ -3733,7 +3709,6 @@ var instructions = [
 				docs: [
 					"Cluster to add to the MXE."
 				],
-				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -3838,8 +3813,8 @@ var instructions = [
 							]
 						},
 						{
-							kind: "account",
-							path: "mxe_program"
+							kind: "arg",
+							path: "cluster_offset"
 						},
 						{
 							kind: "const",
@@ -3867,6 +3842,26 @@ var instructions = [
 					"constraint in tests because setting it would require us to deploy a program each time."
 				]
 			},
+			{
+				name: "pool_account",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								70,
+								101,
+								101,
+								80,
+								111,
+								111,
+								108
+							]
+						}
+					]
+				}
+			},
 			{
 				name: "system_program",
 				docs: [
@@ -3879,14 +3874,6 @@ var instructions = [
 			{
 				name: "cluster_offset",
 				type: "u32"
-			},
-			{
-				name: "mempool_size",
-				type: {
-					defined: {
-						name: "MempoolSize"
-					}
-				}
 			}
 		]
 	},
@@ -4526,7 +4513,7 @@ var instructions = [
 						},
 						{
 							kind: "arg",
-							path: "_mxe_program"
+							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
 						},
 						{
 							kind: "arg",
@@ -4581,7 +4568,7 @@ var instructions = [
 						},
 						{
 							kind: "arg",
-							path: "_mxe_program"
+							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
 						}
 					]
 				}
@@ -4605,7 +4592,7 @@ var instructions = [
 						},
 						{
 							kind: "arg",
-							path: "_mxe_program"
+							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
 						}
 					]
 				}
@@ -4749,10 +4736,8 @@ var instructions = [
 			{
 				name: "args",
 				type: {
-					vec: {
-						defined: {
-							name: "Argument"
-						}
+					defined: {
+						name: "ArgumentList"
 					}
 				}
 			},
@@ -4785,92 +4770,295 @@ var instructions = [
 				type: "u64"
 			},
 			{
-				name: "cu_price_micro",
-				type: "u64"
-			}
-		]
-	},
-	{
-		name: "reclaim_failure_rent",
-		discriminator: [
-			159,
-			99,
-			116,
-			180,
-			42,
-			9,
-			202,
-			219
-		],
-		accounts: [
-			{
-				name: "signer",
+				name: "cu_price_micro",
+				type: "u64"
+			}
+		]
+	},
+	{
+		name: "reclaim_failure_rent",
+		discriminator: [
+			159,
+			99,
+			116,
+			180,
+			42,
+			9,
+			202,
+			219
+		],
+		accounts: [
+			{
+				name: "signer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "failure_acc",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								70,
+								97,
+								105,
+								108,
+								117,
+								114,
+								101,
+								67,
+								108,
+								97,
+								105,
+								109,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116,
+								72,
+								101,
+								97,
+								100,
+								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "mxe_program"
+						},
+						{
+							kind: "arg",
+							path: "comp_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "clock",
+				address: "SysvarC1ock11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "comp_offset",
+				type: "u64"
+			},
+			{
+				name: "node_offset",
+				type: "u32"
+			},
+			{
+				name: "mxe_program",
+				type: "pubkey"
+			}
+		]
+	},
+	{
+		name: "requeue_mxe_keygen",
+		docs: [
+			"Re-queues the MXE keygen computation if it has expired from the mempool.",
+			"This allows retrying the keygen if it wasn't processed in time."
+		],
+		discriminator: [
+			90,
+			98,
+			117,
+			181,
+			88,
+			71,
+			135,
+			30
+		],
+		accounts: [
+			{
+				name: "signer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "mxe",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								77,
+								88,
+								69,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						},
+						{
+							kind: "account",
+							path: "mxe_program"
+						}
+					]
+				}
+			},
+			{
+				name: "executing_pool",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								69,
+								120,
+								101,
+								99,
+								112,
+								111,
+								111,
+								108
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "mempool",
 				writable: true,
-				signer: true
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								77,
+								101,
+								109,
+								112,
+								111,
+								111,
+								108
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
 			},
 			{
-				name: "failure_acc",
-				writable: true,
+				name: "cluster",
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								70,
-								97,
-								105,
+								67,
 								108,
 								117,
-								114,
+								115,
+								116,
 								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "mxe_keygen_computation",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
 								67,
-								108,
+								111,
+								109,
+								112,
+								117,
+								116,
 								97,
+								116,
 								105,
-								109,
+								111,
+								110,
 								65,
 								99,
 								99,
 								111,
 								117,
 								110,
-								116,
-								72,
-								101,
-								97,
-								100,
-								101,
-								114
+								116
 							]
 						},
 						{
 							kind: "arg",
-							path: "mxe_program"
+							path: "cluster_offset"
 						},
 						{
-							kind: "arg",
-							path: "comp_offset"
+							kind: "const",
+							value: [
+								1,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0
+							]
 						}
 					]
 				}
 			},
 			{
-				name: "clock",
-				address: "SysvarC1ock11111111111111111111111111111111"
+				name: "pool_account",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								70,
+								101,
+								101,
+								80,
+								111,
+								111,
+								108
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "mxe_program"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
 			}
 		],
 		args: [
 			{
-				name: "comp_offset",
-				type: "u64"
-			},
-			{
-				name: "node_offset",
+				name: "cluster_offset",
 				type: "u32"
-			},
-			{
-				name: "mxe_program",
-				type: "pubkey"
 			}
 		]
 	},
@@ -5020,7 +5208,6 @@ var instructions = [
 				docs: [
 					"MXE account to set the cluster for."
 				],
-				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -5050,7 +5237,6 @@ var instructions = [
 				docs: [
 					"Cluster to set for the MXE."
 				],
-				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -5250,47 +5436,136 @@ var instructions = [
 		],
 		args: [
 			{
-				name: "node_offset",
+				name: "node_offset",
+				type: "u32"
+			},
+			{
+				name: "_mxe_program",
+				type: "pubkey"
+			},
+			{
+				name: "mxe_x25519_pubkey",
+				type: {
+					array: [
+						"u8",
+						32
+					]
+				}
+			},
+			{
+				name: "mxe_ed25519_verifying_key",
+				type: {
+					array: [
+						"u8",
+						32
+					]
+				}
+			},
+			{
+				name: "mxe_elgamal_pubkey",
+				type: {
+					array: [
+						"u8",
+						32
+					]
+				}
+			},
+			{
+				name: "mxe_pubkey_validity_proof",
+				type: {
+					array: [
+						"u8",
+						64
+					]
+				}
+			}
+		]
+	},
+	{
+		name: "submit_aggregated_bls_pubkey",
+		discriminator: [
+			192,
+			135,
+			47,
+			120,
+			63,
+			18,
+			232,
+			164
+		],
+		accounts: [
+			{
+				name: "node_authority",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "cluster_acc",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "arx_node_acc",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								65,
+								114,
+								120,
+								78,
+								111,
+								100,
+								101
+							]
+						},
+						{
+							kind: "arg",
+							path: "node_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "cluster_id",
 				type: "u32"
 			},
 			{
-				name: "_mxe_program",
-				type: "pubkey"
-			},
-			{
-				name: "mxe_x25519_pubkey",
-				type: {
-					array: [
-						"u8",
-						32
-					]
-				}
-			},
-			{
-				name: "mxe_ed25519_verifying_key",
-				type: {
-					array: [
-						"u8",
-						32
-					]
-				}
-			},
-			{
-				name: "mxe_elgamal_pubkey",
-				type: {
-					array: [
-						"u8",
-						32
-					]
-				}
+				name: "node_bump",
+				type: "u32"
 			},
 			{
-				name: "mxe_pubkey_validity_proof",
+				name: "aggregated_bls_pubkey",
 				type: {
-					array: [
-						"u8",
-						64
-					]
+					defined: {
+						name: "BN254G2BLSPublicKey"
+					}
 				}
 			}
 		]
@@ -5995,6 +6270,11 @@ var errors = [
 		name: "InvalidCallbackInstructions",
 		msg: "Callback instructions are invalid"
 	},
+	{
+		code: 6210,
+		name: "ComputationNotExpired",
+		msg: "Computation has not expired from mempool yet"
+	},
 	{
 		code: 6300,
 		name: "ComputationDefinitionNotCompleted",
@@ -6015,6 +6295,11 @@ var errors = [
 		name: "ComputationDefinitionAlreadyCompleted",
 		msg: "Computation definition already completed"
 	},
+	{
+		code: 6304,
+		name: "InvalidCUAmount",
+		msg: "CU amount exceeds maximum limit"
+	},
 	{
 		code: 6400,
 		name: "InvalidNode",
@@ -6060,6 +6345,11 @@ var errors = [
 		name: "InvalidNodeConfig",
 		msg: "Node config is invalid"
 	},
+	{
+		code: 6409,
+		name: "UnauthorizedNodeCreation",
+		msg: "Unauthorized to create node on mainnet"
+	},
 	{
 		code: 6500,
 		name: "ClusterFull",
@@ -6134,6 +6424,41 @@ var errors = [
 		code: 6607,
 		name: "EpochOverflow",
 		msg: "Epoch overflowed"
+	},
+	{
+		code: 6608,
+		name: "InvalidLighthouseProgramID",
+		msg: "Lighthouse program ID is invalid"
+	},
+	{
+		code: 6609,
+		name: "ExtraInstructionFound",
+		msg: "Extra instruction found in transaction"
+	},
+	{
+		code: 6610,
+		name: "InvalidLighthouseInstructionCount",
+		msg: "Invalid number of Lighthouse program instructions"
+	},
+	{
+		code: 6611,
+		name: "InvalidSignature",
+		msg: "Invalid BLS signature"
+	},
+	{
+		code: 6612,
+		name: "ValueAlreadySet",
+		msg: "Value already set"
+	},
+	{
+		code: 6613,
+		name: "InvalidValueSetterIndex",
+		msg: "Invalid value setter index"
+	},
+	{
+		code: 6614,
+		name: "NotAllNodesVotedForBlsPublicKey",
+		msg: "Not all nodes have voted for the BLS public key"
 	}
 ];
 var types = [
@@ -6209,6 +6534,26 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "AccountArgument",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "pubkey",
+					type: "pubkey"
+				},
+				{
+					name: "offset",
+					type: "u32"
+				},
+				{
+					name: "length",
+					type: "u32"
+				}
+			]
+		}
+	},
 	{
 		name: "Activation",
 		type: {
@@ -6240,10 +6585,64 @@ var types = [
 		}
 	},
 	{
-		name: "Argument",
+		name: "ArgumentList",
+		docs: [
+			"Container for arguments that separates small inline values from large indexed data"
+		],
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "args",
+					type: {
+						vec: {
+							defined: {
+								name: "ArgumentRef"
+							}
+						}
+					}
+				},
+				{
+					name: "byte_arrays",
+					type: {
+						vec: {
+							array: [
+								"u8",
+								32
+							]
+						}
+					}
+				},
+				{
+					name: "plaintext_numbers",
+					type: {
+						vec: "u64"
+					}
+				},
+				{
+					name: "values_128_bit",
+					type: {
+						vec: "u128"
+					}
+				},
+				{
+					name: "accounts",
+					type: {
+						vec: {
+							defined: {
+								name: "AccountArgument"
+							}
+						}
+					}
+				}
+			]
+		}
+	},
+	{
+		name: "ArgumentRef",
 		docs: [
-			"An argument passed into a [Computation], corresponding to [super::mxe::Parameter] of the",
-			"[super::mxe::ComputationSignature]. An argument that corresponds to a Parameter type."
+			"A reference to an argument - stores small values that don't affect alignment inline and large",
+			"values as indices."
 		],
 		type: {
 			kind: "enum",
@@ -6260,153 +6659,160 @@ var types = [
 						"u8"
 					]
 				},
+				{
+					name: "PlaintextI8",
+					fields: [
+						"i8"
+					]
+				},
 				{
 					name: "PlaintextU16",
 					fields: [
-						"u16"
+						"u8"
 					]
 				},
 				{
 					name: "PlaintextU32",
 					fields: [
-						"u32"
+						"u8"
 					]
 				},
 				{
 					name: "PlaintextU64",
 					fields: [
-						"u64"
+						"u8"
 					]
 				},
 				{
 					name: "PlaintextU128",
 					fields: [
-						"u128"
+						"u8"
 					]
 				},
 				{
 					name: "PlaintextFloat",
 					fields: [
-						"f64"
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedBool",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedU8",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedU16",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedU32",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedU64",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedU128",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "EncryptedFloat",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
-					name: "ArcisPubkey",
+					name: "X25519Pubkey",
 					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
+						"u8"
 					]
 				},
 				{
-					name: "ArcisSignature",
+					name: "ArcisEd25519Signature",
 					fields: [
-						{
-							array: [
-								"u8",
-								64
-							]
-						}
+						"u8"
 					]
 				},
 				{
 					name: "Account",
 					fields: [
-						"pubkey",
-						"u32",
-						"u32"
+						"u8"
+					]
+				},
+				{
+					name: "PlaintextI16",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "PlaintextI32",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "PlaintextI64",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "PlaintextI128",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "EncryptedI8",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "EncryptedI16",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "EncryptedI32",
+					fields: [
+						"u8"
+					]
+				},
+				{
+					name: "EncryptedI64",
+					fields: [
+						"u8"
 					]
 				},
 				{
-					name: "ManticoreAlgo",
+					name: "EncryptedI128",
 					fields: [
-						"string"
+						"u8"
 					]
 				},
 				{
-					name: "InputDataset",
+					name: "PlaintextPoint",
 					fields: [
-						"string"
+						"u8"
 					]
 				}
 			]
@@ -6438,21 +6844,14 @@ var types = [
 					}
 				},
 				{
-					name: "cluster_memberships",
+					name: "cluster_membership",
 					docs: [
 						"The offsets of the cluster the node is a member of."
 					],
 					type: {
-						vec: "u32"
-					}
-				},
-				{
-					name: "proposed_cluster_memberships",
-					docs: [
-						"The offsets of the clusters the node has been proposed to be a member of."
-					],
-					type: {
-						vec: "u32"
+						defined: {
+							name: "ClusterMembership"
+						}
 					}
 				},
 				{
@@ -6464,12 +6863,14 @@ var types = [
 					type: "bool"
 				},
 				{
-					name: "reserved",
-					type: {
-						array: [
-							"u8",
-							32
-						]
+					name: "bls_pubkey",
+					docs: [
+						"BLS public key for this node (64 bytes compressed G2 point for alt-bn128)"
+					],
+					type: {
+						defined: {
+							name: "BN254G2BLSPublicKey"
+						}
 					}
 				},
 				{
@@ -6484,10 +6885,6 @@ var types = [
 		type: {
 			kind: "struct",
 			fields: [
-				{
-					name: "max_cluster_memberships",
-					type: "u32"
-				},
 				{
 					name: "authority",
 					docs: [
@@ -6505,6 +6902,20 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "BN254G2BLSPublicKey",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					array: [
+						"u8",
+						64
+					]
+				}
+			]
+		}
+	},
 	{
 		name: "CallbackAccount",
 		docs: [
@@ -6722,15 +7133,6 @@ var types = [
 						}
 					}
 				},
-				{
-					name: "mxes",
-					docs: [
-						"The MXE's that this cluster is assigned to. Referred to by the MXE's program id."
-					],
-					type: {
-						vec: "pubkey"
-					}
-				},
 				{
 					name: "nodes",
 					type: {
@@ -6751,6 +7153,28 @@ var types = [
 						}
 					}
 				},
+				{
+					name: "bls_public_key",
+					docs: [
+						"BLS public key for the cluster (64 bytes compressed G2 point for alt-bn128)",
+						"Set only when all nodes have submitted and agreed on the aggregated pubkey"
+					],
+					type: {
+						defined: {
+							name: "SetUnset",
+							generics: [
+								{
+									kind: "type",
+									type: {
+										defined: {
+											name: "BN254G2BLSPublicKey"
+										}
+									}
+								}
+							]
+						}
+					}
+				},
 				{
 					name: "bump",
 					type: "u8"
@@ -6758,6 +7182,29 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "ClusterMembership",
+		type: {
+			kind: "enum",
+			variants: [
+				{
+					name: "Inactive"
+				},
+				{
+					name: "Active",
+					fields: [
+						"u32"
+					]
+				},
+				{
+					name: "Proposed",
+					fields: [
+						"u32"
+					]
+				}
+			]
+		}
+	},
 	{
 		name: "ComputationAccount",
 		docs: [
@@ -6771,18 +7218,11 @@ var types = [
 					type: "pubkey"
 				},
 				{
-					name: "cluster_index",
+					name: "mxe_program_id",
 					docs: [
-						"The MXE's cluster to be used for execution.",
-						"",
-						"# Notes",
-						"",
-						"- [None] represents the default cluster,",
-						"- [Some] specifies the index of the fallback cluster."
+						"The program ID of the MXE that this computation is associated with."
 					],
-					type: {
-						option: "u16"
-					}
+					type: "pubkey"
 				},
 				{
 					name: "computation_definition_offset",
@@ -6819,16 +7259,24 @@ var types = [
 					}
 				},
 				{
-					name: "arguments",
+					name: "cluster_index",
 					docs: [
-						"The arguments passed to the computation. If it is a manticore computation, we expect the",
-						"first element to be of type ManticoreAlgo"
+						"The MXE's cluster to be used for execution.",
+						"",
+						"# Notes",
+						"",
+						"- [None] represents the default cluster,",
+						"- [Some] specifies the index of the fallback cluster."
 					],
 					type: {
-						vec: {
-							defined: {
-								name: "Argument"
-							}
+						option: "u16"
+					}
+				},
+				{
+					name: "arguments",
+					type: {
+						defined: {
+							name: "ArgumentList"
 						}
 					}
 				},
@@ -6984,10 +7432,6 @@ var types = [
 					name: "priority_fee",
 					type: "u64"
 				},
-				{
-					name: "computation_definition_offset",
-					type: "u32"
-				},
 				{
 					name: "accs",
 					type: {
@@ -6997,7 +7441,7 @@ var types = [
 									name: "AcccountAccessInfo"
 								}
 							},
-							10
+							12
 						]
 					}
 				}
@@ -7518,21 +7962,29 @@ var types = [
 			kind: "struct",
 			fields: [
 				{
-					name: "authority",
+					name: "cluster",
 					docs: [
-						"The management authority of the MXE."
+						"The cluster executing the MXE."
 					],
 					type: {
-						option: "pubkey"
+						option: "u32"
 					}
 				},
 				{
-					name: "cluster",
+					name: "mxe_program_id",
 					docs: [
-						"The cluster executing the MXE."
+						"The program ID of the program that this MXE is associated with. Needed so that when we",
+						"index this account offchain we can find out what program it is associated with."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "authority",
+					docs: [
+						"The management authority of the MXE."
 					],
 					type: {
-						option: "u32"
+						option: "pubkey"
 					}
 				},
 				{
@@ -7992,13 +8444,28 @@ var types = [
 					name: "Ciphertext"
 				},
 				{
-					name: "ArcisPubkey"
+					name: "ArcisX25519Pubkey"
 				},
 				{
 					name: "PlaintextFloat"
 				},
 				{
 					name: "PlaintextPoint"
+				},
+				{
+					name: "PlaintextI8"
+				},
+				{
+					name: "PlaintextI16"
+				},
+				{
+					name: "PlaintextI32"
+				},
+				{
+					name: "PlaintextI64"
+				},
+				{
+					name: "PlaintextI128"
 				}
 			]
 		}
@@ -8037,7 +8504,7 @@ var types = [
 					name: "Ciphertext"
 				},
 				{
-					name: "ArcisPubkey"
+					name: "ArcisX25519Pubkey"
 				},
 				{
 					name: "ArcisSignature"
@@ -8046,10 +8513,22 @@ var types = [
 					name: "PlaintextFloat"
 				},
 				{
-					name: "ManticoreAlgo"
+					name: "PlaintextI8"
+				},
+				{
+					name: "PlaintextI16"
 				},
 				{
-					name: "InputDataset"
+					name: "PlaintextI32"
+				},
+				{
+					name: "PlaintextI64"
+				},
+				{
+					name: "PlaintextI128"
+				},
+				{
+					name: "PlaintextPoint"
 				}
 			]
 		}
@@ -8072,6 +8551,11 @@ var types = [
 	},
 	{
 		name: "SetUnset",
+		docs: [
+			"Utility struct to store a value that needs to be set by a certain number of participants (keys",
+			"in our case). Once all participants have set the value, the value is considered set and we only",
+			"store it once."
+		],
 		generics: [
 			{
 				kind: "type",
@@ -8530,7 +9014,7 @@ var arcium = {
 	types: types
 };
 
-var ARCIUM_IDL = /*#__PURE__*/Object.freeze({
+var ARCIUM_IDL_MODULE = /*#__PURE__*/Object.freeze({
     __proto__: null,
     accounts: accounts,
     address: address,
@@ -8542,110 +9026,52 @@ var ARCIUM_IDL = /*#__PURE__*/Object.freeze({
     types: types
 });
 
+// Handle both ESM (ts-node wraps as {default: ...}) and bundled (direct) imports
+const ARCIUM_IDL = (arcium ?? ARCIUM_IDL_MODULE);
 /**
  * The deployed address of the Arcium program, as specified in the IDL.
  */
-const ARCIUM_ADDR = address;
-
-/**
- * Seed for ClockAccount PDA
- * @constant {string}
- */
-const CLOCK_ACC_SEED = 'ClockAccount';
-/**
- * Seed for FeePool PDA
- * @constant {string}
- */
-const POOL_ACC_SEED = 'FeePool';
-/**
- * Seed for ComputationAccount PDA
- * @constant {string}
- */
-const COMPUTATION_ACC_SEED = 'ComputationAccount';
-/**
- * Seed for Mempool PDA
- * @constant {string}
- */
-const MEMPOOL_ACC_SEED = 'Mempool';
-/**
- * Seed for ExecutingPoolAccount PDA
- * @constant {string}
- */
-const EXEC_POOL_ACC_SEED = 'Execpool';
-/**
- * Seed for ClusterAccount PDA
- * @constant {string}
- */
-const CLUSTER_ACC_SEED = 'Cluster';
-/**
- * Seed for ArxNodeAccount PDA
- * @constant {string}
- */
-const ARX_NODE_ACC_SEED = 'ArxNode';
-/**
- * Seed for MXEAccAccount PDA
- * @constant {string}
- */
-const MXE_ACC_ACC_SEED = 'MXEAccount';
-/**
- * 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;
-/**
- * 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;
-/**
- * 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 ARCIUM_ADDR = ARCIUM_IDL.address;
 
 /**
  * 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('Bv3Fb9VjzjWGfX18QTUcVycAfeLoQ5zZN6vv2g3cTZxp');
+    return new anchor__namespace.web3.PublicKey(ARCIUM_ADDR);
 }
 /**
- * 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.
+ * Derives the computation account address for a given cluster and computation offset.
+ * @param clusterOffset - The offset of the cluster this computation will be executed by.
+ * @param computationOffset - 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)];
+function getComputationAccAddress(clusterOffset, computationOffset) {
+    const clOffsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    clOffsetBuffer.writeUInt32LE(clusterOffset, 0);
+    const seeds = [Buffer.from(COMPUTATION_ACC_SEED), clOffsetBuffer, computationOffset.toArrayLike(Buffer, 'le', 8)];
     return generateArciumPDAFrom(seeds)[0];
 }
 /**
- * Derives the mempool account address for a given MXE program ID.
- * @param mxeProgramId - The public key of the MXE program.
+ * Derives the mempool account address for a given cluster.
+ * @param clusterOffset - The offset of the cluster.
  * @returns The derived mempool account public key.
  */
-function getMempoolAccAddress(mxeProgramId) {
-    const seeds = [Buffer.from(MEMPOOL_ACC_SEED), mxeProgramId.toBuffer()];
+function getMempoolAccAddress(clusterOffset) {
+    const clOffsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    clOffsetBuffer.writeUInt32LE(clusterOffset, 0);
+    const seeds = [Buffer.from(MEMPOOL_ACC_SEED), clOffsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
 /**
- * Derives the executing pool account address for a given MXE program ID.
- * @param mxeProgramId - The public key of the MXE program.
+ * Derives the executing pool account address for a given cluster.
+ * @param clusterOffset - The offset of the cluster.
  * @returns The derived executing pool account public key.
  */
-function getExecutingPoolAccAddress(mxeProgramId) {
-    const seeds = [Buffer.from(EXEC_POOL_ACC_SEED), mxeProgramId.toBuffer()];
+function getExecutingPoolAccAddress(clusterOffset) {
+    const clOffsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    clOffsetBuffer.writeUInt32LE(clusterOffset, 0);
+    const seeds = [Buffer.from(EXEC_POOL_ACC_SEED), clOffsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
 /**
@@ -8666,23 +9092,23 @@ function getClockAccAddress() {
 }
 /**
  * Derives the cluster account address for a given offset.
- * @param offset - The cluster offset as a number.
+ * @param clusterOffset - 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);
+function getClusterAccAddress(clusterOffset) {
+    const offsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    offsetBuffer.writeUInt32LE(clusterOffset, 0);
     const seeds = [Buffer.from(CLUSTER_ACC_SEED), offsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
 /**
  * Derives the ArxNode account address for a given offset.
- * @param offset - The ArxNode offset as a number.
+ * @param nodeOffset - 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);
+function getArxNodeAccAddress(nodeOffset) {
+    const offsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    offsetBuffer.writeUInt32LE(nodeOffset, 0);
     const seeds = [Buffer.from(ARX_NODE_ACC_SEED), offsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
@@ -8692,18 +9118,18 @@ function getArxNodeAccAddress(offset) {
  * @returns The derived MXE account public key.
  */
 function getMXEAccAddress(mxeProgramId) {
-    const seeds = [Buffer.from(MXE_ACC_ACC_SEED), mxeProgramId.toBuffer()];
+    const seeds = [Buffer.from(MXE_ACCOUNT_SEED), mxeProgramId.toBuffer()];
     return generateArciumPDAFrom(seeds)[0];
 }
 /**
  * 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.
+ * @param compDefOffset - 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);
+function getCompDefAccAddress(mxeProgramId, compDefOffset) {
+    const offsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    offsetBuffer.writeUInt32LE(compDefOffset, 0);
     const seeds = [Buffer.from(COMP_DEF_ACC_SEED), mxeProgramId.toBuffer(), offsetBuffer];
     return generateArciumPDAFrom(seeds)[0];
 }
@@ -8818,25 +9244,18 @@ const EXECPOOL_DISCRIMINATOR_MAP = {
     [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 and decodes the mempool account data for any mempool account size.
+ * Fetches and decodes the mempool account info 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.
+ * @returns The decoded mempool account info.
  * @throws Error if the account cannot be fetched or the discriminator is unknown.
  */
-async function getMempoolAccData(provider, mempoolAccPubkey) {
+async function getMempoolAccInfo(provider, mempoolAccPubkey) {
     const accData = await provider.connection.getAccountInfo(mempoolAccPubkey);
     if (accData === null) {
         throw new Error(`Failed to fetch mempool account ${mempoolAccPubkey.toBase58()}`);
     }
-    const discriminator = Array.from(accData.data.subarray(0, 8)).toString();
+    const discriminator = Array.from(accData.data.subarray(0, DISCRIMINATOR_SIZE)).toString();
     const accName = MEMPOOL_DISCRIMINATOR_MAP[discriminator];
     if (accName === undefined) {
         throw new Error(`Unknown mempool account discriminator: ${discriminator}`);
@@ -8845,18 +9264,18 @@ async function getMempoolAccData(provider, mempoolAccPubkey) {
     return program.coder.accounts.decode(accName, accData.data);
 }
 /**
- * Fetches and decodes the executing pool account data for any pool size.
+ * Fetches and decodes the executing pool account info 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.
+ * @returns The decoded executing pool account info.
  * @throws Error if the account cannot be fetched or the discriminator is unknown.
  */
-async function getExecutingPoolAccData(provider, executingPoolAccPubkey) {
+async function getExecutingPoolAccInfo(provider, executingPoolAccPubkey) {
     const accData = await provider.connection.getAccountInfo(executingPoolAccPubkey);
     if (accData === null) {
         throw new Error(`Failed to fetch executing pool account ${executingPoolAccPubkey.toBase58()}`);
     }
-    const discriminator = Array.from(accData.data.subarray(0, 8)).toString();
+    const discriminator = Array.from(accData.data.subarray(0, DISCRIMINATOR_SIZE)).toString();
     const accName = EXECPOOL_DISCRIMINATOR_MAP[discriminator];
     if (accName === undefined) {
         throw new Error(`Unknown executing pool account discriminator: ${discriminator}`);
@@ -8865,70 +9284,129 @@ async function getExecutingPoolAccData(provider, executingPoolAccPubkey) {
     return program.coder.accounts.decode(accName, accData.data);
 }
 /**
- * Fetches and extracts the MXE public key from the MXE account.
- * @param provider - The Anchor provider to use for fetching accounts.
- * @param mxeProgramID - The public key of the MXE program.
- * @returns The MXE's x25519 public key as a Uint8Array, or null if not set.
+ * Returns all computation references in the mempool for a given account.
+ * Only non-stake computations are included.
+ * @param arciumProgram - The Anchor program instance.
+ * @param address - The public key of the mempool account.
+ * @returns Array of ComputationReference objects.
  */
-async function getMXEPublicKey(provider, mxeProgramID) {
-    const program = getArciumProgram(provider);
-    const mxeAccAddress = getMXEAccAddress(mxeProgramID);
-    const mxeAccInfo = await program.account.mxeAccount.fetch(mxeAccAddress);
-    if ('set' in mxeAccInfo.utilityPubkeys) {
-        const setData = mxeAccInfo.utilityPubkeys.set;
-        return new Uint8Array(setData[0].x25519Pubkey);
+async function getComputationsInMempool(arciumProgram, address) {
+    const mempool = await getMempoolAccInfo(arciumProgram.provider, address);
+    const startIndex = mempool.inner.computations.startIndex;
+    const length = mempool.inner.computations.length;
+    const elems = mempool.inner.computations.elems;
+    function isValid(validBits, idx) {
+        const byte = idx >>> 3;
+        const bit = idx & 7;
+        if (byte >= validBits.length) {
+            // This should never happen, so we'll want to know about it
+            throw new Error(`isValid: byte ${byte} >= validBits.length ${validBits.length}`);
+        }
+        return (validBits[byte] & (1 << bit)) !== 0;
     }
-    else if ('unset' in mxeAccInfo.utilityPubkeys) {
-        const unsetData = mxeAccInfo.utilityPubkeys.unset;
-        if (unsetData[1].every(Boolean)) {
-            return new Uint8Array(unsetData[0].x25519Pubkey);
+    // Handle circular buffer wraparound
+    const refs = [];
+    for (let i = 0; i < length; i++) {
+        const idx = (startIndex + i) % elems.length;
+        // Only save non-stake computations
+        if (isValid(mempool.inner.computations.validBits, idx)) {
+            refs.push(...elems[idx].entries);
         }
     }
-    return null;
+    return refs
+        .flat()
+        .filter((ref) => !isNullRef(ref));
 }
 /**
- * Fetches and extracts the MXE arcis ed25519 verifying key from the MXE account.
+ * Calculates priority fee statistics for computations in a mempool.
+ * @param arciumProgram - The Anchor program instance.
+ * @param mempoolAddress - The public key of the mempool account.
+ * @returns Priority fee statistics (mean, median, min, max, count).
+ */
+async function getMempoolPriorityFeeStats(arciumProgram, mempoolAddress) {
+    const refs = await getComputationsInMempool(arciumProgram, mempoolAddress);
+    if (refs.length === 0) {
+        const zero = new anchor__namespace.BN(0);
+        return { mean: zero, median: zero, min: zero, max: zero, count: 0 };
+    }
+    const fees = refs.map(ref => ref.priorityFee).sort((a, b) => a.cmp(b));
+    const sum = fees.reduce((acc, fee) => acc.add(fee), new anchor__namespace.BN(0));
+    const mean = sum.div(new anchor__namespace.BN(fees.length));
+    const mid = Math.floor(fees.length / 2);
+    const median = fees.length % 2 === 0
+        ? fees[mid - 1].add(fees[mid]).div(new anchor__namespace.BN(2))
+        : fees[mid];
+    return {
+        mean,
+        median,
+        min: fees[0],
+        max: fees[fees.length - 1],
+        count: fees.length,
+    };
+}
+/**
+ * Helper function to fetch a specific utility key from the MXE account.
  * @param provider - The Anchor provider to use for fetching accounts.
- * @param mxeProgramID - The public key of the MXE program.
- * @returns The MXE's arcis ed25519 verifying key as a Uint8Array, or null if not set.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @param field - The field name to extract ('x25519Pubkey' or 'ed25519VerifyingKey').
+ * @returns The utility key as a Uint8Array, or null if not set.
  */
-async function getMXEArcisEd25519VerifyingKey(provider, mxeProgramID) {
+async function getMXEUtilityKey(provider, mxeProgramId, field) {
     const program = getArciumProgram(provider);
-    const mxeAccAddress = getMXEAccAddress(mxeProgramID);
+    const mxeAccAddress = getMXEAccAddress(mxeProgramId);
     const mxeAccInfo = await program.account.mxeAccount.fetch(mxeAccAddress);
     if ('set' in mxeAccInfo.utilityPubkeys) {
         const setData = mxeAccInfo.utilityPubkeys.set;
-        return new Uint8Array(setData[0].ed25519VerifyingKey);
+        return new Uint8Array(setData[0][field]);
     }
     else if ('unset' in mxeAccInfo.utilityPubkeys) {
         const unsetData = mxeAccInfo.utilityPubkeys.unset;
         if (unsetData[1].every(Boolean)) {
-            return new Uint8Array(unsetData[0].ed25519VerifyingKey);
+            return new Uint8Array(unsetData[0][field]);
         }
     }
     return null;
 }
+/**
+ * Fetches and extracts the MXE x25519 public key from the MXE account.
+ * @param provider - The Anchor provider to use for fetching accounts.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @returns The MXE's x25519 public key as a Uint8Array, or null if not set.
+ */
+async function getMXEPublicKey(provider, mxeProgramId) {
+    return getMXEUtilityKey(provider, mxeProgramId, 'x25519Pubkey');
+}
+/**
+ * Fetches and extracts the MXE arcis ed25519 verifying key from the MXE account.
+ * @param provider - The Anchor provider to use for fetching accounts.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @returns The MXE's arcis ed25519 verifying key as a Uint8Array, or null if not set.
+ */
+async function getMXEArcisEd25519VerifyingKey(provider, mxeProgramId) {
+    return getMXEUtilityKey(provider, mxeProgramId, 'ed25519VerifyingKey');
+}
 /**
  * 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 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) {
+async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, logging = true, chunkSize = 500) {
+    // 9 = 8-byte discriminator + 1-byte bump for ComputationDefinitionRaw account
     const numAccs = Math.ceil(rawCircuit.length / (MAX_ACCOUNT_SIZE - 9));
-    const compDefAccInfo = getCompDefAccInfo(circuitName, mxeProgramID);
+    const compDefAccInfo = getCompDefAccInfo(circuitName, mxeProgramId);
     const program = getArciumProgram(provider);
     const sigs = [];
     const uploadPromises = [];
     for (let i = 0; i < numAccs; i++) {
-        uploadPromises.push(uploadToCircuitAcc(provider, program, rawCircuit.subarray(i * (MAX_ACCOUNT_SIZE - 9), (i + 1) * (MAX_ACCOUNT_SIZE - 9)), i, compDefAccInfo, mxeProgramID, logging, chunkSize));
+        uploadPromises.push(uploadToCircuitAcc(provider, program, rawCircuit.subarray(i * (MAX_ACCOUNT_SIZE - 9), (i + 1) * (MAX_ACCOUNT_SIZE - 9)), i, compDefAccInfo, mxeProgramId, logging, chunkSize));
     }
     sigs.push(...(await Promise.all(uploadPromises)).flat());
-    const finalizeCompDefTx = await buildFinalizeCompDefTx(provider, compDefAccInfo.offset, mxeProgramID);
+    const finalizeCompDefTx = await buildFinalizeCompDefTx(provider, compDefAccInfo.offset, mxeProgramId);
     sigs.push(await signAndSendWithBlockhash(provider, finalizeCompDefTx, await provider.connection.getLatestBlockhash()));
     return sigs;
 }
@@ -8936,24 +9414,24 @@ async function uploadCircuit(provider, circuitName, mxeProgramID, rawCircuit, lo
  * 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.
+ * @param mxeProgramId - The public key of the MXE program.
  * @returns The transaction to finalize the computation definition.
  */
-async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramID) {
+async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramId) {
     const program = getArciumProgram(provider);
-    const compDefOffsetBuffer = Buffer.alloc(4);
+    const compDefOffsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
     compDefOffsetBuffer.writeUInt32LE(compDefOffset, 0);
     return program.methods
-        .finalizeComputationDefinition(compDefOffset, mxeProgramID)
+        .finalizeComputationDefinition(compDefOffset, mxeProgramId)
         .accounts({
         signer: provider.publicKey,
     })
         .transaction();
 }
-async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramID, shouldLog = true, chunkSize = 500) {
+async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramId, shouldLog = true, chunkSize = 500) {
     const sigs = [];
     const initTx = await program.methods
-        .initRawCircuitAcc(compDefAccInfo.offset, mxeProgramID, rawCircuitIndex)
+        .initRawCircuitAcc(compDefAccInfo.offset, mxeProgramId, rawCircuitIndex)
         .accounts({
         signer: provider.publicKey,
     })
@@ -8966,7 +9444,7 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
         for (let i = 0; i < nonAsyncTxCount; i++) {
             optionalLog(shouldLog, `Sending resize tx ${i} of ${nonAsyncTxCount}`);
             // eslint-disable-next-line no-await-in-loop
-            const tx = await buildResizeTx(program, provider.publicKey, compDefAccInfo, mxeProgramID, rawCircuitIndex, MAX_REALLOC_PER_IX
+            const tx = await buildResizeTx(program, provider.publicKey, compDefAccInfo, mxeProgramId, rawCircuitIndex, MAX_REALLOC_PER_IX
                 + i * (MAX_REALLOC_PER_IX * MAX_EMBIGGEN_IX_PER_TX), rawCircuitPart.length);
             // eslint-disable-next-line no-await-in-loop
             const blockInfo = await provider.connection.getLatestBlockhash();
@@ -8989,7 +9467,7 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
         for (let j = 0; j < currentChunkSize; j++) {
             const offset = MAX_UPLOAD_PER_TX_BYTES * (i + j);
             // eslint-disable-next-line no-await-in-loop
-            const tx = await buildUploadCircuitTx(program, provider.publicKey, compDefAccInfo, mxeProgramID, Buffer.copyBytesFrom(rawCircuitPart, offset, MAX_UPLOAD_PER_TX_BYTES), offset, rawCircuitIndex);
+            const tx = await buildUploadCircuitTx(program, provider.publicKey, compDefAccInfo, mxeProgramId, Buffer.copyBytesFrom(rawCircuitPart, offset, MAX_UPLOAD_PER_TX_BYTES), offset, rawCircuitIndex);
             chunkPromises.push(signAndSendWithBlockhash(provider, tx, blockInfo));
         }
         // Wait for the current chunk to complete before proceeding
@@ -9000,9 +9478,9 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
     }
     return sigs.concat(remainingTxs);
 }
-async function buildResizeTx(program, signerPubkey, compDefAccInfo, mxeProgramID, rawCircuitIndex, currentSize, requiredSize) {
+async function buildResizeTx(program, signerPubkey, compDefAccInfo, mxeProgramId, rawCircuitIndex, currentSize, requiredSize) {
     const ix = await program.methods
-        .embiggenRawCircuitAcc(compDefAccInfo.offset, mxeProgramID, rawCircuitIndex)
+        .embiggenRawCircuitAcc(compDefAccInfo.offset, mxeProgramId, rawCircuitIndex)
         .accounts({
         signer: signerPubkey,
     })
@@ -9016,9 +9494,9 @@ async function buildResizeTx(program, signerPubkey, compDefAccInfo, mxeProgramID
     }
     return tx;
 }
-async function buildUploadCircuitTx(program, signerPubkey, compDefAccInfo, mxeProgramID, bytes, circuitOffset, rawCircuitIndex) {
+async function buildUploadCircuitTx(program, signerPubkey, compDefAccInfo, mxeProgramId, bytes, circuitOffset, rawCircuitIndex) {
     if (bytes.length > MAX_UPLOAD_PER_TX_BYTES) {
-        throw new Error('Upload circuit bytes must be 814 bytes or less per tx');
+        throw new Error(`Upload circuit bytes must be ${MAX_UPLOAD_PER_TX_BYTES} bytes or less per tx`);
     }
     let bytesInner = bytes;
     if (bytesInner.length < MAX_UPLOAD_PER_TX_BYTES) {
@@ -9027,7 +9505,7 @@ async function buildUploadCircuitTx(program, signerPubkey, compDefAccInfo, mxePr
         bytesInner = paddedBytes;
     }
     return program.methods
-        .uploadCircuit(compDefAccInfo.offset, mxeProgramID, rawCircuitIndex, Array.from(bytesInner), circuitOffset)
+        .uploadCircuit(compDefAccInfo.offset, mxeProgramId, rawCircuitIndex, Array.from(bytesInner), circuitOffset)
         .accounts({
         signer: signerPubkey,
     })
@@ -9055,7 +9533,7 @@ function getArciumAccountBaseSeed(accName) {
  */
 function getCompDefAccOffset(circuitName) {
     const hash = new Uint8Array(sha256([Buffer.from(circuitName, 'utf-8')]));
-    return hash.slice(0, 4);
+    return hash.slice(0, COMP_DEF_OFFSET_SIZE);
 }
 /**
  * Returns an Anchor program instance for the Arcium program.
@@ -9065,45 +9543,26 @@ function getCompDefAccOffset(circuitName) {
 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.
+ * @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) {
+function getCompDefAccInfo(circuitName, mxeProgramId) {
     const offset = getCompDefAccOffset(circuitName);
-    const pda = getCompDefAccPDA(getArciumProgAddress(), mxeProgramID, offset);
+    const pda = getCompDefAccPDA(getArciumProgramId(), 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 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];
+function getCompDefAccPDA(arciumProgramId, mxeProgramId, offset) {
+    return anchor__namespace.web3.PublicKey.findProgramAddressSync([Buffer.from(COMP_DEF_ACC_SEED, 'utf-8'), mxeProgramId.toBuffer(), offset], arciumProgramId)[0];
 }
 
 /**
@@ -9116,13 +9575,13 @@ function getArciumEnv() {
     if (isBrowser()) {
         throw new Error('Arcium local env is not available in browser.');
     }
-    // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
-    const process = require('process');
     try {
-        // const arxNodePubkey = new PublicKey(process.env.ARX_NODE_PUBKEY);
-        const arciumClusterPubkey = new web3_js.PublicKey(process.env.ARCIUM_CLUSTER_PUBKEY);
+        const arciumClusterOffset = Number(process.env.ARCIUM_CLUSTER_OFFSET);
+        if (isNaN(arciumClusterOffset)) {
+            throw new Error('ARCIUM_CLUSTER_OFFSET environment variable is not set or is invalid (NaN).');
+        }
         return {
-            arciumClusterPubkey,
+            arciumClusterOffset,
         };
     }
     catch (e) {
@@ -9188,25 +9647,25 @@ exports.deserializeLE = deserializeLE;
 exports.generateRandomFieldElem = generateRandomFieldElem;
 exports.getArciumAccountBaseSeed = getArciumAccountBaseSeed;
 exports.getArciumEnv = getArciumEnv;
-exports.getArciumProgAddress = getArciumProgAddress;
 exports.getArciumProgram = getArciumProgram;
 exports.getArciumProgramId = getArciumProgramId;
-exports.getArciumProgramReadonly = getArciumProgramReadonly;
-exports.getArxAccPDA = getArxAccPDA;
 exports.getArxNodeAccAddress = getArxNodeAccAddress;
 exports.getClockAccAddress = getClockAccAddress;
 exports.getClusterAccAddress = getClusterAccAddress;
 exports.getCompDefAccAddress = getCompDefAccAddress;
 exports.getCompDefAccOffset = getCompDefAccOffset;
 exports.getComputationAccAddress = getComputationAccAddress;
+exports.getComputationsInMempool = getComputationsInMempool;
 exports.getExecutingPoolAccAddress = getExecutingPoolAccAddress;
-exports.getExecutingPoolAccData = getExecutingPoolAccData;
+exports.getExecutingPoolAccInfo = getExecutingPoolAccInfo;
 exports.getFeePoolAccAddress = getFeePoolAccAddress;
 exports.getMXEAccAddress = getMXEAccAddress;
 exports.getMXEArcisEd25519VerifyingKey = getMXEArcisEd25519VerifyingKey;
 exports.getMXEPublicKey = getMXEPublicKey;
 exports.getMempoolAccAddress = getMempoolAccAddress;
-exports.getMempoolAccData = getMempoolAccData;
+exports.getMempoolAccInfo = getMempoolAccInfo;
+exports.getMempoolPriorityFeeStats = getMempoolPriorityFeeStats;
+exports.isNullRef = isNullRef;
 exports.positiveModulo = positiveModulo;
 exports.randMatrix = randMatrix;
 exports.serializeLE = serializeLE;