@arcium-hq/client 0.10.3 → 0.11.0

package/build/index.cjs

@@ -1883,7 +1883,7 @@ function createPacker(fields, typeName = 'Packer') {
 var address = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
 var metadata = {
 	name: "arcium",
-	version: "0.10.3",
+	version: "0.11.0",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -2174,6 +2174,84 @@ var instructions = [
 			}
 		]
 	},
+	{
+		name: "bind_recovery_peer_migration",
+		discriminator: [
+			30,
+			148,
+			4,
+			206,
+			139,
+			2,
+			55,
+			156
+		],
+		accounts: [
+			{
+				name: "authority",
+				docs: [
+					"The recovery peer's `authority` — same dual role as in `MigrateArxNode`: it authorizes the",
+					"bind and is the owner of `primary_stake_account`."
+				],
+				signer: true
+			},
+			{
+				name: "recovery_peer_account",
+				docs: [
+					"Must already be layout-migrated (`migrate_recovery_peer`) so the appended",
+					"`primary_stake_account` field exists; otherwise the zero-copy load fails on the short",
+					"account. Bundle `migrate_recovery_peer` ahead of this instruction in the same transaction."
+				],
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								82,
+								101,
+								99,
+								111,
+								118,
+								101,
+								114,
+								121,
+								80,
+								101,
+								101,
+								114,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						},
+						{
+							kind: "arg",
+							path: "peer_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "primary_stake_account",
+				writable: true
+			},
+			{
+				name: "arcium_staking_program",
+				address: "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq"
+			}
+		],
+		args: [
+			{
+				name: "peer_offset",
+				type: "u32"
+			}
+		]
+	},
 	{
 		name: "bump_epoch_cluster",
 		discriminator: [
@@ -2287,6 +2365,7 @@ var instructions = [
 			},
 			{
 				name: "mxe",
+				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -2824,6 +2903,7 @@ var instructions = [
 			},
 			{
 				name: "mxe",
+				writable: true,
 				pda: {
 					seeds: [
 						{
@@ -3153,13 +3233,88 @@ var instructions = [
 		],
 		accounts: [
 			{
-				name: "node_authority",
+				name: "staking_pool_signer",
+				docs: [
+					"The `arcium_staking::state::StakingPoolAccount` PDA, signing via CPI. Also the destination",
+					"for the settled lamports (so the staking program immediately owns them for later",
+					"proportional distribution). The `seeds`/`bump` constraint verifies it's the canonical pool",
+					"PDA under `ARCIUM_STAKING_ID` (so only the staking program can call this); `Signer`",
+					"enforces it actually signed."
+				],
 				writable: true,
-				signer: true
+				signer: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								83,
+								116,
+								97,
+								107,
+								105,
+								110,
+								103,
+								80,
+								111,
+								111,
+								108,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						}
+					],
+					program: {
+						kind: "const",
+						value: [
+							146,
+							110,
+							184,
+							172,
+							179,
+							131,
+							118,
+							35,
+							207,
+							122,
+							30,
+							190,
+							228,
+							134,
+							232,
+							140,
+							222,
+							89,
+							53,
+							150,
+							174,
+							187,
+							151,
+							58,
+							208,
+							108,
+							237,
+							119,
+							97,
+							204,
+							184,
+							186
+						]
+					}
+				}
 			},
 			{
-				name: "recipient",
-				writable: true
+				name: "primary_stake_account",
+				docs: [
+					"The `PrimaryStakingAccount` bound to this node. Passed so the handler can verify",
+					"`node.primary_staking_account == primary_stake_account.key()` — i.e. the staking account",
+					"that's about to claim the fees is the one this node was initialized with."
+				]
 			},
 			{
 				name: "cluster",
@@ -3238,7 +3393,197 @@ var instructions = [
 				name: "node_offset",
 				type: "u32"
 			}
-		]
+		],
+		returns: "u64"
+	},
+	{
+		name: "claim_recovery_peer_fees",
+		discriminator: [
+			132,
+			120,
+			187,
+			164,
+			106,
+			57,
+			202,
+			8
+		],
+		accounts: [
+			{
+				name: "staking_pool_signer",
+				docs: [
+					"`arcium_staking::StakingPoolAccount` PDA, signing via CPI and receiving the drained",
+					"lamports. The `seeds`/`bump` constraint verifies it's the canonical pool PDA under",
+					"`ARCIUM_STAKING_ID`; `Signer` enforces `is_signer`."
+				],
+				writable: true,
+				signer: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								83,
+								116,
+								97,
+								107,
+								105,
+								110,
+								103,
+								80,
+								111,
+								111,
+								108,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						}
+					],
+					program: {
+						kind: "const",
+						value: [
+							146,
+							110,
+							184,
+							172,
+							179,
+							131,
+							118,
+							35,
+							207,
+							122,
+							30,
+							190,
+							228,
+							134,
+							232,
+							140,
+							222,
+							89,
+							53,
+							150,
+							174,
+							187,
+							151,
+							58,
+							208,
+							108,
+							237,
+							119,
+							97,
+							204,
+							184,
+							186
+						]
+					}
+				}
+			},
+			{
+				name: "primary_stake_account",
+				docs: [
+					"`PrimaryStakingAccount` the claiming peer is bound to. Only the key is compared",
+					"against `recovery_peer.primary_stake_account`; the staking program owns the struct."
+				]
+			},
+			{
+				name: "recovery_peer",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								82,
+								101,
+								99,
+								111,
+								118,
+								101,
+								114,
+								121,
+								80,
+								101,
+								101,
+								114,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						},
+						{
+							kind: "arg",
+							path: "peer_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "mxe",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								77,
+								88,
+								69,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						},
+						{
+							kind: "arg",
+							path: "mxe_program"
+						}
+					]
+				}
+			},
+			{
+				name: "pool",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								70,
+								101,
+								101,
+								80,
+								111,
+								111,
+								108
+							]
+						}
+					]
+				}
+			}
+		],
+		args: [
+			{
+				name: "mxe_program",
+				type: "pubkey"
+			},
+			{
+				name: "peer_offset",
+				type: "u32"
+			}
+		],
+		returns: "u64"
 	},
 	{
 		name: "close_computation_definition",
@@ -4543,8 +4888,16 @@ var instructions = [
 			{
 				name: "large_execpool"
 			}
-		],
-		args: [
+		],
+		args: [
+			{
+				name: "_selector",
+				type: {
+					defined: {
+						name: "LeaderSelector"
+					}
+				}
+			}
 		]
 	},
 	{
@@ -6156,6 +6509,31 @@ var instructions = [
 					]
 				}
 			},
+			{
+				name: "primary_stake_account",
+				docs: [
+					"The `PrimaryStakingAccount` (owned by the `arcium_staking` program) that this node will be",
+					"bound to for the rest of its life. Reward settlement requires this linkage: fees accrued",
+					"under this node can only be drained via a CPI signed by the staking program's pool PDA",
+					"after matching on this key.",
+					"the staking program's responsibility — if the staker binds garbage they lock themselves",
+					"out of rewards, which is their own problem."
+				],
+				writable: true
+			},
+			{
+				name: "staker",
+				docs: [
+					"Authority of `primary_stake_account`. Required as a second signer so we can CPI into",
+					"`arcium_staking::bind_primary_stake` and commit the stake to this node. The staking",
+					"program re-derives the stake PDA from this key and rejects the call if it mismatches."
+				],
+				signer: true
+			},
+			{
+				name: "arcium_staking_program",
+				address: "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq"
+			},
 			{
 				name: "system_program",
 				address: "11111111111111111111111111111111"
@@ -7023,6 +7401,15 @@ var instructions = [
 			}
 		],
 		args: [
+			{
+				name: "recovery_peers",
+				type: {
+					array: [
+						"u32",
+						100
+					]
+				}
+			}
 		]
 	},
 	{
@@ -7137,8 +7524,8 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "_mxe_program"
+							kind: "account",
+							path: "mxe_program"
 						}
 					]
 				}
@@ -7438,6 +7825,17 @@ var instructions = [
 					]
 				}
 			},
