@arcium-hq/client 0.2.0 → 0.4.0

package/build/index.cjs

@@ -1079,7 +1079,7 @@ function getCounter(nonce, nBlocks) {
 // SHA3-512 instead of SHA-512 since its multiplicative depth is much lower, which
 // makes it much better suited to be evaluated in MPC.
 // Those are the parameters specified [here](https://datatracker.ietf.org/doc/html/rfc8032#section-5.1)
-// (except for the hash function, see above). The below is copied from [here](https://github.com/paulmillr/noble-curves/blob/main/src/ed25519.ts#L111).
+// (except for the hash function, see above). The below is copied from [here](https://github.com/paulmillr/noble-curves/blob/main/src/ed25519.ts).
 const arcisEd25519Defaults = (() => ({
     a: BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819948'),
     d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
@@ -1093,6 +1093,34 @@ const arcisEd25519Defaults = (() => ({
     adjustScalarBytes,
     uvRatio,
 }))();
+/**
+ * Ed25519 curve instance using SHA3-512 for hashing, suitable for MPC (ArcisEd25519 signature scheme).
+ * This is essentially Ed25519 but with SHA3-512 instead of SHA-512 for lower multiplicative depth.
+ * See: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1
+ */
+const arcisEd25519 = (() => edwards.twistedEdwards(arcisEd25519Defaults))();
+// Helper function for the sqrt in Fp.
+function ed25519_pow_2_252_3(x) {
+    // prettier-ignore
+    const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+    const P = ed25519.ed25519.CURVE.Fp.ORDER;
+    const x2 = (x * x) % P;
+    const b2 = (x2 * x) % P; // x^3, 11
+    const b4 = (modular.pow2(b2, 2n, P) * b2) % P; // x^15, 1111
+    const b5 = (modular.pow2(b4, 1n, P) * x) % P; // x^31
+    const b10 = (modular.pow2(b5, 5n, P) * b5) % P;
+    const b20 = (modular.pow2(b10, _10n, P) * b10) % P;
+    const b40 = (modular.pow2(b20, _20n, P) * b20) % P;
+    const b80 = (modular.pow2(b40, _40n, P) * b40) % P;
+    const b160 = (modular.pow2(b80, _80n, P) * b80) % P;
+    const b240 = (modular.pow2(b160, _80n, P) * b80) % P;
+    const b250 = (modular.pow2(b240, _10n, P) * b10) % P;
+    const pow_p_5_8 = (modular.pow2(b250, 2n, P) * x) % P;
+    // ^ To pow to (p+3)/8, multiply it by x.
+    return { pow_p_5_8, b2 };
+}
+// Fp.sqrt(Fp.neg(1))
+const ED25519_SQRT_M1 = /* @__PURE__ */ BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
 /**
  * Clamps a 32-byte scalar as required by the Ed25519 signature scheme.
  * See: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.5
@@ -1107,19 +1135,30 @@ function adjustScalarBytes(bytes) {
     return clamped;
 }
 /**
- * Dummy function for compatibility; not used in the ArcisEd25519 signature scheme.
- * Always returns { isValid: true, value: 0n }.
- * @returns An object with isValid: true and value: 0n.
+ * Helper function for decompression, calculating √(u/v).
+ * @returns An object with isValid and value.
  */
-function uvRatio() {
-    return { isValid: true, value: 0n };
+function uvRatio(u, v) {
+    const P = ed25519.ed25519.CURVE.Fp.ORDER;
+    const v3 = modular.mod(v * v * v, P); // v³
+    const v7 = modular.mod(v3 * v3 * v, P); // v⁷
+    // (p+3)/8 and (p-5)/8
+    const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+    let x = modular.mod(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8
+    const vx2 = modular.mod(v * x * x, P); // vx²
+    const root1 = x; // First root candidate
+    const root2 = modular.mod(x * ED25519_SQRT_M1, P); // Second root candidate
+    const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root
+    const useRoot2 = vx2 === modular.mod(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)
+    const noRoot = vx2 === modular.mod(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)
+    if (useRoot1)
+        x = root1;
+    if (useRoot2 || noRoot)
+        x = root2; // We return root2 anyway, for const-time
+    if (modular.isNegativeLE(x, P))
+        x = modular.mod(-x, P);
+    return { isValid: useRoot1 || useRoot2, value: x };
 }
-/**
- * Ed25519 curve instance using SHA3-512 for hashing, suitable for MPC (ArcisEd25519 signature scheme).
- * This is essentially Ed25519 but with SHA3-512 instead of SHA-512 for lower multiplicative depth.
- * See: https://datatracker.ietf.org/doc/html/rfc8032#section-5.1
- */
-const arcisEd25519 = (() => edwards.twistedEdwards(arcisEd25519Defaults))();
 
 /**
  * AES-128 cipher in Counter (CTR) mode, using HKDF-SHA3-256 to derive the key from a shared secret.
@@ -1268,10 +1307,10 @@ class Aes256Cipher {
     }
 }
 
-var address = "BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6";
+var address = "Bv3Fb9VjzjWGfX18QTUcVycAfeLoQ5zZN6vv2g3cTZxp";
 var metadata = {
 	name: "arcium",
-	version: "0.2.0",
+	version: "0.4.0",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -1589,7 +1628,7 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "mxe.cluster.ok_or(MXEError :: ClusterNotSet) ? ",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
 							account: "MXEAccount"
 						}
 					]
@@ -1764,20 +1803,24 @@ var instructions = [
 						name: "ExecutionStatus"
 					}
 				}
+			},
+			{
+				name: "callback_transaction_index",
+				type: "u8"
 			}
 		]
 	},
 	{
-		name: "deactivate_arx",
+		name: "claim_failure_append",
 		discriminator: [
-			117,
-			244,
-			137,
-			148,
-			25,
-			190,
-			175,
-			164
+			92,
+			52,
+			184,
+			203,
+			76,
+			221,
+			128,
+			69
 		],
 		accounts: [
 			{
@@ -1786,156 +1829,233 @@ var instructions = [
 				signer: true
 			},
 			{
-				name: "arx_node_acc",
+				name: "failure_acc",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								65,
+								70,
+								97,
+								105,
+								108,
+								117,
 								114,
-								120,
-								78,
+								101,
+								67,
+								108,
+								97,
+								105,
+								109,
+								65,
+								99,
+								99,
 								111,
+								117,
+								110,
+								116,
+								72,
+								101,
+								97,
 								100,
-								101
+								101,
+								114
 							]
 						},
 						{
 							kind: "arg",
-							path: "_node_offset"
+							path: "mxe_program"
+						},
+						{
+							kind: "arg",
+							path: "comp_offset"
 						}
 					]
 				}
 			},
 			{
-				name: "clock",
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "comp_offset",
+				type: "u64"
+			},
+			{
+				name: "node_offset",
+				type: "u32"
+			},
+			{
+				name: "mxe_program",
+				type: "pubkey"
+			},
+			{
+				name: "chunk",
+				type: "bytes"
+			},
+			{
+				name: "failure_claim_offset",
+				type: "u32"
+			}
+		]
+	},
+	{
+		name: "claim_failure_finalize",
+		discriminator: [
+			192,
+			133,
+			215,
+			19,
+			76,
+			107,
+			111,
+			217
+		],
+		accounts: [
+			{
+				name: "signer",
+				signer: true
+			},
+			{
+				name: "failure_acc",
+				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
+								70,
+								97,
+								105,
+								108,
+								117,
+								114,
+								101,
 								67,
 								108,
-								111,
-								99,
-								107,
+								97,
+								105,
+								109,
 								65,
 								99,
 								99,
 								111,
 								117,
 								110,
-								116
-							]
-						}
-					]
-				}
-			},
-			{
-				name: "cluster_acc_0",
-				optional: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
 								116,
+								72,
+								101,
+								97,
+								100,
 								101,
 								114
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
+						},
+						{
+							kind: "arg",
+							path: "comp_offset"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_1",
-				optional: true,
+				name: "executing_pool",
+				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
+								69,
+								120,
 								101,
-								114
+								99,
+								112,
+								111,
+								111,
+								108
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(1).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_2",
-				optional: true,
+				name: "mempool",
+				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
+								77,
 								101,
-								114
+								109,
+								112,
+								111,
+								111,
+								108
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(2).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_3",
-				optional: true,
+				name: "comp",
+				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								108,
+								111,
+								109,
+								112,
 								117,
-								115,
 								116,
-								101,
-								114
+								97,
+								116,
+								105,
+								111,
+								110,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(3).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
+						},
+						{
+							kind: "arg",
+							path: "comp_offset"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_4",
-				optional: true,
+				name: "cluster_acc",
+				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -1952,41 +2072,125 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(4).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_5",
-				optional: true,
+				name: "mxe",
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								67,
-								108,
+								77,
+								88,
+								69,
+								65,
+								99,
+								99,
+								111,
 								117,
-								115,
-								116,
-								101,
-								114
+								110,
+								116
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(5).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
 						}
 					]
 				}
+			}
+		],
+		args: [
+			{
+				name: "comp_offset",
+				type: "u64"
 			},
 			{
-				name: "cluster_acc_6",
-				optional: true,
-				pda: {
+				name: "node_offset",
+				type: "u32"
+			},
+			{
+				name: "mxe_program",
+				type: "pubkey"
+			}
+		]
+	},
+	{
+		name: "claim_failure_init",
+		discriminator: [
+			204,
+			106,
+			245,
+			73,
+			212,
+			136,
+			61,
+			99
+		],
+		accounts: [
+			{
+				name: "signer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "node_acc",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								65,
+								114,
+								120,
+								78,
+								111,
+								100,
+								101
+							]
+						},
+						{
+							kind: "arg",
+							path: "node_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "mxe",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								77,
+								88,
+								69,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						},
+						{
+							kind: "arg",
+							path: "_mxe_program"
+						}
+					]
+				}
+			},
+			{
+				name: "cluster_acc",
+				writable: true,
+				pda: {
 					seeds: [
 						{
 							kind: "const",
@@ -2002,133 +2206,203 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(6).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_7",
-				optional: true,
+				name: "comp_acc",
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								108,
+								111,
+								109,
+								112,
 								117,
-								115,
 								116,
-								101,
-								114
+								97,
+								116,
+								105,
+								111,
+								110,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(7).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
+						},
+						{
+							kind: "arg",
+							path: "comp_offset"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_8",
-				optional: true,
+				name: "comp_def_acc",
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								108,
+								111,
+								109,
+								112,
 								117,
-								115,
 								116,
+								97,
+								116,
+								105,
+								111,
+								110,
+								68,
 								101,
-								114
+								102,
+								105,
+								110,
+								105,
+								116,
+								105,
+								111,
+								110,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
 							]
 						},
+						{
+							kind: "arg",
+							path: "_mxe_program"
+						},
 						{
 							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(8).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							path: "comp_acc.computation_definition_offset",
+							account: "ComputationAccount"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc_9",
-				optional: 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,
-								115,
+								110,
 								116,
+								72,
+								101,
+								97,
+								100,
 								101,
 								114
 							]
 						},
 						{
-							kind: "account",
-							path: "arx_node_acc.cluster_memberships.get(9).ok_or(NodeError ::\nInvalidClusterMembership) ? ",
-							account: "ArxNode"
+							kind: "arg",
+							path: "_mxe_program"
+						},
+						{
+							kind: "arg",
+							path: "comp_offset"
 						}
 					]
 				}
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
 			}
 		],
 		args: [
+			{
+				name: "comp_offset",
+				type: "u64"
+			},
 			{
 				name: "node_offset",
 				type: "u32"
+			},
+			{
+				name: "mxe_program",
+				type: "pubkey"
 			}
 		]
 	},
 	{
-		name: "deactivate_cluster",
+		name: "deactivate_arx",
 		discriminator: [
-			13,
-			42,
-			182,
-			159,
-			184,
-			10,
-			212,
-			178
+			117,
+			244,
+			137,
+			148,
+			25,
+			190,
+			175,
+			164
 		],
 		accounts: [
 			{
-				name: "authority",
+				name: "signer",
 				writable: true,
 				signer: true
 			},
 			{
-				name: "cluster_acc",
+				name: "arx_node_acc",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
+								65,
+								114,
+								120,
+								78,
+								111,
+								100,
+								101
 							]
 						},
 						{
 							kind: "arg",
-							path: "_id"
+							path: "_node_offset"
 						}
 					]
 				}
@@ -2158,287 +2432,233 @@ var instructions = [
 				}
 			},
 			{
-				name: "system_program",
-				address: "11111111111111111111111111111111"
-			}
-		],
-		args: [
-			{
-				name: "cluster_id",
-				type: "u32"
+				name: "cluster_acc_0",
+				optional: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "account",
+							path: "arx_node_acc.cluster_memberships",
+							account: "ArxNode"
+						}
+					]
+				}
 			},
 			{
-				name: "deactivation_epoch",
-				type: {
-					defined: {
-						name: "Epoch"
-					}
+				name: "cluster_acc_1",
+				optional: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "account",
+							path: "arx_node_acc.cluster_memberships.get(1).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
+							account: "ArxNode"
+						}
+					]
 				}
-			}
-		]
-	},
-	{
-		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: "cluster_acc_2",
+				optional: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								111,
-								109,
-								112,
+								108,
 								117,
+								115,
 								116,
-								97,
-								116,
-								105,
-								111,
-								110,
-								68,
 								101,
-								102,
-								105,
-								110,
-								105,
-								116,
-								105,
-								111,
-								110,
-								65,
-								99,
-								99,
-								111,
-								117,
-								110,
-								116
+								114
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
-						},
-						{
-							kind: "arg",
-							path: "_comp_offset"
+							kind: "account",
+							path: "arx_node_acc.cluster_memberships.get(2).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
+							account: "ArxNode"
 						}
 					]
 				}
 			},
 			{
-				name: "comp_def_raw",
-				writable: true,
+				name: "cluster_acc_3",
+				optional: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								111,
-								109,
-								112,
+								108,
 								117,
+								115,
 								116,
-								97,
-								116,
-								105,
-								111,
-								110,
-								68,
 								101,
-								102,
-								105,
-								110,
-								105,
-								116,
-								105,
-								111,
-								110,
-								82,
-								97,
-								119
+								114
 							]
 						},
 						{
 							kind: "account",
-							path: "comp_def_acc"
-						},
-						{
-							kind: "arg",
-							path: "_raw_circuit_index"
+							path: "arx_node_acc.cluster_memberships.get(3).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
+							account: "ArxNode"
 						}
 					]
 				}
 			},
 			{
-				name: "system_program",
-				address: "11111111111111111111111111111111"
-			}
-		],
-		args: [
-			{
-				name: "comp_offset",
-				type: "u32"
-			},
-			{
-				name: "mxe_program",
-				type: "pubkey"
+				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: "raw_circuit_index",
-				type: "u8"
-			}
-		]
-	},
-	{
-		name: "finalize_computation",
-		discriminator: [
-			43,
-			29,
-			152,
-			92,
-			241,
-			179,
-			193,
-			210
-		],
-		accounts: [
-			{
-				name: "signer",
-				writable: true,
-				signer: true
+				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: "comp",
-				writable: true,
+				name: "cluster_acc_6",
+				optional: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								111,
-								109,
-								112,
+								108,
 								117,
+								115,
 								116,
-								97,
-								116,
-								105,
-								111,
-								110,
-								65,
-								99,
-								99,
-								111,
-								117,
-								110,
-								116
+								101,
+								114
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							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: "arg",
-							path: "comp_offset"
+							kind: "account",
+							path: "arx_node_acc.cluster_memberships.get(7).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
+							account: "ArxNode"
 						}
 					]
 				}
 			},
 			{
-				name: "mxe",
+				name: "cluster_acc_8",
+				optional: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								77,
-								88,
-								69,
-								65,
-								99,
-								99,
-								111,
+								67,
+								108,
 								117,
-								110,
-								116
+								115,
+								116,
+								101,
+								114
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "arx_node_acc.cluster_memberships.get(8).ok_or(ArciumError ::\nInvalidClusterMembership) ? ",
+							account: "ArxNode"
 						}
 					]
 				}
 			},
 			{
-				name: "cluster_acc",
-				writable: true,
+				name: "cluster_acc_9",
+				optional: true,
 				pda: {
 					seeds: [
 						{
@@ -2455,61 +2675,169 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "mxe.cluster.ok_or(MXEError :: ClusterNotSet) ? ",
-							account: "MXEAccount"
+							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: "executing_pool",
+				name: "cluster_acc",
 				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								69,
-								120,
+								67,
+								108,
+								117,
+								115,
+								116,
 								101,
-								99,
-								112,
-								111,
-								111,
-								108
+								114
 							]
 						},
 						{
 							kind: "arg",
-							path: "_mxe_program"
+							path: "_id"
 						}
 					]
 				}
 			},
 			{
-				name: "mempool",
-				writable: true,
+				name: "clock",
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								77,
-								101,
-								109,
-								112,
+								67,
+								108,
 								111,
+								99,
+								107,
+								65,
+								99,
+								99,
 								111,
-								108
+								117,
+								110,
+								116
 							]
-						},
-						{
-							kind: "arg",
-							path: "_mxe_program"
 						}
 					]
 				}
 			},
+			{
+				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",
 				pda: {
@@ -2553,31 +2881,52 @@ var instructions = [
 						},
 						{
 							kind: "arg",
-							path: "_comp_def_offset"
+							path: "_comp_offset"
 						}
 					]
 				}
 			},
 			{
-				name: "clock",
+				name: "comp_def_raw",
+				writable: true,
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
 								67,
-								108,
-								111,
-								99,
-								107,
-								65,
-								99,
-								99,
 								111,
+								109,
+								112,
 								117,
+								116,
+								97,
+								116,
+								105,
+								111,
 								110,
-								116
+								68,
+								101,
+								102,
+								105,
+								110,
+								105,
+								116,
+								105,
+								111,
+								110,
+								82,
+								97,
+								119
 							]
+						},
+						{
+							kind: "account",
+							path: "comp_def_acc"
+						},
+						{
+							kind: "arg",
+							path: "_raw_circuit_index"
 						}
 					]
 				}
@@ -2590,15 +2939,15 @@ var instructions = [
 		args: [
 			{
 				name: "comp_offset",
-				type: "u64"
-			},
-			{
-				name: "comp_def_offset",
 				type: "u32"
 			},
 			{
 				name: "mxe_program",
 				type: "pubkey"
+			},
+			{
+				name: "raw_circuit_index",
+				type: "u8"
 			}
 		]
 	},
@@ -2745,7 +3094,7 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "mxe.cluster.ok_or(MXEError :: ClusterNotSet) ? ",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
 							account: "MXEAccount"
 						}
 					]
@@ -3270,10 +3619,6 @@ var instructions = [
 				type: {
 					option: "pubkey"
 				}
-			},
-			{
-				name: "finalize_during_callback",
-				type: "bool"
 			}
 		]
 	},
@@ -4097,7 +4442,7 @@ var instructions = [
 		name: "queue_computation",
 		docs: [
 			"Queues a computation.",
-			"cu_price_micro: The priority price of a CU, in thousandths of a $ARX. Used",
+			"cu_price_micro: The priority price of a CU, in thousandths of lamports. Used",
 			"to calculate the priority fee and rounded down."
 		],
 		discriminator: [
@@ -4116,6 +4461,41 @@ var instructions = [
 				writable: true,
 				signer: true
 			},
+			{
+				name: "sign_seed",
+				docs: [
+					"This is ok-ish though, as we're not reading the account, we just need it to check that the",
+					"CPI invocation is valid. The only downside is it's a bit ugly and wastes some CUs since",
+					"we can't use a potentially stored bump."
+				],
+				signer: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								83,
+								105,
+								103,
+								110,
+								101,
+								114,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						}
+					],
+					program: {
+						kind: "arg",
+						path: "_mxe_program"
+					}
+				}
+			},
 			{
 				name: "comp",
 				writable: true,
@@ -4297,7 +4677,7 @@ var instructions = [
 						},
 						{
 							kind: "arg",
-							path: "cluster_index.map_or(mxe.cluster.ok_or(MXEError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
+							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
 						}
 					]
 				}
@@ -4376,16 +4756,6 @@ var instructions = [
 					}
 				}
 			},
-			{
-				name: "callback_accs",
-				type: {
-					vec: {
-						defined: {
-							name: "CallbackAccount"
-						}
-					}
-				}
-			},
 			{
 				name: "mxe_program",
 				type: "pubkey"
@@ -4397,8 +4767,18 @@ var instructions = [
 				}
 			},
 			{
-				name: "input_delivery_fee",
-				type: "u64"
+				name: "custom_callback_instructions",
+				type: {
+					vec: {
+						defined: {
+							name: "CallbackInstruction"
+						}
+					}
+				}
+			},
+			{
+				name: "callback_transactions_required",
+				type: "u8"
 			},
 			{
 				name: "output_delivery_fee",
@@ -4410,6 +4790,90 @@ var instructions = [
 			}
 		]
 	},
+	{
+		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: "set_arx_node_config",
 		discriminator: [
@@ -4773,7 +5237,7 @@ var instructions = [
 						},
 						{
 							kind: "account",
-							path: "mxe.cluster.ok_or(MXEError :: ClusterNotSet) ? ",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
 							account: "MXEAccount"
 						}
 					]
@@ -4801,6 +5265,33 @@ var instructions = [
 						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
+					]
+				}
 			}
 		]
 	},
@@ -5151,6 +5642,19 @@ var accounts = [
 			136
 		]
 	},
+	{
+		name: "FailureClaimAccountHeader",
+		discriminator: [
+			132,
+			11,
+			106,
+			171,
+			253,
+			138,
+			56,
+			78
+		]
+	},
 	{
 		name: "FeePool",
 		discriminator: [
@@ -5309,6 +5813,19 @@ var events = [
 			19
 		]
 	},
+	{
+		name: "ClaimFailureEvent",
+		discriminator: [
+			143,
+			97,
+			229,
+			166,
+			72,
+			218,
+			87,
+			145
+		]
+	},
 	{
 		name: "FinalizeComputationEvent",
 		discriminator: [
@@ -5322,6 +5839,19 @@ var events = [
 			249
 		]
 	},
+	{
+		name: "FinalizeFailureDataEvent",
+		discriminator: [
+			132,
+			26,
+			138,
+			201,
+			214,
+			29,
+			244,
+			167
+		]
+	},
 	{
 		name: "InitComputationEvent",
 		discriminator: [
@@ -5352,48 +5882,258 @@ var events = [
 var errors = [
 	{
 		code: 6000,
+		name: "InvalidAuthority",
+		msg: "The given authority is invalid"
+	},
+	{
+		code: 6001,
+		name: "MxeKeysAlreadySet",
+		msg: "The MXE keys are already set, i.e. all the nodes of the MXE cluster already agreed on the MXE keys"
+	},
+	{
+		code: 6002,
+		name: "MxeKeysNotSet",
+		msg: "The MXE keys are not set, i.e. not all the nodes of the MXE cluster agreed on the MXE keys"
+	},
+	{
+		code: 6003,
+		name: "InvalidMXE",
+		msg: "An invalid MXE account has been supplied"
+	},
+	{
+		code: 6004,
+		name: "ClusterAlreadySet",
+		msg: "The cluster is already set"
+	},
+	{
+		code: 6005,
+		name: "ClusterNotSet",
+		msg: "The cluster is not set"
+	},
+	{
+		code: 6006,
+		name: "InvalidCluster",
+		msg: "An invalid cluster account has been supplied"
+	},
+	{
+		code: 6007,
+		name: "InvalidComputationDefinition",
+		msg: "An invalid computation definition account has been supplied"
+	},
+	{
+		code: 6008,
+		name: "CantFindMempoolID",
+		msg: "Couldn't find a mempool ID for the computation"
+	},
+	{
+		code: 6100,
+		name: "InvalidMempoolDiscriminator",
+		msg: "Mempool discriminator is invalid"
+	},
+	{
+		code: 6101,
+		name: "InvalidMempoolSize",
+		msg: "Mempool size is invalid"
+	},
+	{
+		code: 6102,
+		name: "InvalidExecpoolDiscriminator",
+		msg: "Execpool discriminator is invalid"
+	},
+	{
+		code: 6103,
+		name: "MaxParallelismReached",
+		msg: "Max parallelism reached"
+	},
+	{
+		code: 6200,
+		name: "InvalidComputationOffset",
+		msg: "Computation offset is invalid"
+	},
+	{
+		code: 6201,
+		name: "InvalidCallbackAccs",
+		msg: "Callback accounts are invalid"
+	},
+	{
+		code: 6202,
+		name: "InvalidCallbackAccsLen",
+		msg: "Callback accounts length is invalid"
+	},
+	{
+		code: 6203,
+		name: "AlreadyInitializedComputation",
+		msg: "The computation is already initialized"
+	},
+	{
+		code: 6204,
+		name: "AlreadyCallbackedComputation",
+		msg: "Callback computation already called"
+	},
+	{
+		code: 6205,
+		name: "InvalidCallbackTx",
+		msg: "Callback tx is invalid"
+	},
+	{
+		code: 6206,
+		name: "InvalidComputationStatus",
+		msg: "Computation status is invalid"
+	},
+	{
+		code: 6207,
+		name: "InvalidComputation",
+		msg: "Computation is invalid"
+	},
+	{
+		code: 6208,
+		name: "InvalidComputationAuthority",
+		msg: "Computation authority is invalid"
+	},
+	{
+		code: 6209,
+		name: "InvalidCallbackInstructions",
+		msg: "Callback instructions are invalid"
+	},
+	{
+		code: 6300,
+		name: "ComputationDefinitionNotCompleted",
+		msg: "Computation definition is not completed"
+	},
+	{
+		code: 6301,
+		name: "InvalidArguments",
+		msg: "Arguments supplied are invalid"
+	},
+	{
+		code: 6302,
+		name: "InvalidCircuitSource",
+		msg: "Circuit source is invalid"
+	},
+	{
+		code: 6303,
+		name: "ComputationDefinitionAlreadyCompleted",
+		msg: "Computation definition already completed"
+	},
+	{
+		code: 6400,
 		name: "InvalidNode",
 		msg: "Node is invalid"
 	},
 	{
-		code: 6001,
+		code: 6401,
 		name: "MaxClusterMembershipReached",
 		msg: "Maximum number of nodes in the cluster has been reached"
 	},
 	{
-		code: 6002,
+		code: 6402,
 		name: "NodeAlreadyExists",
 		msg: "The node already exists in the cluster"
 	},
 	{
-		code: 6003,
-		name: "InvalidAuthority",
+		code: 6403,
+		name: "InvalidNodeAuthority",
 		msg: "Node authority is invalid"
 	},
 	{
-		code: 6004,
+		code: 6404,
 		name: "NodeNotInactive",
 		msg: "Node is not inactive"
 	},
 	{
-		code: 6005,
+		code: 6405,
 		name: "NodeNotActive",
 		msg: "Node is not active"
 	},
 	{
-		code: 6006,
+		code: 6406,
 		name: "InvalidClusterMembership",
 		msg: "Cluster membership is invalid"
 	},
 	{
-		code: 6007,
+		code: 6407,
 		name: "NodeInActiveCluster",
 		msg: "Node is in an active cluster"
 	},
 	{
-		code: 6008,
-		name: "InvalidConfig",
+		code: 6408,
+		name: "InvalidNodeConfig",
 		msg: "Node config is invalid"
+	},
+	{
+		code: 6500,
+		name: "ClusterFull",
+		msg: "Cluster is full"
+	},
+	{
+		code: 6501,
+		name: "InvalidDeactivationEpoch",
+		msg: "Cluster deactivation epoch is invalid"
+	},
+	{
+		code: 6502,
+		name: "InvalidMaxSize",
+		msg: "Cluster maximum size is invalid"
+	},
+	{
+		code: 6503,
+		name: "InvalidClusterAuthority",
+		msg: "Cluster authority is invalid"
+	},
+	{
+		code: 6504,
+		name: "InvalidFeeProposal",
+		msg: "Cluster fee proposal is invalid"
+	},
+	{
+		code: 6505,
+		name: "InvalidClusterState",
+		msg: "Cluster state is invalid"
+	},
+	{
+		code: 6506,
+		name: "InvalidVote",
+		msg: "Cluster vote is invalid"
+	},
+	{
+		code: 6600,
+		name: "SerializationFailed",
+		msg: "Borsh serialization failed"
+	},
+	{
+		code: 6601,
+		name: "DeserializationFailed",
+		msg: "Borsh deserialization failed"
+	},
+	{
+		code: 6602,
+		name: "HeapFull",
+		msg: "Heap is full"
+	},
+	{
+		code: 6603,
+		name: "InvalidSlot",
+		msg: "Current slot is before the last updated slot"
+	},
+	{
+		code: 6604,
+		name: "EpochIsInfinity",
+		msg: "Epoch is infinity"
+	},
+	{
+		code: 6605,
+		name: "InvalidTimestamp",
+		msg: "Timestamp is invalid"
+	},
+	{
+		code: 6606,
+		name: "InvalidEpoch",
+		msg: "Epoch is invalid"
+	},
+	{
+		code: 6607,
+		name: "EpochOverflow",
+		msg: "Epoch overflowed"
 	}
 ];
 var types = [
@@ -5438,8 +6178,17 @@ var types = [
 				{
 					name: "PrimitiveError"
 				},
+				{
+					name: "InvalidBatchLength"
+				},
 				{
 					name: "QuadraticNonResidue"
+				},
+				{
+					name: "BitConversionError"
+				},
+				{
+					name: "ChannelClosed"
 				}
 			]
 		}
@@ -5740,20 +6489,18 @@ var types = [
 					type: "u32"
 				},
 				{
-					name: "allowed_authorities",
-					type: {
-						vec: "pubkey"
-					}
+					name: "authority",
+					docs: [
+						"Admin key for node management operations"
+					],
+					type: "pubkey"
 				},
 				{
-					name: "supported_protocols",
-					type: {
-						vec: {
-							defined: {
-								name: "MPCProtocol"
-							}
-						}
-					}
+					name: "callback_authority",
+					docs: [
+						"Key used to sign computation callbacks - separated for operational security"
+					],
+					type: "pubkey"
 				}
 			]
 		}
@@ -5794,6 +6541,35 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "CallbackInstruction",
+		docs: [
+			"A custom callback instruction with its own program ID and discriminator."
+		],
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "program_id",
+					type: "pubkey"
+				},
+				{
+					name: "discriminator",
+					type: "bytes"
+				},
+				{
+					name: "accounts",
+					type: {
+						vec: {
+							defined: {
+								name: "CallbackAccount"
+							}
+						}
+					}
+				}
+			]
+		}
+	},
 	{
 		name: "CircuitSource",
 		type: {
@@ -5832,6 +6608,22 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "ClaimFailureEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "computation_offset",
+					type: "u64"
+				},
+				{
+					name: "mxe_program_id",
+					type: "pubkey"
+				}
+			]
+		}
+	},
 	{
 		name: "ClockAccount",
 		docs: [
@@ -6041,20 +6833,28 @@ var types = [
 					}
 				},
 				{
-					name: "callback_accs",
+					name: "callback_url",
+					type: {
+						option: "string"
+					}
+				},
+				{
+					name: "custom_callback_instructions",
 					type: {
 						vec: {
 							defined: {
-								name: "CallbackAccount"
+								name: "CallbackInstruction"
 							}
 						}
 					}
 				},
 				{
-					name: "callback_url",
-					type: {
-						option: "string"
-					}
+					name: "callback_transactions_required",
+					type: "u8"
+				},
+				{
+					name: "callback_transactions_submitted_bm",
+					type: "u16"
 				},
 				{
 					name: "bump",
@@ -6080,13 +6880,6 @@ var types = [
 						option: "pubkey"
 					}
 				},
-				{
-					name: "finalize_during_callback",
-					docs: [
-						"Whether to we need a separate callback and finalize instruction or if we can do it in one."
-					],
-					type: "bool"
-				},
 				{
 					name: "cu_amount",
 					docs: [
@@ -6142,15 +6935,6 @@ var types = [
 							name: "ComputationSignature"
 						}
 					}
-				},
-				{
-					name: "callback_discriminator",
-					type: {
-						array: [
-							"u8",
-							8
-						]
-					}
 				}
 			]
 		}
@@ -6265,9 +7049,6 @@ var types = [
 				{
 					name: "Queued"
 				},
-				{
-					name: "Executed"
-				},
 				{
 					name: "Finalized"
 				}
@@ -6307,20 +7088,26 @@ var types = [
 					type: "u8"
 				},
 				{
-					name: "comp_status",
+					name: "padding",
 					type: {
 						array: [
 							"u8",
-							13
+							7
 						]
 					}
 				},
 				{
-					name: "padding",
+					name: "counter",
+					type: "u64"
+				},
+				{
+					name: "execpool_index",
 					type: {
 						array: [
-							"u8",
-							2
+							"u64",
+							{
+								generic: "MAX_PARRALLEL_COMPUTATIONS"
+							}
 						]
 					}
 				},
@@ -6397,18 +7184,10 @@ var types = [
 					],
 					type: "u64"
 				},
-				{
-					name: "input_delivery_fee",
-					docs: [
-						"A fee for data relaying used with [super::mxe::DataProvisioning::Protected] data",
-						"provisioning."
-					],
-					type: "u64"
-				},
 				{
 					name: "output_delivery_fee",
 					docs: [
-						"A fee for relayer based (unverifiable) off-chain output delivery."
+						"A fee for output delivery fees (i.e. tx fees)."
 					],
 					type: "u64"
 				}
@@ -6442,6 +7221,43 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "FailureClaimAccountHeader",
+		serialization: "bytemuckunsafe",
+		repr: {
+			kind: "c"
+		},
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "bump",
+					type: "u8"
+				},
+				{
+					name: "is_complete",
+					type: "bool"
+				},
+				{
+					name: "padding",
+					type: {
+						array: [
+							"u8",
+							6
+						]
+					}
+				},
+				{
+					name: "challenge_end_slot",
+					type: "u64"
+				},
+				{
+					name: "poster",
+					type: "pubkey"
+				}
+			]
+		}
+	},
 	{
 		name: "FeePool",
 		type: {
@@ -6470,6 +7286,22 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "FinalizeFailureDataEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "computation_offset",
+					type: "u64"
+				},
+				{
+					name: "mxe_program_id",
+					type: "pubkey"
+				}
+			]
+		}
+	},
 	{
 		name: "InitComputationEvent",
 		type: {
@@ -6677,20 +7509,6 @@ var types = [
 			]
 		}
 	},
-	{
-		name: "MPCProtocol",
-		type: {
-			kind: "enum",
-			variants: [
-				{
-					name: "CERBERUS"
-				},
-				{
-					name: "MANTICORE"
-				}
-			]
-		}
-	},
 	{
 		name: "MXEAccount",
 		docs: [
@@ -6718,13 +7536,27 @@ var types = [
 					}
 				},
 				{
-					name: "x25519_pubkey",
+					name: "utility_pubkeys",
 					docs: [
-						"The x25519 pubkey (256 bits curve25519), used for encrypted data."
+						"The utility pubkeys, consisting of",
+						"- x25519 pubkey (32 bytes), used for key exchange",
+						"- ed25519 verifying key (32 bytes), used for signature verification",
+						"- ElGamal pubkey (32 bytes), used for c-spl",
+						"- ElGamal pubkey validity proof (64 bytes), used for c-spl"
 					],
 					type: {
 						defined: {
-							name: "X25519Pubkey"
+							name: "SetUnset",
+							generics: [
+								{
+									kind: "type",
+									type: {
+										defined: {
+											name: "UtilityPubkeys"
+										}
+									}
+								}
+							]
 						}
 					}
 				},
@@ -7164,6 +7996,9 @@ var types = [
 				},
 				{
 					name: "PlaintextFloat"
+				},
+				{
+					name: "PlaintextPoint"
 				}
 			]
 		}
@@ -7235,6 +8070,39 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "SetUnset",
+		generics: [
+			{
+				kind: "type",
+				name: "T"
+			}
+		],
+		type: {
+			kind: "enum",
+			variants: [
+				{
+					name: "Set",
+					fields: [
+						{
+							generic: "T"
+						}
+					]
+				},
+				{
+					name: "Unset",
+					fields: [
+						{
+							generic: "T"
+						},
+						{
+							vec: "bool"
+						}
+					]
+				}
+			]
+		}
+	},
 	{
 		name: "SmallExecPool",
 		serialization: "bytemuckunsafe",
@@ -7608,34 +8476,45 @@ var types = [
 		}
 	},
 	{
-		name: "X25519Pubkey",
+		name: "UtilityPubkeys",
 		type: {
-			kind: "enum",
-			variants: [
+			kind: "struct",
+			fields: [
 				{
-					name: "Set",
-					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						}
-					]
+					name: "x25519_pubkey",
+					type: {
+						array: [
+							"u8",
+							32
+						]
+					}
 				},
 				{
-					name: "Unset",
-					fields: [
-						{
-							array: [
-								"u8",
-								32
-							]
-						},
-						{
-							vec: "bool"
-						}
-					]
+					name: "ed25519_verifying_key",
+					type: {
+						array: [
+							"u8",
+							32
+						]
+					}
+				},
+				{
+					name: "elgamal_pubkey",
+					type: {
+						array: [
+							"u8",
+							32
+						]
+					}
+				},
+				{
+					name: "pubkey_validity_proof",
+					type: {
+						array: [
+							"u8",
+							64
+						]
+					}
 				}
 			]
 		}
@@ -7674,10 +8553,10 @@ const ARCIUM_ADDR = address;
  */
 const CLOCK_ACC_SEED = 'ClockAccount';
 /**
- * Seed for StakingPoolAccount PDA
+ * Seed for FeePool PDA
  * @constant {string}
  */
-const POOL_ACC_SEED = 'StakingPoolAccount';
+const POOL_ACC_SEED = 'FeePool';
 /**
  * Seed for ComputationAccount PDA
  * @constant {string}
@@ -7739,7 +8618,7 @@ const MAX_EMBIGGEN_IX_PER_TX = 18;
  * @returns The Arcium program's public key.
  */
 function getArciumProgramId() {
-    return new web3_js.PublicKey('BKck65TgoKRokMjQM3datB9oRwJ8rAj2jxPXvHXUvcL6');
+    return new web3_js.PublicKey('Bv3Fb9VjzjWGfX18QTUcVycAfeLoQ5zZN6vv2g3cTZxp');
 }
 /**
  * Derives the computation account address for a given MXE program ID and offset.
@@ -7770,10 +8649,10 @@ function getExecutingPoolAccAddress(mxeProgramId) {
     return generateArciumPDAFrom(seeds)[0];
 }
 /**
- * Derives the staking pool account address.
- * @returns The derived staking pool account public key.
+ * Derives the fee pool account address.
+ * @returns The derived fee pool account public key.
  */
-function getStakingPoolAccAddress() {
+function getFeePoolAccAddress() {
     const seeds = [Buffer.from(POOL_ACC_SEED)];
     return generateArciumPDAFrom(seeds)[0];
 }
@@ -7995,14 +8874,36 @@ 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.x25519Pubkey) {
-        const setData = mxeAccInfo.x25519Pubkey.set;
-        return new Uint8Array([...setData[0]]);
+    if ('set' in mxeAccInfo.utilityPubkeys) {
+        const setData = mxeAccInfo.utilityPubkeys.set;
+        return new Uint8Array(setData[0].x25519Pubkey);
+    }
+    else if ('unset' in mxeAccInfo.utilityPubkeys) {
+        const unsetData = mxeAccInfo.utilityPubkeys.unset;
+        if (unsetData[1].every(Boolean)) {
+            return new Uint8Array(unsetData[0].x25519Pubkey);
+        }
+    }
+    return null;
+}
+/**
+ * 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) {
+    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].ed25519VerifyingKey);
     }
-    else if ('unset' in mxeAccInfo.x25519Pubkey) {
-        const unsetData = mxeAccInfo.x25519Pubkey.unset;
+    else if ('unset' in mxeAccInfo.utilityPubkeys) {
+        const unsetData = mxeAccInfo.utilityPubkeys.unset;
         if (unsetData[1].every(Boolean)) {
-            return new Uint8Array([...unsetData[0]]);
+            return new Uint8Array(unsetData[0].ed25519VerifyingKey);
         }
     }
     return null;
@@ -8300,11 +9201,12 @@ exports.getCompDefAccOffset = getCompDefAccOffset;
 exports.getComputationAccAddress = getComputationAccAddress;
 exports.getExecutingPoolAccAddress = getExecutingPoolAccAddress;
 exports.getExecutingPoolAccData = getExecutingPoolAccData;
+exports.getFeePoolAccAddress = getFeePoolAccAddress;
 exports.getMXEAccAddress = getMXEAccAddress;
+exports.getMXEArcisEd25519VerifyingKey = getMXEArcisEd25519VerifyingKey;
 exports.getMXEPublicKey = getMXEPublicKey;
 exports.getMempoolAccAddress = getMempoolAccAddress;
 exports.getMempoolAccData = getMempoolAccData;
-exports.getStakingPoolAccAddress = getStakingPoolAccAddress;
 exports.positiveModulo = positiveModulo;
 exports.randMatrix = randMatrix;
 exports.serializeLE = serializeLE;