@arcium-hq/client 0.10.4 → 0.11.1

package/build/types/idl/arcium.d.ts

@@ -8,7 +8,7 @@ export type Arcium = {
     "address": "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
     "metadata": {
         "name": "arcium";
-        "version": "0.10.4";
+        "version": "0.11.1";
         "spec": "0.1.0";
         "description": "The Arcium program";
     };
@@ -299,6 +299,84 @@ export type Arcium = {
                 }
             ];
         },
+        {
+            "name": "bindRecoveryPeerMigration";
+            "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": "recoveryPeerAccount";
+                    "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": "peerOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "primaryStakeAccount";
+                    "writable": true;
+                },
+                {
+                    "name": "arciumStakingProgram";
+                    "address": "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq";
+                }
+            ];
+            "args": [
+                {
+                    "name": "peerOffset";
+                    "type": "u32";
+                }
+            ];
+        },
         {
             "name": "bumpEpochCluster";
             "discriminator": [
@@ -412,6 +490,7 @@ export type Arcium = {
                 },
                 {
                     "name": "mxe";
+                    "writable": true;
                     "pda": {
                         "seeds": [
                             {
@@ -949,6 +1028,7 @@ export type Arcium = {
                 },
                 {
                     "name": "mxe";
+                    "writable": true;
                     "pda": {
                         "seeds": [
                             {
@@ -1278,13 +1358,88 @@ export type Arcium = {
             ];
             "accounts": [
                 {
-                    "name": "nodeAuthority";
+                    "name": "stakingPoolSigner";
+                    "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;
+                    "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": "primaryStakeAccount";
+                    "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";
@@ -1364,39 +1519,121 @@ export type Arcium = {
                     "type": "u32";
                 }
             ];
+            "returns": "u64";
         },
         {
-            "name": "closeComputationDefinition";
-            "docs": [
-                "Closes a computation definition after TTL wait and verifying no active computations."
-            ];
+            "name": "claimRecoveryPeerFees";
             "discriminator": [
-                175,
-                224,
-                148,
-                1,
-                107,
-                74,
-                70,
-                110
+                132,
+                120,
+                187,
+                164,
+                106,
+                57,
+                202,
+                8
             ];
             "accounts": [
                 {
-                    "name": "signer";
+                    "name": "stakingPoolSigner";
+                    "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": "mxe";
-                    "writable": true;
+                    "name": "primaryStakeAccount";
+                    "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": "recoveryPeer";
                     "pda": {
                         "seeds": [
                             {
                                 "kind": "const";
                                 "value": [
-                                    77,
-                                    88,
-                                    69,
+                                    82,
+                                    101,
+                                    99,
+                                    111,
+                                    118,
+                                    101,
+                                    114,
+                                    121,
+                                    80,
+                                    101,
+                                    101,
+                                    114,
                                     65,
                                     99,
                                     99,
@@ -1408,40 +1645,22 @@ export type Arcium = {
                             },
                             {
                                 "kind": "arg";
-                                "path": "mxeProgram";
+                                "path": "peerOffset";
                             }
                         ];
                     };
                 },
                 {
-                    "name": "compDefAcc";
+                    "name": "mxe";
                     "writable": true;
                     "pda": {
                         "seeds": [
                             {
                                 "kind": "const";
                                 "value": [
-                                    67,
-                                    111,
-                                    109,
-                                    112,
-                                    117,
-                                    116,
-                                    97,
-                                    116,
-                                    105,
-                                    111,
-                                    110,
-                                    68,
-                                    101,
-                                    102,
-                                    105,
-                                    110,
-                                    105,
-                                    116,
-                                    105,
-                                    111,
-                                    110,
+                                    77,
+                                    88,
+                                    69,
                                     65,
                                     99,
                                     99,
@@ -1454,65 +1673,191 @@ export type Arcium = {
                             {
                                 "kind": "arg";
                                 "path": "mxeProgram";
-                            },
-                            {
-                                "kind": "arg";
-                                "path": "compOffset";
                             }
                         ];
                     };
                 },
                 {
-                    "name": "executingPool";
+                    "name": "pool";
+                    "writable": true;
                     "pda": {
                         "seeds": [
                             {
                                 "kind": "const";
                                 "value": [
-                                    69,
-                                    120,
+                                    70,
                                     101,
-                                    99,
-                                    112,
+                                    101,
+                                    80,
                                     111,
                                     111,
                                     108
                                 ];
-                            },
-                            {
-                                "kind": "arg";
-                                "path": "clusterOffset";
                             }
                         ];
                     };
-                },
-                {
-                    "name": "systemProgram";
-                    "docs": [
-                        "System program account."
-                    ];
-                    "address": "11111111111111111111111111111111";
                 }
             ];
             "args": [
-                {
-                    "name": "compOffset";
-                    "type": "u32";
-                },
                 {
                     "name": "mxeProgram";
                     "type": "pubkey";
                 },
                 {
-                    "name": "clusterOffset";
+                    "name": "peerOffset";
                     "type": "u32";
                 }
             ];
+            "returns": "u64";
         },
         {
-            "name": "closeComputationDefinitionBuffers";
+            "name": "closeComputationDefinition";
             "docs": [
-                "Closes the raw circuit buffer account for a computation definition."
+                "Closes a computation definition after TTL wait and verifying no active computations."
+            ];
+            "discriminator": [
+                175,
+                224,
+                148,
+                1,
+                107,
+                74,
+                70,
+                110
+            ];
+            "accounts": [
+                {
+                    "name": "signer";
+                    "writable": true;
+                    "signer": true;
+                },
+                {
+                    "name": "mxe";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    77,
+                                    88,
+                                    69,
+                                    65,
+                                    99,
+                                    99,
+                                    111,
+                                    117,
+                                    110,
+                                    116
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "mxeProgram";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "compDefAcc";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    67,
+                                    111,
+                                    109,
+                                    112,
+                                    117,
+                                    116,
+                                    97,
+                                    116,
+                                    105,
+                                    111,
+                                    110,
+                                    68,
+                                    101,
+                                    102,
+                                    105,
+                                    110,
+                                    105,
+                                    116,
+                                    105,
+                                    111,
+                                    110,
+                                    65,
+                                    99,
+                                    99,
+                                    111,
+                                    117,
+                                    110,
+                                    116
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "mxeProgram";
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "compOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "executingPool";
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    69,
+                                    120,
+                                    101,
+                                    99,
+                                    112,
+                                    111,
+                                    111,
+                                    108
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "clusterOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "systemProgram";
+                    "docs": [
+                        "System program account."
+                    ];
+                    "address": "11111111111111111111111111111111";
+                }
+            ];
+            "args": [
+                {
+                    "name": "compOffset";
+                    "type": "u32";
+                },
+                {
+                    "name": "mxeProgram";
+                    "type": "pubkey";
+                },
+                {
+                    "name": "clusterOffset";
+                    "type": "u32";
+                }
+            ];
+        },
+        {
+            "name": "closeComputationDefinitionBuffers";
+            "docs": [
+                "Closes the raw circuit buffer account for a computation definition."
             ];
             "discriminator": [
                 98,
@@ -2668,7 +3013,16 @@ export type Arcium = {
                     "name": "largeExecpool";
                 }
             ];
-            "args": [];
+            "args": [
+                {
+                    "name": "selector";
+                    "type": {
+                        "defined": {
+                            "name": "leaderSelector";
+                        };
+                    };
+                }
+            ];
         },
         {
             "name": "embiggenRawCircuitAcc";
@@ -4279,6 +4633,31 @@ export type Arcium = {
                         ];
                     };
                 },
+                {
+                    "name": "primaryStakeAccount";
+                    "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": "arciumStakingProgram";
+                    "address": "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq";
+                },
                 {
                     "name": "systemProgram";
                     "address": "11111111111111111111111111111111";
@@ -5145,7 +5524,17 @@ export type Arcium = {
                     "address": "11111111111111111111111111111111";
                 }
             ];
-            "args": [];
+            "args": [
+                {
+                    "name": "recoveryPeers";
+                    "type": {
+                        "array": [
+                            "u32",
+                            100
+                        ];
+                    };
+                }
+            ];
         },
         {
             "name": "initMxePart2";
@@ -5259,7 +5648,7 @@ export type Arcium = {
                                 ];
                             },
                             {
-                                "kind": "arg";
+                                "kind": "account";
                                 "path": "mxeProgram";
                             }
                         ];
@@ -5560,6 +5949,17 @@ export type Arcium = {
                         ];
                     };
                 },
+                {
+                    "name": "instructionsSysvar";
+                    "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": "systemProgram";
                     "address": "11111111111111111111111111111111";
@@ -5570,19 +5970,6 @@ export type Arcium = {
                     "name": "clusterOffset";
                     "type": "u32";
                 },
-                {
-                    "name": "mxeProgram";
-                    "type": "pubkey";
-                },
-                {
-                    "name": "recoveryPeers";
-                    "type": {
-                        "array": [
-                            "u32",
-                            100
-                        ];
-                    };
-                },
                 {
                     "name": "keygenOffset";
                     "type": "u64";
@@ -6039,6 +6426,31 @@ export type Arcium = {
                         ];
                     };
                 },
+                {
+                    "name": "primaryStakeAccount";
+                    "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": "arciumStakingProgram";
+                    "address": "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq";
+                },
                 {
                     "name": "systemProgram";
                     "address": "11111111111111111111111111111111";
@@ -6176,49 +6588,30 @@ export type Arcium = {
             ];
         },
         {
-            "name": "proposeFee";
+            "name": "migrateArxNode";
             "discriminator": [
+                26,
+                223,
                 103,
-                204,
-                172,
-                134,
-                248,
-                252,
-                27,
-                170
+                52,
+                241,
+                117,
+                229,
+                143
             ];
             "accounts": [
                 {
-                    "name": "nodeAuthority";
-                    "writable": true;
+                    "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": "clusterAcc";
-                    "writable": true;
-                    "pda": {
-                        "seeds": [
-                            {
-                                "kind": "const";
-                                "value": [
-                                    67,
-                                    108,
-                                    117,
-                                    115,
-                                    116,
-                                    101,
-                                    114
-                                ];
-                            },
-                            {
-                                "kind": "arg";
-                                "path": "clusterOffset";
-                            }
-                        ];
-                    };
-                },
                 {
                     "name": "arxNodeAcc";
+                    "writable": true;
                     "pda": {
                         "seeds": [
                             {
@@ -6241,8 +6634,189 @@ export type Arcium = {
                     };
                 },
                 {
-                    "name": "clock";
-                    "writable": true;
+                    "name": "primaryStakeAccount";
+                    "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": "arciumStakingProgram";
+                    "address": "ArcStnN9zZZVB5WjgPhLHjYpY7Gb29mzb96ySsb1kxgq";
+                }
+            ];
+            "args": [
+                {
+                    "name": "nodeOffset";
+                    "type": "u32";
+                }
+            ];
+        },
+        {
+            "name": "migrateCluster";
+            "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": "systemProgram";
+                    "address": "11111111111111111111111111111111";
+                }
+            ];
+            "args": [];
+        },
+        {
+            "name": "migrateMxeAccount";
+            "discriminator": [
+                96,
+                162,
+                117,
+                100,
+                242,
+                143,
+                16,
+                80
+            ];
+            "accounts": [
+                {
+                    "name": "payer";
+                    "writable": true;
+                    "signer": true;
+                },
+                {
+                    "name": "mxe";
+                    "writable": true;
+                },
+                {
+                    "name": "systemProgram";
+                    "address": "11111111111111111111111111111111";
+                }
+            ];
+            "args": [];
+        },
+        {
+            "name": "migrateRecoveryPeer";
+            "discriminator": [
+                58,
+                226,
+                37,
+                60,
+                200,
+                31,
+                251,
+                245
+            ];
+            "accounts": [
+                {
+                    "name": "payer";
+                    "writable": true;
+                    "signer": true;
+                },
+                {
+                    "name": "recoveryPeer";
+                    "writable": true;
+                },
+                {
+                    "name": "systemProgram";
+                    "address": "11111111111111111111111111111111";
+                }
+            ];
+            "args": [];
+        },
+        {
+            "name": "proposeFee";
+            "discriminator": [
+                103,
+                204,
+                172,
+                134,
+                248,
+                252,
+                27,
+                170
+            ];
+            "accounts": [
+                {
+                    "name": "nodeAuthority";
+                    "writable": true;
+                    "signer": true;
+                },
+                {
+                    "name": "clusterAcc";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    67,
+                                    108,
+                                    117,
+                                    115,
+                                    116,
+                                    101,
+                                    114
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "clusterOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "arxNodeAcc";
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    65,
+                                    114,
+                                    120,
+                                    78,
+                                    111,
+                                    100,
+                                    101
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "nodeOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "clock";
+                    "writable": true;
                     "pda": {
                         "seeds": [
                             {
@@ -6347,6 +6921,42 @@ export type Arcium = {
                         ];
                     };
                 },
+                {
+                    "name": "mempool";
+                    "docs": [
+                        "The cluster's mempool account, used only to read its size (from the discriminator) so we",
+                        "know the minimum primary stake the invited node must hold.",
+                        "`mempool_size_of`."
+                    ];
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    77,
+                                    101,
+                                    109,
+                                    112,
+                                    111,
+                                    111,
+                                    108
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "clusterOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "primaryStakeAccount";
+                    "docs": [
+                        "The `PrimaryStakingAccount` (owned by `arcium_staking`) bound to the invited node. We read",
+                        "its `primary_stake` (first field) to enforce the per-mempool-size minimum. Verified to be",
+                        "owned by the staking program and to match the node's recorded `primary_staking_account`."
+                    ];
+                },
                 {
                     "name": "clock";
                     "writable": true;
@@ -6393,7 +7003,12 @@ export type Arcium = {
             "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,
@@ -6726,8 +7341,12 @@ export type Arcium = {
                     "type": "u8";
                 },
                 {
-                    "name": "outputDeliveryFee";
-                    "type": "u64";
+                    "name": "callbackCuLimit";
+                    "type": "u32";
+                },
+                {
+                    "name": "padding";
+                    "type": "u32";
                 },
                 {
                     "name": "cuPriceMicro";
@@ -8106,6 +8725,114 @@ export type Arcium = {
                 }
             ];
         },
+        {
+            "name": "setLeaderChoice";
+            "discriminator": [
+                42,
+                7,
+                112,
+                255,
+                254,
+                186,
+                135,
+                133
+            ];
+            "accounts": [
+                {
+                    "name": "nodeAuthority";
+                    "writable": true;
+                    "signer": true;
+                },
+                {
+                    "name": "clusterAcc";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    67,
+                                    108,
+                                    117,
+                                    115,
+                                    116,
+                                    101,
+                                    114
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "clusterOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "arxNodeAcc";
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    65,
+                                    114,
+                                    120,
+                                    78,
+                                    111,
+                                    100,
+                                    101
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "nodeOffset";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "mempool";
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    77,
+                                    101,
+                                    109,
+                                    112,
+                                    111,
+                                    111,
+                                    108
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "clusterOffset";
+                            }
+                        ];
+                    };
+                }
+            ];
+            "args": [
+                {
+                    "name": "clusterOffset";
+                    "type": "u32";
+                },
+                {
+                    "name": "nodeOffset";
+                    "type": "u32";
+                },
+                {
+                    "name": "choice";
+                    "type": {
+                        "defined": {
+                            "name": "leaderChoice";
+                        };
+                    };
+                }
+            ];
+        },
         {
             "name": "setMxeKeys";
             "discriminator": [
@@ -8316,47 +9043,234 @@ export type Arcium = {
                     };
                 },
                 {
-                    "name": "recoveryClusterAcc";
+                    "name": "recoveryClusterAcc";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    82,
+                                    101,
+                                    99,
+                                    111,
+                                    118,
+                                    101,
+                                    114,
+                                    121,
+                                    67,
+                                    108,
+                                    117,
+                                    115,
+                                    116,
+                                    101,
+                                    114,
+                                    65,
+                                    99,
+                                    99,
+                                    111,
+                                    117,
+                                    110,
+                                    116
+                                ];
+                            },
+                            {
+                                "kind": "arg";
+                                "path": "mxeProgram";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "clusterAcc";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    67,
+                                    108,
+                                    117,
+                                    115,
+                                    116,
+                                    101,
+                                    114
+                                ];
+                            },
+                            {
+                                "kind": "account";
+                                "path": "mxe.cluster";
+                                "account": "mxeAccount";
+                            }
+                        ];
+                    };
+                }
+            ];
+            "args": [
+                {
+                    "name": "nodeOffset";
+                    "type": "u32";
+                },
+                {
+                    "name": "mxeProgram";
+                    "type": "pubkey";
+                },
+                {
+                    "name": "nonce";
+                    "type": {
+                        "array": [
+                            "u8",
+                            16
+                        ];
+                    };
+                },
+                {
+                    "name": "encryptedMxeKeys";
+                    "type": {
+                        "array": [
+                            {
+                                "array": [
+                                    "u8",
+                                    32
+                                ];
+                            },
+                            13
+                        ];
+                    };
+                },
+                {
+                    "name": "keyMaterialHash";
+                    "type": {
+                        "array": [
+                            "u8",
+                            32
+                        ];
+                    };
+                },
+                {
+                    "name": "blsSig";
+                    "type": {
+                        "array": [
+                            "u8",
+                            64
+                        ];
+                    };
+                }
+            ];
+        },
+        {
+            "name": "setNodeStaking";
+            "discriminator": [
+                158,
+                40,
+                109,
+                244,
+                217,
+                195,
+                35,
+                140
+            ];
+            "accounts": [
+                {
+                    "name": "stakingPoolSigner";
+                    "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": [
-                                    82,
-                                    101,
-                                    99,
-                                    111,
-                                    118,
-                                    101,
-                                    114,
-                                    121,
                                     67,
                                     108,
                                     117,
                                     115,
                                     116,
                                     101,
-                                    114,
-                                    65,
-                                    99,
-                                    99,
-                                    111,
-                                    117,
-                                    110,
-                                    116
+                                    114
                                 ];
                             },
                             {
                                 "kind": "arg";
-                                "path": "mxeProgram";
+                                "path": "clusterOffset";
                             }
                         ];
                     };
                 },
                 {
-                    "name": "clusterAcc";
-                    "writable": true;
+                    "name": "clock";
                     "pda": {
                         "seeds": [
                             {
@@ -8364,17 +9278,17 @@ export type Arcium = {
                                 "value": [
                                     67,
                                     108,
+                                    111,
+                                    99,
+                                    107,
+                                    65,
+                                    99,
+                                    99,
+                                    111,
                                     117,
-                                    115,
-                                    116,
-                                    101,
-                                    114
+                                    110,
+                                    116
                                 ];
-                            },
-                            {
-                                "kind": "account";
-                                "path": "mxe.cluster";
-                                "account": "mxeAccount";
                             }
                         ];
                     };
@@ -8382,53 +9296,16 @@ export type Arcium = {
             ];
             "args": [
                 {
-                    "name": "nodeOffset";
+                    "name": "clusterOffset";
                     "type": "u32";
                 },
                 {
-                    "name": "mxeProgram";
-                    "type": "pubkey";
-                },
-                {
-                    "name": "nonce";
-                    "type": {
-                        "array": [
-                            "u8",
-                            16
-                        ];
-                    };
-                },
-                {
-                    "name": "encryptedMxeKeys";
-                    "type": {
-                        "array": [
-                            {
-                                "array": [
-                                    "u8",
-                                    32
-                                ];
-                            },
-                            13
-                        ];
-                    };
-                },
-                {
-                    "name": "keyMaterialHash";
-                    "type": {
-                        "array": [
-                            "u8",
-                            32
-                        ];
-                    };
+                    "name": "nodeOffset";
+                    "type": "u32";
                 },
                 {
-                    "name": "blsSig";
-                    "type": {
-                        "array": [
-                            "u8",
-                            64
-                        ];
-                    };
+                    "name": "stake";
+                    "type": "u64";
                 }
             ];
         },
@@ -9760,6 +10637,11 @@ export type Arcium = {
             "name": "maxParallelismReached";
             "msg": "Max parallelism reached";
         },
+        {
+            "code": 6104;
+            "name": "mempoolAlreadyFullSize";
+            "msg": "Mempool is already at its full allocated size";
+        },
         {
             "code": 6200;
             "name": "invalidComputationOffset";
@@ -9935,6 +10817,16 @@ export type Arcium = {
             "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";
@@ -9993,7 +10885,7 @@ export type Arcium = {
         {
             "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;
@@ -10110,6 +11002,11 @@ export type Arcium = {
             "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";
@@ -10234,6 +11131,16 @@ export type Arcium = {
             "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)";
+        },
+        {
+            "code": 6727;
+            "name": "insufficientPrimaryStake";
+            "msg": "Node's primary stake is below the minimum for this cluster's mempool size";
         }
     ];
     "types": [
@@ -11057,7 +11964,48 @@ export type Arcium = {
                     },
                     {
                         "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": "currentEpochTotalRewards";
+                        "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": "rewardsEpoch";
+                        "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": "leaderSelector";
+                        "docs": [
+                            "The selector for leader."
+                        ];
+                        "type": {
+                            "defined": {
+                                "name": "leaderSelector";
+                            };
+                        };
                     }
                 ];
             };
@@ -11591,16 +12539,28 @@ export type Arcium = {
                     {
                         "name": "priorityFee";
                         "docs": [
-                            "The additional fee to enforce priortized execution in the mempool."
+                            "The additional fee to enforce prioritized execution in the mempool."
                         ];
                         "type": "u64";
                     },
                     {
-                        "name": "outputDeliveryFee";
+                        "name": "callbackCuLimit";
                         "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";
                     }
                 ];
             };
@@ -11966,6 +12926,113 @@ export type Arcium = {
                 ];
             };
         },
+        {
+            "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": "slotIdx";
+                        "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": "lastCounterPlusOne";
+                        "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": "stakingEpoch";
+                        "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": {
@@ -12090,7 +13157,40 @@ export type Arcium = {
                     },
                     {
                         "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": "currentEpochRecoveryRewards";
+                        "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": "recoveryRewardsEpoch";
+                        "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";
+                            };
+                        };
                     }
                 ];
             };
@@ -12425,9 +13525,7 @@ export type Arcium = {
             "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";
@@ -12437,11 +13535,22 @@ export type Arcium = {
                         "type": "u32";
                     },
                     {
-                        "name": "currentTotalRewards";
+                        "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";
@@ -12879,7 +13988,27 @@ export type Arcium = {
                     },
                     {
                         "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": "primaryStakeAccount";
+                        "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";
                     }
                 ];
             };