+			{
+				name: "instructions_sysvar",
+				docs: [
+					"Instructions sysvar — used in the handler to verify the **next** instruction in this",
+					"transaction is `arcium_staking::init_mxe_recovery_stake_state` with the same",
+					"`mxe_program`. This mirrors the reverse check on the staking side and is what",
+					"guarantees that every MXE is created alongside its recovery stake state (replacement",
+					"for the CPI we couldn't do because of the 4KB stack limit on `try_accounts`)."
+				],
+				address: "Sysvar1nstructions1111111111111111111111111"
+			},
 			{
 				name: "system_program",
 				address: "11111111111111111111111111111111"
@@ -7448,19 +7846,6 @@ var instructions = [
 				name: "cluster_offset",
 				type: "u32"
 			},
-			{
-				name: "mxe_program",
-				type: "pubkey"
-			},
-			{
-				name: "recovery_peers",
-				type: {
-					array: [
-						"u32",
-						100
-					]
-				}
-			},
 			{
 				name: "keygen_offset",
 				type: "u64"
@@ -7918,6 +8303,31 @@ var instructions = [
 					]
 				}
 			},
+			{
+				name: "primary_stake_account",
+				docs: [
+					"The `PrimaryStakingAccount` (owned by `arcium_staking`) that the recovery peer is",
+					"binding itself to. Mirrors the stake-first requirement on `InitArxNode`: every",
+					"recovery peer has to point at a real staking account so we have someone to slash",
+					"(or dock rewards from) if the peer misbehaves. Full account-structure validation",
+					"is the staking program's job — here we just make sure the account is owned by it.",
+					"point at any primary stake account they have authority over."
+				],
+				writable: true
+			},
+			{
+				name: "staker",
+				docs: [
+					"Authority of `primary_stake_account`. Required as a second signer so we can CPI into",
+					"`arcium_staking::bind_primary_stake` and commit the stake to this recovery peer. The",
+					"staking program re-derives the stake PDA from this key and rejects on mismatch."
+				],
+				signer: true
+			},
+			{
+				name: "arcium_staking_program",
+				address: "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq"
+			},
 			{
 				name: "system_program",
 				address: "11111111111111111111111111111111"
@@ -8054,6 +8464,171 @@ var instructions = [
 			}
 		]
 	},
+	{
+		name: "migrate_arx_node",
+		discriminator: [
+			26,
+			223,
+			103,
+			52,
+			241,
+			117,
+			229,
+			143
+		],
+		accounts: [
+			{
+				name: "authority",
+				docs: [
+					"The node's `config.authority`, which both *authorizes* the bind (only the node's own admin",
+					"may link a stake account to it — otherwise anyone could divert a node's rewards to their",
+					"own stake) and doubles as the `staker` (owner of `primary_stake_account`) for the CPI."
+				],
+				signer: true
+			},
+			{
+				name: "arx_node_acc",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								65,
+								114,
+								120,
+								78,
+								111,
+								100,
+								101
+							]
+						},
+						{
+							kind: "arg",
+							path: "node_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "primary_stake_account",
+				docs: [
+					"The `PrimaryStakingAccount` (created beforehand via",
+					"`arcium_staking::add_primary_stake_to_legacy_acc`) to bind. Owner-checked here; the staking",
+					"program re-derives `[SEED, authority]` and rejects a mismatch during the bind CPI."
+				],
+				writable: true
+			},
+			{
+				name: "arcium_staking_program",
+				address: "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq"
+			}
+		],
+		args: [
+			{
+				name: "node_offset",
+				type: "u32"
+			}
+		]
+	},
+	{
+		name: "migrate_cluster",
+		docs: [
+			"One-shot layout migrations for the staking upgrade. Each grows one already-deployed",
+			"account to the current (append-only) layout; idempotent and permissionless. See",
+			"`instructions::migration`."
+		],
+		discriminator: [
+			158,
+			61,
+			104,
+			161,
+			253,
+			138,
+			0,
+			17
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "cluster",
+				docs: [
+					"because the new program cannot deserialize the old (short) layout via `Account<Cluster>`."
+				],
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "migrate_mxe_account",
+		discriminator: [
+			96,
+			162,
+			117,
+			100,
+			242,
+			143,
+			16,
+			80
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "mxe",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "migrate_recovery_peer",
+		discriminator: [
+			58,
+			226,
+			37,
+			60,
+			200,
+			31,
+			251,
+			245
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "recovery_peer",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+		]
+	},
 	{
 		name: "propose_fee",
 		discriminator: [
@@ -8272,7 +8847,12 @@ var instructions = [
 		docs: [
 			"Queues a computation.",
 			"cu_price_micro: The priority price of a CU, in micro-lamports. Used",
-			"to calculate the priority fee and rounded down."
+			"to calculate the priority fee and rounded down.",
+			"callback_cu_limit: The compute unit limit to request for the callback transaction(s)",
+			"via set_compute_unit_limit. 0 means unset (the node uses the default compute budget).",
+			"A non-zero value incurs an additional priority fee of callback_cu_limit * cu_price_micro.",
+			"callback_cu_limit + padding together occupy the 8 bytes that previously held the",
+			"(always-zero) output_delivery_fee: u64, so the instruction layout is unchanged."
 		],
 		discriminator: [
 			1,
@@ -8605,8 +9185,12 @@ var instructions = [
 				type: "u8"
 			},
 			{
-				name: "output_delivery_fee",
-				type: "u64"
+				name: "callback_cu_limit",
+				type: "u32"
+			},
+			{
+				name: "padding",
+				type: "u32"
 			},
 			{
 				name: "cu_price_micro",
@@ -9883,7 +10467,63 @@ var instructions = [
 		],
 		accounts: [
 			{
-				name: "current_authority",
+				name: "current_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"
+						}
+					]
+				}
+			}
+		],
+		args: [
+			{
+				name: "cluster_id",
+				type: "u32"
+			},
+			{
+				name: "new_authority",
+				type: {
+					option: "pubkey"
+				}
+			}
+		]
+	},
+	{
+		name: "set_cluster_td_info",
+		discriminator: [
+			182,
+			126,
+			92,
+			101,
+			25,
+			252,
+			84,
+			180
+		],
+		accounts: [
+			{
+				name: "authority",
 				writable: true,
 				signer: true
 			},
@@ -9918,28 +10558,32 @@ var instructions = [
 				type: "u32"
 			},
 			{
-				name: "new_authority",
+				name: "td_info",
 				type: {
-					option: "pubkey"
+					option: {
+						defined: {
+							name: "NodeMetadata"
+						}
+					}
 				}
 			}
 		]
 	},
 	{
-		name: "set_cluster_td_info",
+		name: "set_leader_choice",
 		discriminator: [
-			182,
-			126,
-			92,
-			101,
-			25,
-			252,
-			84,
-			180
+			42,
+			7,
+			112,
+			255,
+			254,
+			186,
+			135,
+			133
 		],
 		accounts: [
 			{
-				name: "authority",
+				name: "node_authority",
 				writable: true,
 				signer: true
 			},
@@ -9962,7 +10606,53 @@ var instructions = [
 						},
 						{
 							kind: "arg",
-							path: "_id"
+							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: "mempool",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								77,
+								101,
+								109,
+								112,
+								111,
+								111,
+								108
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
 						}
 					]
 				}
@@ -9970,16 +10660,18 @@ var instructions = [
 		],
 		args: [
 			{
-				name: "cluster_id",
+				name: "cluster_offset",
 				type: "u32"
 			},
 			{
-				name: "td_info",
+				name: "node_offset",
+				type: "u32"
+			},
+			{
+				name: "choice",
 				type: {
-					option: {
-						defined: {
-							name: "NodeMetadata"
-						}
+					defined: {
+						name: "LeaderChoice"
 					}
 				}
 			}
@@ -10311,6 +11003,156 @@ var instructions = [
 			}
 		]
 	},
+	{
+		name: "set_node_staking",
+		discriminator: [
+			158,
+			40,
+			109,
+			244,
+			217,
+			195,
+			35,
+			140
+		],
+		accounts: [
+			{
+				name: "staking_pool_signer",
+				docs: [
+					"The `arcium_staking::state::StakingPoolAccount` PDA, signing via CPI. The `seeds`/`bump`",
+					"constraint verifies it's the canonical pool PDA under `ARCIUM_STAKING_ID` (so only the",
+					"staking program can call this)"
+				],
+				signer: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								83,
+								116,
+								97,
+								107,
+								105,
+								110,
+								103,
+								80,
+								111,
+								111,
+								108,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						}
+					],
+					program: {
+						kind: "const",
+						value: [
+							146,
+							110,
+							184,
+							172,
+							179,
+							131,
+							118,
+							35,
+							207,
+							122,
+							30,
+							190,
+							228,
+							134,
+							232,
+							140,
+							222,
+							89,
+							53,
+							150,
+							174,
+							187,
+							151,
+							58,
+							208,
+							108,
+							237,
+							119,
+							97,
+							204,
+							184,
+							186
+						]
+					}
+				}
+			},
+			{
+				name: "cluster",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "clock",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								111,
+								99,
+								107,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						}
+					]
+				}
+			}
+		],
+		args: [
+			{
+				name: "cluster_offset",
+				type: "u32"
+			},
+			{
+				name: "node_offset",
+				type: "u32"
+			},
+			{
+				name: "stake",
+				type: "u64"
+			}
+		]
+	},
 	{
 		name: "submit_aggregated_bls_pubkey",
 		discriminator: [
@@ -11640,6 +12482,11 @@ var errors = [
 		name: "MaxParallelismReached",
 		msg: "Max parallelism reached"
 	},
+	{
+		code: 6104,
+		name: "MempoolAlreadyFullSize",
+		msg: "Mempool is already at its full allocated size"
+	},
 	{
 		code: 6200,
 		name: "InvalidComputationOffset",
@@ -11815,6 +12662,16 @@ var errors = [
 		name: "InvalidNodeOffset",
 		msg: "Node offset is invalid"
 	},
+	{
+		code: 6411,
+		name: "InvalidStakingPoolSigner",
+		msg: "The provided staking pool signer is not the staking program's StakingPoolAccount PDA"
+	},
+	{
+		code: 6412,
+		name: "InvalidStakingAccount",
+		msg: "The provided primary stake account is not owned by the staking program or does not match the node's bound staking account"
+	},
 	{
 		code: 6500,
 		name: "ClusterFull",
@@ -11873,7 +12730,7 @@ var errors = [
 	{
 		code: 6602,
 		name: "HeapFull",
-		msg: "Heap is full"
+		msg: "Mempool capacity for the current slot reached - retry next slot or reduce queue rate"
 	},
 	{
 		code: 6603,
@@ -11990,6 +12847,11 @@ var errors = [
 		name: "RecoveryInitAlreadyInitialized",
 		msg: "Recovery already initialized"
 	},
+	{
+		code: 6626,
+		name: "InvalidSubsequentIx",
+		msg: "Subsequent instruction in this transaction is not the expected one"
+	},
 	{
 		code: 6700,
 		name: "MxeNotInMigrationState",
@@ -12114,6 +12976,11 @@ var errors = [
 		code: 6725,
 		name: "CannotCloseMxeDuringMigration",
 		msg: "MXE is in migration state, cannot close MXE"
+	},
+	{
+		code: 6726,
+		name: "InvalidMigrationAccount",
+		msg: "Account is not a valid target for this migration (wrong owner or discriminator)"
 	}
 ];
 var types = [
@@ -12914,30 +13781,71 @@ var types = [
 					}
 				},
 				{
-					name: "bls_public_key",
+					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",
+					docs: [
+						"PDA bump. Declared by hand rather than via the `#[bump]` macro (which appends the bump",
+						"as the *final* struct field) so it keeps its original offset right after",
+						"`bls_public_key`. Everything below is appended *after* the bump, which means the byte",
+						"layout of every field up to and including `bump` is identical to the pre-staking",
+						"`Cluster` — old deserializers (including external user programs that read this account)",
+						"decode the original prefix and harmlessly ignore the trailing staking fields."
+					],
+					type: "u8"
+				},
+				{
+					name: "current_epoch_total_rewards",
+					docs: [
+						"Running total of computation rewards accrued during `rewards_epoch`. Drained to zero",
+						"by `claim_node_fees` when nodes settle via `finalize_epoch_rewards`."
+					],
+					type: "u64"
+				},
+				{
+					name: "rewards_epoch",
+					docs: [
+						"The epoch that `current_epoch_total_rewards` belongs to. If the clock has advanced",
+						"past this epoch and `current_epoch_total_rewards > 0`, the rewards are stale",
+						"(nodes didn't settle in time) — new accruals are silently skipped until nodes",
+						"finalize, which punishes lazy operators."
+					],
+					type: {
+						defined: {
+							name: "Epoch"
+						}
+					}
+				},
+				{
+					name: "leader_selector",
 					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"
+						"The selector for leader."
 					],
 					type: {
 						defined: {
-							name: "SetUnset",
-							generics: [
-								{
-									kind: "type",
-									type: {
-										defined: {
-											name: "BN254G2BLSPublicKey"
-										}
-									}
-								}
-							]
+							name: "LeaderSelector"
 						}
 					}
-				},
-				{
-					name: "bump",
-					type: "u8"
 				}
 			]
 		}
@@ -13471,16 +14379,28 @@ var types = [
 				{
 					name: "priority_fee",
 					docs: [
-						"The additional fee to enforce priortized execution in the mempool."
+						"The additional fee to enforce prioritized execution in the mempool."
 					],
 					type: "u64"
 				},
 				{
-					name: "output_delivery_fee",
+					name: "callback_cu_limit",
 					docs: [
-						"A fee for output delivery fees (i.e. tx fees)."
+						"The compute unit limit to request for the callback transaction(s), i.e. how many CUs the",
+						"node should request via set_compute_unit_limit. 0 means unset, in which case the node uses",
+						"the default compute budget.",
+						"",
+						"This reuses the low 4 bytes of what was previously `output_delivery_fee: u64` (which was",
+						"always 0), so the serialized layout of ExecutionFee is unchanged."
 					],
-					type: "u64"
+					type: "u32"
+				},
+				{
+					name: "padding",
+					docs: [
+						"Padding preserving the original 8-byte (u64) layout of the former `output_delivery_fee`."
+					],
+					type: "u32"
 				}
 			]
 		}
@@ -13846,6 +14766,113 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "LeaderChoice",
+		docs: [
+			"The computation chosen by a node to be executed when the node is leader."
+		],
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "offset",
+					docs: [
+						"Computation_offset of the chosen computation."
+					],
+					type: "u64"
+				},
+				{
+					name: "slot_idx",
+					docs: [
+						"The index of the max_heap the computation is in inside the MemPool's Circular Buffer.",
+						"This is the physical index, not the logical one."
+					],
+					type: "u16"
+				}
+			]
+		}
+	},
+	{
+		name: "LeaderInfo",
+		docs: [
+			"The information about a node."
+		],
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "stake",
+					docs: [
+						"The node's stake."
+					],
+					type: "u64"
+				},
+				{
+					name: "count",
+					docs: [
+						"The number + 1 of times the node has been chosen as leader in this cycle.",
+						"0 if the stake is unset.",
+						"This way works well for performance."
+					],
+					type: "u64"
+				},
+				{
+					name: "last_counter_plus_one",
+					docs: [
+						"The last time the node has been chosen as leader."
+					],
+					type: "u64"
+				},
+				{
+					name: "choice",
+					docs: [
+						"The choice of that node."
+					],
+					type: {
+						defined: {
+							name: "LeaderChoice"
+						}
+					}
+				}
+			]
+		}
+	},
+	{
+		name: "LeaderSelector",
+		docs: [
+			"To select a Leader.",
+			"Uses the greatest divisors method: https://en.wikipedia.org/wiki/D%27Hondt_method"
+		],
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "staking_epoch",
+					docs: [
+						"The last epoch the staking was set."
+					],
+					type: {
+						defined: {
+							name: "Epoch"
+						}
+					}
+				},
+				{
+					name: "info",
+					docs: [
+						"The information about each node."
+					],
+					type: {
+						vec: {
+							defined: {
+								name: "LeaderInfo"
+							}
+						}
+					}
+				}
+			]
+		}
+	},
 	{
 		name: "LocalCircuitSource",
 		type: {
@@ -13970,7 +14997,40 @@ var types = [
 				},
 				{
 					name: "bump",
+					docs: [
+						"PDA bump. Declared by hand rather than via the `#[bump]` macro (which appends the bump",
+						"as the *final* struct field) so it keeps its original offset right after `status`.",
+						"The recovery-reward fields below are appended *after* the bump, leaving the byte layout",
+						"of every field up to and including `bump` identical to the pre-staking `MXEAccount` —",
+						"old deserializers (including external user programs) decode the original prefix and",
+						"harmlessly ignore the trailing fields."
+					],
 					type: "u8"
+				},
+				{
+					name: "current_epoch_recovery_rewards",
+					docs: [
+						"Running total of recovery-peer rewards accrued during `recovery_rewards_epoch`.",
+						"Fed by the 20% slice of every computation/failure fee processed on this MXE;",
+						"drained to zero by `claim_recovery_peer_fees` when recovery peers settle via",
+						"`arcium_staking::finalize_recovery_epoch_rewards`. Same stale-epoch guard as",
+						"`Cluster::current_epoch_total_rewards` — if peers don't settle before the epoch",
+						"rolls over, new accruals are silently skipped until the pot is drained."
+					],
+					type: "u64"
+				},
+				{
+					name: "recovery_rewards_epoch",
+					docs: [
+						"Epoch that `current_epoch_recovery_rewards` is attributed to. Compared against the",
+						"executing cluster's `last_updated_epoch` (the same proxy used by cluster rewards) to",
+						"decide whether a new accrual is for the current round or a stale one."
+					],
+					type: {
+						defined: {
+							name: "Epoch"
+						}
+					}
 				}
 			]
 		}
@@ -14305,9 +15365,7 @@ var types = [
 		name: "NodeRef",
 		docs: [
 			"A reference to a node in the cluster.",
-			"The offset is to derive the Node Account.",
-			"The current_total_rewards is the total rewards the node has received so far in the current",
-			"epoch."
+			"The offset is to derive the Node Account."
 		],
 		type: {
 			kind: "struct",
@@ -14317,11 +15375,22 @@ var types = [
 					type: "u32"
 				},
 				{
-					name: "current_total_rewards",
+					name: "_padding",
 					docs: [
-						"Current total rewards the node has received in the current epoch in lamports."
+						"Reserved padding occupying the 8 bytes that previously held `current_total_rewards: u64`",
+						"(per-node reward tracking, now superseded by the cluster-level",
+						"`current_epoch_total_rewards`). We keep these bytes rather than shrinking `NodeRef`",
+						"because `nodes: Vec<NodeRef>` sits in the *middle* of the `Cluster` struct: removing the",
+						"field would change the encoded element size and desync the borsh decode of every field",
+						"after `nodes` for already-deployed accounts and external deserializers. Do not repurpose",
+						"without a full account migration."
 					],
-					type: "u64"
+					type: {
+						array: [
+							"u8",
+							8
+						]
+					}
 				},
 				{
 					name: "vote",
@@ -14759,7 +15828,27 @@ var types = [
 				},
 				{
 					name: "bump",
+					docs: [
+						"PDA bump. Declared by hand rather than via the `#[bump]` macro (which appends the bump",
+						"as the *final* struct field) so it keeps its original offset (76) right after",
+						"`peer_offset`. `primary_stake_account` is appended *after* the bump, leaving the byte",
+						"layout of every field up to and including `bump` identical to the pre-staking",
+						"`RecoveryPeerAccount` — old deserializers decode the original prefix and harmlessly",
+						"ignore the trailing field."
+					],
 					type: "u8"
+				},
+				{
+					name: "primary_stake_account",
+					docs: [
+						"The `PrimaryStakingAccount` (owned by `arcium_staking`) this recovery peer is bound",
+						"to. Enforced at init time via an owner check so every recovery peer has skin in the",
+						"game — the same stake-first model we already apply to `ArxNode`. Stored here so",
+						"downstream instructions (and off-chain consumers) can look up the backing stake",
+						"without re-validating the chain of accounts. Appended after `bump` to preserve the",
+						"legacy on-chain layout (see the `bump` field comment)."
+					],
+					type: "pubkey"
 				}
 			]
 		}
@@ -15308,6 +16397,26 @@ const MXE_RECOVERY_ACC_SEED = 'MxeRecoveryAccount';
  * @constant {string}
  */
 const RAW_CIRCUIT_ACC_SEED = 'ComputationDefinitionRaw';
+/**
+ * Seed for RecoveryPeerAccount PDA.
+ * @constant {string}
+ */
+const RECOVERY_PEER_ACC_SEED = 'RecoveryPeerAccount';
+/**
+ * Seed for Operator PDA.
+ * @constant {string}
+ */
+const OPERATOR_ACC_SEED = 'Operator';
+/**
+ * Seed for FailureClaimAccountHeader PDA.
+ * @constant {string}
+ */
+const FAILURE_CLAIM_ACC_SEED = 'FailureClaimAccountHeader';
+/**
+ * Seed for ArciumSignerAccount PDA.
+ * @constant {string}
+ */
+const ARCIUM_SIGNER_ACC_SEED = 'ArciumSignerAccount';
 /**
  * Maximum number of bytes that can be reallocated per instruction.
  * @constant {number}
@@ -15328,11 +16437,36 @@ const MAX_ACCOUNT_SIZE = 10485760;
  * @constant {number}
  */
 const MAX_EMBIGGEN_IX_PER_TX = 18;
+/**
+ * Default number of upload transactions sent in parallel.
+ * @constant {number}
+ */
+const DEFAULT_UPLOAD_TX_BATCH_SIZE = 500;
 /**
  * Size of account discriminator in bytes.
  * @constant {number}
  */
 const DISCRIMINATOR_SIZE = 8;
+/**
+ * Size of the bump field in a ComputationDefinitionRaw account.
+ * @constant {number}
+ */
+const RAW_CIRCUIT_ACCOUNT_BUMP_SIZE = 1;
+/**
+ * Size of ComputationDefinitionRaw account metadata before circuit bytes.
+ * @constant {number}
+ */
+const RAW_CIRCUIT_ACCOUNT_HEADER_SIZE = DISCRIMINATOR_SIZE + RAW_CIRCUIT_ACCOUNT_BUMP_SIZE;
+/**
+ * Maximum circuit bytes that fit in one ComputationDefinitionRaw account.
+ * @constant {number}
+ */
+const MAX_RAW_CIRCUIT_BYTES_PER_ACC = MAX_ACCOUNT_SIZE - RAW_CIRCUIT_ACCOUNT_HEADER_SIZE;
+/**
+ * Maximum number of raw circuit accounts addressable by the u8 raw circuit index.
+ * @constant {number}
+ */
+const MAX_RAW_CIRCUIT_ACCOUNTS = 256;
 /**
  * Size of offset buffer in bytes (u32).
  * @constant {number}
@@ -15343,7 +16477,20 @@ const OFFSET_BUFFER_SIZE = 4;
  * @constant {number}
  */
 const COMP_DEF_OFFSET_SIZE = 4;
+/**
+ * Maximum recovery peer slots supported by key recovery accounts.
+ * @constant {number}
+ */
+const MAX_RECOVERY_PEERS = 100;
+/**
+ * Minimum recovery peers required for key recovery.
+ * @constant {number}
+ */
+const MIN_RECOVERY_PEERS = 4;
 
+const U64_SEED_SIZE = 8;
+const MAX_U8 = 0xff;
+const MAX_U32$1 = 0xffffffff;
 /**
  * Return the public key of the deployed Arcium program on Solana.
  * @returns Arcium program's public key.
@@ -15358,10 +16505,7 @@ function getArciumProgramId() {
  * @returns Derived computation account public key.
  */
 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];
+    return findArciumPda([stringSeed(COMPUTATION_ACC_SEED), u32Seed(clusterOffset), u64Seed(computationOffset)]);
 }
 /**
  * Derive the mempool account address for a given cluster.
@@ -15369,10 +16513,7 @@ function getComputationAccAddress(clusterOffset, computationOffset) {
  * @returns Derived mempool account public key.
  */
 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];
+    return findArciumPda([stringSeed(MEMPOOL_ACC_SEED), u32Seed(clusterOffset)]);
 }
 /**
  * Derive the executing pool account address for a given cluster.
@@ -15380,26 +16521,21 @@ function getMempoolAccAddress(clusterOffset) {
  * @returns Derived executing pool account public key.
  */
 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];
+    return findArciumPda([stringSeed(EXEC_POOL_ACC_SEED), u32Seed(clusterOffset)]);
 }
 /**
  * Derive the fee pool account address.
  * @returns Derived fee pool account public key.
  */
 function getFeePoolAccAddress() {
-    const seeds = [Buffer.from(POOL_ACC_SEED)];
-    return generateArciumPDAFrom(seeds)[0];
+    return findArciumPda([stringSeed(POOL_ACC_SEED)]);
 }
 /**
  * Derive the clock account address.
  * @returns Derived clock account public key.
  */
 function getClockAccAddress() {
-    const seeds = [Buffer.from(CLOCK_ACC_SEED)];
-    return generateArciumPDAFrom(seeds)[0];
+    return findArciumPda([stringSeed(CLOCK_ACC_SEED)]);
 }
 /**
  * Derive the cluster account address for a given offset.
@@ -15407,10 +16543,7 @@ function getClockAccAddress() {
  * @returns Derived cluster account public key.
  */
 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];
+    return findArciumPda([stringSeed(CLUSTER_ACC_SEED), u32Seed(clusterOffset)]);
 }
 /**
  * Derive the ArxNode account address for a given offset.
@@ -15418,10 +16551,7 @@ function getClusterAccAddress(clusterOffset) {
  * @returns Derived ArxNode account public key.
  */
 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];
+    return findArciumPda([stringSeed(ARX_NODE_ACC_SEED), u32Seed(nodeOffset)]);
 }
 /**
  * Derive the MXE account address for a given MXE program ID.
@@ -15429,8 +16559,7 @@ function getArxNodeAccAddress(nodeOffset) {
  * @returns Derived MXE account public key.
  */
 function getMXEAccAddress(mxeProgramId) {
-    const seeds = [Buffer.from(MXE_ACCOUNT_SEED), mxeProgramId.toBuffer()];
-    return generateArciumPDAFrom(seeds)[0];
+    return findArciumPda([stringSeed(MXE_ACCOUNT_SEED), pubkeySeed(mxeProgramId)]);
 }
 /**
  * Derive the computation definition account address for a given MXE program ID and offset.
@@ -15439,10 +16568,7 @@ function getMXEAccAddress(mxeProgramId) {
  * @returns Derived computation definition account public key.
  */
 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];
+    return findArciumPda([stringSeed(COMP_DEF_ACC_SEED), pubkeySeed(mxeProgramId), u32Seed(compDefOffset)]);
 }
 /**
  * Derive the recovery cluster account address for a given MXE program ID.
@@ -15450,8 +16576,7 @@ function getCompDefAccAddress(mxeProgramId, compDefOffset) {
  * @returns Derived recovery cluster account public key.
  */
 function getRecoveryClusterAccAddress(mxeProgramId) {
-    const seeds = [Buffer.from(RECOVERY_CLUSTER_ACC_SEED), mxeProgramId.toBuffer()];
-    return generateArciumPDAFrom(seeds)[0];
+    return findArciumPda([stringSeed(RECOVERY_CLUSTER_ACC_SEED), pubkeySeed(mxeProgramId)]);
 }
 /**
  * Derive the MXE recovery account address for a key recovery session.
@@ -15459,22 +16584,52 @@ function getRecoveryClusterAccAddress(mxeProgramId) {
  * @returns Derived MXE recovery account public key.
  */
 function getMxeRecoveryAccAddress(originalMxeProgramId) {
-    const seeds = [Buffer.from(MXE_RECOVERY_ACC_SEED), originalMxeProgramId.toBuffer()];
-    return generateArciumPDAFrom(seeds)[0];
+    return findArciumPda([stringSeed(MXE_RECOVERY_ACC_SEED), pubkeySeed(originalMxeProgramId)]);
+}
+/**
+ * Derive the recovery peer account address for a given recovery peer offset.
+ * @param peerOffset - Recovery peer offset as a u32 in `[0, 2^32 - 1]`.
+ * @returns Derived recovery peer account public key.
+ */
+function getRecoveryPeerAccAddress(peerOffset) {
+    return findArciumPda([stringSeed(RECOVERY_PEER_ACC_SEED), u32Seed(peerOffset)]);
+}
+/**
+ * Derive the operator account address for a given operator signer.
+ * @param operatorSigner - Public key of the operator signer.
+ * @returns Derived operator account public key.
+ */
+function getOperatorAccAddress(operatorSigner) {
+    return findArciumPda([stringSeed(OPERATOR_ACC_SEED), pubkeySeed(operatorSigner)]);
+}
+/**
+ * Derive the failure claim account address for a given MXE program and computation offset.
+ * @param mxeProgramId - Public key of the MXE program.
+ * @param computationOffset - Computation offset as an anchor.BN in `[0, 2^64 - 1]`.
+ * @returns Derived failure claim account public key.
+ */
+function getFailureClaimAccAddress(mxeProgramId, computationOffset) {
+    return findArciumPda([stringSeed(FAILURE_CLAIM_ACC_SEED), pubkeySeed(mxeProgramId), u64Seed(computationOffset)]);
+}
+/**
+ * Derive the Arcium signer account address used by an MXE program when invoking the Arcium
+ * program. Unlike most other helpers in this module, this PDA is derived under the MXE
+ * program ID (the caller), not the Arcium program ID - Arcium verifies the seed via
+ * `seeds::program = _mxe_program`.
+ * @param mxeProgramId - Public key of the MXE program that owns the signer PDA.
+ * @returns Derived Arcium signer account public key.
+ */
+function getArciumSignerAccAddress(mxeProgramId) {
+    return findPda(mxeProgramId, [stringSeed(ARCIUM_SIGNER_ACC_SEED)]);
 }
 /**
  * Derive the raw circuit account address for a given computation definition and index.
  * @param compDefPubkey - Public key of the computation definition account.
- * @param rawCircuitIndex - Index of the raw circuit account (0-based).
+ * @param rawCircuitIndex - Index of the raw circuit account as a u8 in `[0, 255]`.
  * @returns Derived raw circuit account public key.
  */
 function getRawCircuitAccAddress(compDefPubkey, rawCircuitIndex) {
-    const seeds = [
-        Buffer.from(RAW_CIRCUIT_ACC_SEED),
-        compDefPubkey.toBuffer(),
-        Buffer.from([rawCircuitIndex]),
-    ];
-    return generateArciumPDAFrom(seeds)[0];
+    return findArciumPda([stringSeed(RAW_CIRCUIT_ACC_SEED), pubkeySeed(compDefPubkey), u8Seed(rawCircuitIndex)]);
 }
 /**
  * Derive the address lookup table address for an MXE program.
@@ -15484,120 +16639,149 @@ function getRawCircuitAccAddress(compDefPubkey, rawCircuitIndex) {
  */
 function getLookupTableAddress(mxeProgramId, lutOffset) {
     const mxeAccount = getMXEAccAddress(mxeProgramId);
-    const lutIndexBuffer = lutOffset.toArrayLike(Buffer, 'le', 8);
-    const seeds = [mxeAccount.toBuffer(), lutIndexBuffer];
-    return web3_js.PublicKey.findProgramAddressSync(seeds, web3_js.AddressLookupTableProgram.programId)[0];
+    return findPda(web3_js.AddressLookupTableProgram.programId, [pubkeySeed(mxeAccount), u64Seed(lutOffset)]);
 }
-/**
- * Generate a program-derived address (PDA) from the provided seeds and the Arcium program ID.
- * @param seeds - Array of Buffer seeds used for PDA derivation.
- * @returns Tuple containing the derived public key and the bump seed.
- */
-function generateArciumPDAFrom(seeds) {
-    const programId = getArciumProgramId();
-    return web3_js.PublicKey.findProgramAddressSync(seeds, programId);
+function stringSeed(value) {
+    return Buffer.from(value);
+}
+function u8Seed(value) {
+    assertIntegerInRange(value, 0, MAX_U8, 'u8 seed');
+    return Buffer.from([value]);
+}
+function u32Seed(value) {
+    assertIntegerInRange(value, 0, MAX_U32$1, 'u32 seed');
+    const buffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
+    buffer.writeUInt32LE(value, 0);
+    return buffer;
+}
+function u64Seed(value) {
+    if (value.isNeg() || value.byteLength() > U64_SEED_SIZE) {
+        throw new RangeError(`u64 seed must be between 0 and 18446744073709551615 (got ${value.toString()})`);
+    }
+    return value.toArrayLike(Buffer, 'le', U64_SEED_SIZE);
+}
+function pubkeySeed(value) {
+    return value.toBuffer();
+}
+function findArciumPda(seeds) {
+    return findPda(getArciumProgramId(), seeds);
+}
+function findPda(programId, seeds) {
+    return web3_js.PublicKey.findProgramAddressSync(seeds, programId)[0];
+}
+function assertIntegerInRange(value, min, max, label) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new RangeError(`${label} must be an integer between ${min} and ${max} (got ${value})`);
+    }
 }
 
-const TINY_MEMPOOL_ACC_NAME = 'tinyMempool';
-const TINY_MEMPOOL_DISCRIMINATOR = [
-    176,
-    33,
-    67,
-    108,
-    73,
-    135,
-    110,
-    166,
-];
-const TINY_EXECPOOL_ACC_NAME = 'tinyExecPool';
-const TINY_EXECPOOL_DISCRIMINATOR = [
-    80,
-    245,
-    5,
-    90,
-    154,
-    189,
-    190,
-    172,
-];
-const SMALL_MEMPOOL_ACC_NAME = 'smallMempool';
-const SMALL_MEMPOOL_DISCRIMINATOR = [
-    123,
-    153,
-    151,
-    118,
-    126,
-    71,
-    73,
-    92,
-];
-const SMALL_EXECPOOL_ACC_NAME = 'smallExecPool';
-const SMALL_EXECPOOL_DISCRIMINATOR = [
-    37,
-    147,
-    249,
-    253,
-    217,
-    136,
-    3,
-    87,
+// Names are validated against the IDL account-name union at compile time, so a
+// typo or stale tier fails `tsc` rather than only throwing at load.
+const MEMPOOL_DECODER_ACCOUNT_NAMES = [
+    'tinyMempool',
+    'smallMempool',
+    'mediumMempool',
+    'largeMempool',
 ];
-const MEDIUM_MEMPOOL_ACC_NAME = 'mediumMempool';
-const MEDIUM_MEMPOOL_DISCRIMINATOR = [
-    10,
-    249,
-    58,
-    39,
-    255,
-    231,
-    199,
-    168,
+const EXECUTING_POOL_DECODER_ACCOUNT_NAMES = [
+    'tinyExecPool',
+    'smallExecPool',
+    'mediumExecPool',
+    'largeExecPool',
 ];
-const MEDIUM_EXECPOOL_ACC_NAME = 'mediumExecPool';
-const MEDIUM_EXECPOOL_DISCRIMINATOR = [
-    97,
-    117,
-    128,
-    202,
-    213,
-    76,
-    5,
-    163,
-];
-const LARGE_MEMPOOL_ACC_NAME = 'largeMempool';
-const LARGE_MEMPOOL_DISCRIMINATOR = [
-    16,
-    168,
-    90,
-    235,
-    249,
-    207,
-    73,
-    223,
-];
-const LARGE_EXECPOOL_ACC_NAME = 'largeExecPool';
-const LARGE_EXECPOOL_DISCRIMINATOR = [
-    147,
-    145,
-    148,
-    170,
-    30,
-    13,
-    43,
-    216,
-];
-const MEMPOOL_DISCRIMINATOR_MAP = {
-    [TINY_MEMPOOL_DISCRIMINATOR.toString()]: TINY_MEMPOOL_ACC_NAME,
-    [SMALL_MEMPOOL_DISCRIMINATOR.toString()]: SMALL_MEMPOOL_ACC_NAME,
-    [MEDIUM_MEMPOOL_DISCRIMINATOR.toString()]: MEDIUM_MEMPOOL_ACC_NAME,
-    [LARGE_MEMPOOL_DISCRIMINATOR.toString()]: LARGE_MEMPOOL_ACC_NAME,
-};
-const EXECPOOL_DISCRIMINATOR_MAP = {
-    [TINY_EXECPOOL_DISCRIMINATOR.toString()]: TINY_EXECPOOL_ACC_NAME,
-    [SMALL_EXECPOOL_DISCRIMINATOR.toString()]: SMALL_EXECPOOL_ACC_NAME,
-    [MEDIUM_EXECPOOL_DISCRIMINATOR.toString()]: MEDIUM_EXECPOOL_ACC_NAME,
-    [LARGE_EXECPOOL_DISCRIMINATOR.toString()]: LARGE_EXECPOOL_ACC_NAME,
-};
+function discriminatorKey(discriminator) {
+    return Buffer.from(discriminator).toString('hex');
+}
+// Discriminator bytes are read from the IDL at load time rather than pinned, so the
+// decoder tracks the program's account layout as the single source of truth; a
+// missing or renamed tier throws here instead of silently misrouting at runtime.
+const accountDiscriminatorCoder = new anchor.BorshCoder(anchor.convertIdlToCamelCase(ARCIUM_IDL)).accounts;
+function buildPoolAccountMap(accountNames) {
+    return new Map(accountNames.map((name) => [
+        discriminatorKey(accountDiscriminatorCoder.accountDiscriminator(name)),
+        name,
+    ]));
+}
+const MEMPOOL_ACCOUNT_BY_DISCRIMINATOR = buildPoolAccountMap(MEMPOOL_DECODER_ACCOUNT_NAMES);
+const EXECUTING_POOL_ACCOUNT_BY_DISCRIMINATOR = buildPoolAccountMap(EXECUTING_POOL_DECODER_ACCOUNT_NAMES);
+function getPoolAccountNameByDiscriminator(accountData, accountsByDiscriminator, kind) {
+    if (accountData.length < DISCRIMINATOR_SIZE) {
+        throw new Error(`${kind} account data is shorter than discriminator size`);
+    }
+    const key = discriminatorKey(accountData.subarray(0, DISCRIMINATOR_SIZE));
+    const accountName = accountsByDiscriminator.get(key);
+    if (accountName === undefined) {
+        throw new Error(`Unknown ${kind} account discriminator: ${key}`);
+    }
+    return accountName;
+}
+/** @internal */
+function getMempoolAccountNameByDiscriminator(accountData) {
+    return getPoolAccountNameByDiscriminator(accountData, MEMPOOL_ACCOUNT_BY_DISCRIMINATOR, 'mempool');
+}
+/** @internal */
+function getExecutingPoolAccountNameByDiscriminator(accountData) {
+    return getPoolAccountNameByDiscriminator(accountData, EXECUTING_POOL_ACCOUNT_BY_DISCRIMINATOR, 'executing pool');
+}
+
+const MAX_U32 = 0xffffffff;
+/**
+ * Mirrors the on-chain `init_mxe_part2` recovery-peer bounds before building the instruction.
+ * @internal
+ */
+function assertValidRecoveryPeers(recoveryPeers) {
+    if (recoveryPeers.length > MAX_RECOVERY_PEERS) {
+        throw new Error(`recoveryPeers must have at most ${MAX_RECOVERY_PEERS} elements (got ${recoveryPeers.length})`);
+    }
+    let nonZeroPeers = 0;
+    for (let index = 0; index < recoveryPeers.length; index += 1) {
+        const peer = recoveryPeers[index];
+        if (!Number.isInteger(peer) || peer < 0 || peer > MAX_U32) {
+            throw new RangeError(`recoveryPeers[${index}] must be an integer in [0, ${MAX_U32}] (got ${peer})`);
+        }
+        if (peer !== 0) {
+            nonZeroPeers += 1;
+        }
+    }
+    if (nonZeroPeers > 0 && nonZeroPeers < MIN_RECOVERY_PEERS) {
+        throw new Error(`recoveryPeers must have 0 or at least ${MIN_RECOVERY_PEERS} non-zero offsets (found ${nonZeroPeers})`);
+    }
+}
+/** @internal */
+function normalizeRecoveryPeers(recoveryPeers) {
+    assertValidRecoveryPeers(recoveryPeers);
+    const paddedRecoveryPeers = [...recoveryPeers];
+    while (paddedRecoveryPeers.length < MAX_RECOVERY_PEERS) {
+        paddedRecoveryPeers.push(0);
+    }
+    return paddedRecoveryPeers;
+}
+
+/** @internal */
+function getRawCircuitAccountCount(rawCircuitByteLength) {
+    if (!Number.isInteger(rawCircuitByteLength) || rawCircuitByteLength < 0) {
+        throw new RangeError(`rawCircuit byte length must be a non-negative integer (got ${rawCircuitByteLength})`);
+    }
+    const accountCount = Math.ceil(rawCircuitByteLength / MAX_RAW_CIRCUIT_BYTES_PER_ACC);
+    if (accountCount > MAX_RAW_CIRCUIT_ACCOUNTS) {
+        throw new RangeError(`Raw circuit is too large for on-chain upload: requires ${accountCount} raw circuit accounts, maximum is ${MAX_RAW_CIRCUIT_ACCOUNTS}`);
+    }
+    return accountCount;
+}
+/** @internal */
+function assertRawCircuitUploadLength(rawCircuitByteLength, declaredCircuitByteLength, circuitName) {
+    if (!Number.isInteger(rawCircuitByteLength) || rawCircuitByteLength < 0) {
+        throw new RangeError(`rawCircuit byte length must be a non-negative integer (got ${rawCircuitByteLength})`);
+    }
+    if (!Number.isInteger(declaredCircuitByteLength) || declaredCircuitByteLength <= 0) {
+        throw new RangeError(`Declared circuit byte length for ${circuitName} must be a positive integer (got ${declaredCircuitByteLength})`);
+    }
+    if (rawCircuitByteLength !== declaredCircuitByteLength) {
+        throw new RangeError(`Raw circuit byte length for ${circuitName} must match the computation definition: got ${rawCircuitByteLength}, expected ${declaredCircuitByteLength}`);
+    }
+}
+
+const { BN } = anchor;
 /**
  * Fetch and decode the mempool account info for any mempool account size.
  * @param provider - Anchor provider to use for fetching accounts.
@@ -15606,15 +16790,8 @@ const EXECPOOL_DISCRIMINATOR_MAP = {
  * @throws Error if the account cannot be fetched or the discriminator is unknown.
  */
 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, DISCRIMINATOR_SIZE)).toString();
-    const accName = MEMPOOL_DISCRIMINATOR_MAP[discriminator];
-    if (accName === undefined) {
-        throw new Error(`Unknown mempool account discriminator: ${discriminator}`);
-    }
+    const accData = requireAccountInfo(await provider.connection.getAccountInfo(mempoolAccPubkey), mempoolAccPubkey, 'mempool');
+    const accName = getMempoolAccountNameByDiscriminator(accData.data);
     const program = getArciumProgram(provider);
     return program.coder.accounts.decode(accName, accData.data);
 }
@@ -15626,18 +16803,17 @@ async function getMempoolAccInfo(provider, mempoolAccPubkey) {
  * @throws Error if the account cannot be fetched or the discriminator is unknown.
  */
 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, DISCRIMINATOR_SIZE)).toString();
-    const accName = EXECPOOL_DISCRIMINATOR_MAP[discriminator];
-    if (accName === undefined) {
-        throw new Error(`Unknown executing pool account discriminator: ${discriminator}`);
-    }
+    const accData = requireAccountInfo(await provider.connection.getAccountInfo(executingPoolAccPubkey), executingPoolAccPubkey, 'executing pool');
+    const accName = getExecutingPoolAccountNameByDiscriminator(accData.data);
     const program = getArciumProgram(provider);
     return program.coder.accounts.decode(accName, accData.data);
 }
+function requireAccountInfo(accountInfo, pubkey, label) {
+    if (accountInfo === null) {
+        throw new Error(`Failed to fetch ${label} account ${pubkey.toBase58()}`);
+    }
+    return accountInfo;
+}
 /**
  * Return all computation references in the mempool for a given account.
  * Only non-stake computations are included.
@@ -15681,15 +16857,15 @@ async function getComputationsInMempool(arciumProgram, address) {
 async function getMempoolPriorityFeeStats(arciumProgram, mempoolAddress) {
     const refs = await getComputationsInMempool(arciumProgram, mempoolAddress);
     if (refs.length === 0) {
-        const zero = new anchor__namespace.BN(0);
+        const zero = new 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 sum = fees.reduce((acc, fee) => acc.add(fee), new BN(0));
+    const mean = sum.div(new 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 - 1].add(fees[mid]).div(new BN(2))
         : fees[mid];
     return {
         mean,
@@ -15762,11 +16938,12 @@ function getCircuitState(circuitSource) {
  * @param mxeProgramId - Public key of the MXE program.
  * @param rawCircuit - Raw circuit data as a Uint8Array.
  * @param logging - Whether to log progress (default: true).
- * @param chunkSize - Number of upload transactions to send in parallel (default: 500).
+ * @param chunkSize - Number of upload transactions to send in parallel. Defaults to
+ *                    {@link DEFAULT_UPLOAD_TX_BATCH_SIZE}.
  * @param confirmOptions - Transaction confirmation options.
  * @returns Array of transaction signatures for all upload and finalize transactions.
  */
-async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, logging = true, chunkSize = 500, confirmOptions) {
+async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, logging = true, chunkSize = DEFAULT_UPLOAD_TX_BATCH_SIZE, confirmOptions) {
     const compDefAccInfo = getCompDefAccInfo(circuitName, mxeProgramId);
     const program = getArciumProgram(provider);
     const compDefAcc = await program.account.computationDefinitionAccount.fetch(compDefAccInfo.pubkey);
@@ -15776,12 +16953,12 @@ async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, lo
         optionalLog(logging, `Circuit ${circuitName} skipped: ${state}`);
         return [];
     }
-    // 9 = 8-byte discriminator + 1-byte bump for ComputationDefinitionRaw account
-    const numAccs = Math.ceil(rawCircuit.length / (MAX_ACCOUNT_SIZE - 9));
+    assertRawCircuitUploadLength(rawCircuit.length, compDefAcc.definition.circuitLen, circuitName);
+    const numAccs = getRawCircuitAccountCount(rawCircuit.length);
     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, confirmOptions));
+        uploadPromises.push(uploadToCircuitAcc(provider, program, rawCircuit.subarray(i * MAX_RAW_CIRCUIT_BYTES_PER_ACC, (i + 1) * MAX_RAW_CIRCUIT_BYTES_PER_ACC), i, compDefAccInfo, mxeProgramId, logging, chunkSize, confirmOptions));
     }
     sigs.push(...(await Promise.all(uploadPromises)).flat());
     const finalizeCompDefTx = await buildFinalizeCompDefTx(provider, compDefAccInfo.offset, mxeProgramId);
@@ -15797,8 +16974,6 @@ async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, lo
  */
 async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramId) {
     const program = getArciumProgram(provider);
-    const compDefOffsetBuffer = Buffer.alloc(OFFSET_BUFFER_SIZE);
-    compDefOffsetBuffer.writeUInt32LE(compDefOffset, 0);
     return program.methods
         .finalizeComputationDefinition(compDefOffset, mxeProgramId)
         .accounts({
@@ -15806,12 +16981,11 @@ async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramId) {
     })
         .transaction();
 }
-async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramId, shouldLog = true, chunkSize = 500, confirmOptions) {
+async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramId, shouldLog = true, chunkSize = DEFAULT_UPLOAD_TX_BATCH_SIZE, confirmOptions) {
     const rawCircuitPda = getRawCircuitAccAddress(compDefAccInfo.pubkey, rawCircuitIndex);
     const existingAcc = await provider.connection.getAccountInfo(rawCircuitPda);
     // Skip entirely if account exists with correct size (pre-seeded at genesis or already uploaded)
-    // Account layout: 8-byte discriminator + 1-byte bump + circuit data
-    const requiredAccountSize = rawCircuitPart.length + 9;
+    const requiredAccountSize = rawCircuitPart.length + RAW_CIRCUIT_ACCOUNT_HEADER_SIZE;
     if (existingAcc !== null && existingAcc.data.length >= requiredAccountSize) {
         optionalLog(shouldLog, `Raw circuit acc ${rawCircuitIndex} already exists with sufficient size, skipping`);
         return [];
@@ -15945,18 +17119,8 @@ function getArciumProgram(provider) {
  */
 function getCompDefAccInfo(circuitName, mxeProgramId) {
     const offset = getCompDefAccOffset(circuitName);
-    const pda = getCompDefAccPDA(getArciumProgramId(), mxeProgramId, offset);
-    return { pubkey: pda, offset: Buffer.from(offset).readUInt32LE(0) };
-}
-/**
- * Return the PDA for a computation definition account, given the program ID, MXE program ID, and offset.
- * @param arciumProgramId - Public key of the Arcium program.
- * @param mxeProgramId - Public key of the MXE program.
- * @param offset - Offset as a Uint8Array.
- * @returns PDA for the computation definition account.
- */
-function getCompDefAccPDA(arciumProgramId, mxeProgramId, offset) {
-    return anchor__namespace.web3.PublicKey.findProgramAddressSync([Buffer.from(COMP_DEF_ACC_SEED, 'utf-8'), mxeProgramId.toBuffer(), offset], arciumProgramId)[0];
+    const offsetNumber = Buffer.from(offset).readUInt32LE(0);
+    return { pubkey: getCompDefAccAddress(mxeProgramId, offsetNumber), offset: offsetNumber };
 }
 /**
  * Initialize an MXE (part 1). Due to Solana's 10KB per-instruction allocation limit,
@@ -15964,13 +17128,15 @@ function getCompDefAccPDA(arciumProgramId, mxeProgramId, offset) {
  * Call initMxePart2 afterwards to finish allocation and add keygen to mempool.
  * @param provider - Anchor provider to use for transactions.
  * @param mxeProgramId - Public key to use as the MXE program ID.
+ * @param recoveryPeers - Array of 100 node offsets for recovery peers (0 for unused slots).
  * @param confirmOptions - Transaction confirmation options.
  * @returns Transaction signature.
  */
-async function initMxePart1(provider, mxeProgramId, confirmOptions) {
+async function initMxePart1(provider, mxeProgramId, recoveryPeers, confirmOptions) {
     const program = getArciumProgram(provider);
+    const paddedRecoveryPeers = normalizeRecoveryPeers(recoveryPeers);
     const tx = await program.methods
-        .initMxePart1()
+        .initMxePart1(paddedRecoveryPeers)
         .accountsPartial({
         signer: provider.publicKey,
         mxeProgram: mxeProgramId,
@@ -15985,9 +17151,12 @@ async function initMxePart1(provider, mxeProgramId, confirmOptions) {
  * @param provider - Anchor provider to use for transactions.
  * @param clusterOffset - Cluster offset to associate with the MXE.
  * @param mxeProgramId - Public key to use as the MXE program ID.
- * @param recoveryPeers - Array of 100 node offsets for recovery peers (0 for unused slots).
  * @param keygenOffset - Computation offset for the keygen computation.
  * @param keyRecoveryInitOffset - Computation offset for the key_recovery_init computation.
+ * @param recoveryPeers - Recovery peer node offsets. Slots set to 0 are treated as unused.
+ *                        The non-zero count must be either 0 (recovery disabled) or at least
+ *                        `MIN_RECOVERY_PEERS` (4). The array is padded with zeros up to
+ *                        `MAX_RECOVERY_PEERS` (100); passing more than that throws.
  * @param lutOffset - Lookup table offset for the MXE's address lookup table.
  * @param mxeAuthority - Optional authority for the MXE (defaults to provider.publicKey).
  * @param confirmOptions - Transaction confirmation options.
@@ -15995,16 +17164,8 @@ async function initMxePart1(provider, mxeProgramId, confirmOptions) {
  */
 async function initMxePart2(provider, clusterOffset, mxeProgramId, keygenOffset, keyRecoveryInitOffset, recoveryPeers, lutOffset, mxeAuthority, confirmOptions) {
     const program = getArciumProgram(provider);
-    // Ensure recoveryPeers has exactly 100 elements
-    const paddedRecoveryPeers = [...recoveryPeers];
-    while (paddedRecoveryPeers.length < 100) {
-        paddedRecoveryPeers.push(0);
-    }
-    if (paddedRecoveryPeers.length > 100) {
-        throw new Error('recoveryPeers must have at most 100 elements');
-    }
     const tx = await program.methods
-        .initMxePart2(clusterOffset, mxeProgramId, paddedRecoveryPeers, keygenOffset, keyRecoveryInitOffset, lutOffset)
+        .initMxePart2(clusterOffset, keygenOffset, keyRecoveryInitOffset, lutOffset)
         .accountsPartial({
         signer: provider.publicKey,
         mxeProgram: mxeProgramId,
@@ -16015,6 +17176,14 @@ async function initMxePart2(provider, clusterOffset, mxeProgramId, keygenOffset,
         .transaction();
     return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
+/**
+ * Reclaim the rent locked in a finished computation account.
+ * @param provider - Anchor provider to use for transactions.
+ * @param clusterOffset - Offset of the cluster that ran the computation.
+ * @param computationOffset - Offset of the computation whose rent is being claimed.
+ * @param confirmOptions - Transaction confirmation options.
+ * @returns Transaction signature.
+ */
 async function claimComputationRent(provider, clusterOffset, computationOffset, confirmOptions) {
     const program = getArciumProgram(provider);
     const tx = await program.methods
@@ -16163,6 +17332,7 @@ exports.getArciumAccountBaseSeed = getArciumAccountBaseSeed;
 exports.getArciumEnv = getArciumEnv;
 exports.getArciumProgram = getArciumProgram;
 exports.getArciumProgramId = getArciumProgramId;
+exports.getArciumSignerAccAddress = getArciumSignerAccAddress;
 exports.getArxNodeAccAddress = getArxNodeAccAddress;
 exports.getCircuitState = getCircuitState;
 exports.getClockAccAddress = getClockAccAddress;
@@ -16173,6 +17343,7 @@ exports.getComputationAccAddress = getComputationAccAddress;
 exports.getComputationsInMempool = getComputationsInMempool;
 exports.getExecutingPoolAccAddress = getExecutingPoolAccAddress;
 exports.getExecutingPoolAccInfo = getExecutingPoolAccInfo;
+exports.getFailureClaimAccAddress = getFailureClaimAccAddress;
 exports.getFeePoolAccAddress = getFeePoolAccAddress;
 exports.getLookupTableAddress = getLookupTableAddress;
 exports.getMXEAccAddress = getMXEAccAddress;
@@ -16182,8 +17353,10 @@ exports.getMempoolAccAddress = getMempoolAccAddress;
 exports.getMempoolAccInfo = getMempoolAccInfo;
 exports.getMempoolPriorityFeeStats = getMempoolPriorityFeeStats;
 exports.getMxeRecoveryAccAddress = getMxeRecoveryAccAddress;
+exports.getOperatorAccAddress = getOperatorAccAddress;
 exports.getRawCircuitAccAddress = getRawCircuitAccAddress;
 exports.getRecoveryClusterAccAddress = getRecoveryClusterAccAddress;
+exports.getRecoveryPeerAccAddress = getRecoveryPeerAccAddress;
 exports.initMxePart1 = initMxePart1;
 exports.initMxePart2 = initMxePart2;
 exports.isNullRef = isNullRef;