Arcium LogoArcium TS SDK Docs
@arcium-hq/client/Type aliases

ArciumIdlType

ArciumIdlType = object

Program IDL in camelCase format in order to be used in JS/TS.

Note that this is only a type helper and is not the actual IDL. The original IDL can be found at target/idl/arcium.json.

Properties

accounts

accounts: [{ discriminator: [2, 207, 122, 223, 93, 97, 231, 199]; name: "arxNode"; }, { discriminator: [152, 171, 158, 195, 75, 61, 51, 8]; name: "clockAccount"; }, { discriminator: [236, 225, 118, 228, 173, 106, 18, 60]; name: "cluster"; }, { discriminator: [136, 34, 167, 71, 41, 174, 103, 77]; name: "computationAccount"; }, { discriminator: [245, 176, 217, 221, 253, 104, 172, 200]; name: "computationDefinitionAccount"; }, { discriminator: [226, 70, 57, 224, 38, 233, 59, 136]; name: "computationDefinitionRaw"; }, { discriminator: [132, 11, 106, 171, 253, 138, 56, 78]; name: "failureClaimAccountHeader"; }, { discriminator: [172, 38, 77, 146, 148, 5, 51, 242]; name: "feePool"; }, { discriminator: [147, 145, 148, 170, 30, 13, 43, 216]; name: "largeExecPool"; }, { discriminator: [16, 168, 90, 235, 249, 207, 73, 223]; name: "largeMempool"; }, { discriminator: [103, 26, 85, 250, 179, 159, 17, 117]; name: "mxeAccount"; }, { discriminator: [97, 117, 128, 202, 213, 76, 5, 163]; name: "mediumExecPool"; }, { discriminator: [10, 249, 58, 39, 255, 231, 199, 168]; name: "mediumMempool"; }, { discriminator: [35, 240, 187, 131, 211, 114, 166, 11]; name: "mxeRecoveryAccount"; }, { discriminator: [219, 31, 188, 145, 69, 139, 204, 117]; name: "operator"; }, { discriminator: [116, 60, 120, 184, 194, 209, 87, 183]; name: "recoveryClusterAccount"; }, { discriminator: [37, 147, 249, 253, 217, 136, 3, 87]; name: "smallExecPool"; }, { discriminator: [123, 153, 151, 118, 126, 71, 73, 92]; name: "smallMempool"; }, { discriminator: [80, 245, 5, 90, 154, 189, 190, 172]; name: "tinyExecPool"; }, { discriminator: [176, 33, 67, 108, 73, 135, 110, 166]; name: "tinyMempool"; }]

address

address: "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ"

errors

errors: [{ code: 6000; msg: "The given authority is invalid"; name: "invalidAuthority"; }, { code: 6001; msg: "The MXE keys are already set, i.e. all the nodes of the MXE cluster already agreed on the MXE keys"; name: "mxeKeysAlreadySet"; }, { code: 6002; msg: "The MXE keys are not set, i.e. not all the nodes of the MXE cluster agreed on the MXE keys"; name: "mxeKeysNotSet"; }, { code: 6003; msg: "An invalid MXE account has been supplied"; name: "invalidMxe"; }, { code: 6004; msg: "The cluster is already set"; name: "clusterAlreadySet"; }, { code: 6005; msg: "The cluster is not set"; name: "clusterNotSet"; }, { code: 6006; msg: "An invalid cluster account has been supplied"; name: "invalidCluster"; }, { code: 6007; msg: "An invalid computation definition account has been supplied"; name: "invalidComputationDefinition"; }, { code: 6008; msg: "Couldn't find a mempool ID for the computation"; name: "cantFindMempoolId"; }, { code: 6100; msg: "Mempool discriminator is invalid"; name: "invalidMempoolDiscriminator"; }, { code: 6101; msg: "Mempool size is invalid"; name: "invalidMempoolSize"; }, { code: 6102; msg: "Execpool discriminator is invalid"; name: "invalidExecpoolDiscriminator"; }, { code: 6103; msg: "Max parallelism reached"; name: "maxParallelismReached"; }, { code: 6200; msg: "Computation offset is invalid"; name: "invalidComputationOffset"; }, { code: 6201; msg: "Callback accounts are invalid"; name: "invalidCallbackAccs"; }, { code: 6202; msg: "Callback accounts length is invalid"; name: "invalidCallbackAccsLen"; }, { code: 6203; msg: "The computation is already initialized"; name: "alreadyInitializedComputation"; }, { code: 6204; msg: "Callback computation already called"; name: "alreadyCallbackedComputation"; }, { code: 6205; msg: "Callback tx is invalid"; name: "invalidCallbackTx"; }, { code: 6206; msg: "Computation status is invalid"; name: "invalidComputationStatus"; }, { code: 6207; msg: "Computation is invalid"; name: "invalidComputation"; }, { code: 6208; msg: "Computation authority is invalid"; name: "invalidComputationAuthority"; }, { code: 6209; msg: "Callback instructions are invalid"; name: "invalidCallbackInstructions"; }, { code: 6210; msg: "Computation has not expired from mempool yet"; name: "computationNotExpired"; }, { code: 6211; msg: "Invalid callback transaction index"; name: "invalidCallbackIndex"; }, { code: 6300; msg: "Computation definition is not completed"; name: "computationDefinitionNotCompleted"; }, { code: 6301; msg: "Arguments supplied are invalid"; name: "invalidArguments"; }, { code: 6302; msg: "Circuit source is invalid"; name: "invalidCircuitSource"; }, { code: 6303; msg: "Computation definition already completed"; name: "computationDefinitionAlreadyCompleted"; }, { code: 6304; msg: "CU amount exceeds maximum limit"; name: "invalidCuAmount"; }, { code: 6305; msg: "Offset is invalid"; name: "invalidOffset"; }, { code: 6400; msg: "Node is invalid"; name: "invalidNode"; }, { code: 6401; msg: "Maximum number of nodes in the cluster has been reached"; name: "maxClusterMembershipReached"; }, { code: 6402; msg: "The node already exists in the cluster"; name: "nodeAlreadyExists"; }, { code: 6403; msg: "Node authority is invalid"; name: "invalidNodeAuthority"; }, { code: 6404; msg: "Node is not inactive"; name: "nodeNotInactive"; }, { code: 6405; msg: "Node is not active"; name: "nodeNotActive"; }, { code: 6406; msg: "Cluster membership is invalid"; name: "invalidClusterMembership"; }, { code: 6407; msg: "Node is in an active cluster"; name: "nodeInActiveCluster"; }, { code: 6408; msg: "Node config is invalid"; name: "invalidNodeConfig"; }, { code: 6409; msg: "Unauthorized to create node on mainnet"; name: "unauthorizedNodeCreation"; }, { code: 6410; msg: "Node offset is invalid"; name: "invalidNodeOffset"; }, { code: 6500; msg: "Cluster is full"; name: "clusterFull"; }, { code: 6501; msg: "Cluster deactivation epoch is invalid"; name: "invalidDeactivationEpoch"; }, { code: 6502; msg: "Cluster maximum size is invalid"; name: "invalidMaxSize"; }, { code: 6503; msg: "Cluster authority is invalid"; name: "invalidClusterAuthority"; }, { code: 6504; msg: "Cluster fee proposal is invalid"; name: "invalidFeeProposal"; }, { code: 6505; msg: "Cluster state is invalid"; name: "invalidClusterState"; }, { code: 6506; msg: "Cluster vote is invalid"; name: "invalidVote"; }, { code: 6507; msg: "Cluster is not ready"; name: "clusterNotReady"; }, { code: 6600; msg: "Borsh serialization failed"; name: "serializationFailed"; }, { code: 6601; msg: "Borsh deserialization failed"; name: "deserializationFailed"; }, { code: 6602; msg: "Heap is full"; name: "heapFull"; }, { code: 6603; msg: "Current slot is before the last updated slot"; name: "invalidSlot"; }, { code: 6604; msg: "Epoch is infinity"; name: "epochIsInfinity"; }, { code: 6605; msg: "Timestamp is invalid"; name: "invalidTimestamp"; }, { code: 6606; msg: "Epoch is invalid"; name: "invalidEpoch"; }, { code: 6607; msg: "Epoch overflowed"; name: "epochOverflow"; }, { code: 6608; msg: "Lighthouse program ID is invalid"; name: "invalidLighthouseProgramId"; }, { code: 6609; msg: "Extra instruction found in transaction"; name: "extraInstructionFound"; }, { code: 6610; msg: "Invalid number of Lighthouse program instructions"; name: "invalidLighthouseInstructionCount"; }, { code: 6611; msg: "Invalid BLS signature"; name: "invalidSignature"; }, { code: 6612; msg: "Value already set"; name: "valueAlreadySet"; }, { code: 6613; msg: "Invalid value setter index"; name: "invalidValueSetterIndex"; }, { code: 6614; msg: "Not all nodes have voted for the BLS public key"; name: "notAllNodesVotedForBlsPublicKey"; }, { code: 6615; msg: "Keyshares index out of bounds"; name: "keysharesIndexOutOfBounds"; }, { code: 6616; msg: "Recovery key material not set"; name: "recoveryKeyMaterialNotSet"; }, { code: 6617; msg: "Recovery already finalized"; name: "recoveryInitAlreadyFinalized"; }, { code: 6618; msg: "Invalid number of recovery peers"; name: "invalidRecoveryPeersCount"; }, { code: 6619; msg: "BLS public key is zero"; name: "blsPublicKeyZero"; }, { code: 6620; msg: "This instruction must be called directly, not via CPI"; name: "mustNotBeCalledViaCpi"; }, { code: 6700; msg: "MXE is not in recovery state"; name: "mxeNotInRecoveryState"; }, { code: 6701; msg: "MXE is already in recovery state"; name: "mxeAlreadyInRecovery"; }, { code: 6702; msg: "Backup MXE keygen is not complete"; name: "backupKeygenNotComplete"; }, { code: 6703; msg: "Authority mismatch between original and backup MXE"; name: "recoveryAuthorityMismatch"; }, { code: 6704; msg: "Recovery peers account not initialized"; name: "recoveryPeersNotInitialized"; }, { code: 6705; msg: "Invalid peer offset for recovery share submission"; name: "invalidRecoveryPeerOffset"; }, { code: 6706; msg: "Signer is not a valid recovery peer"; name: "notRecoveryPeer"; }, { code: 6707; msg: "Recovery execution already finalized"; name: "recoveryExecutionAlreadyFinalized"; }, { code: 6708; msg: "Recovery threshold not met"; name: "recoveryThresholdNotMet"; }, { code: 6709; msg: "Recovery execution not finalized"; name: "recoveryExecutionNotFinalized"; }, { code: 6710; msg: "Previous computation did not fail, cannot requeue"; name: "recoveryComputationNotFailed"; }, { code: 6711; msg: "Cannot close recovery with active computation"; name: "recoveryActiveComputationExists"; }, { code: 6712; msg: "Callback requires successful execution status"; name: "recoveryExecutionNotSuccess"; }, { code: 6713; msg: "Backup MXE cluster is not set"; name: "backupClusterNotSet"; }, { code: 6714; msg: "Share already submitted"; name: "shareAlreadySubmitted"; }]

events

events: [{ discriminator: [155, 213, 238, 159, 240, 76, 167, 19]; name: "callbackComputationEvent"; }, { discriminator: [143, 97, 229, 166, 72, 218, 87, 145]; name: "claimFailureEvent"; }, { discriminator: [27, 75, 117, 221, 191, 213, 253, 249]; name: "finalizeComputationEvent"; }, { discriminator: [132, 26, 138, 201, 214, 29, 244, 167]; name: "finalizeFailureDataEvent"; }, { discriminator: [17, 51, 124, 226, 70, 97, 58, 186]; name: "initComputationEvent"; }, { discriminator: [118, 53, 33, 169, 32, 14, 197, 147]; name: "queueComputationEvent"; }]

instructions

instructions: [{ accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }]; args: [{ name: "nodeOffset"; type: "u32"; }]; discriminator: [15, 203, 48, 186, 243, 85, 60, 115]; name: "activateArx"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "clusterId"; type: "u32"; }]; discriminator: [228, 170, 10, 172, 246, 96, 63, 154]; name: "activateCluster"; }, { accounts: [{ name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "clusterOffset"; type: "u32"; }]; discriminator: [172, 203, 90, 207, 128, 221, 229, 246]; name: "bumpEpochCluster"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { name: "comp"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { name: "compDefAcc"; 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: "compDefOffset"; }]; }; }, { address: "Sysvar1nstructions1111111111111111111111111"; name: "instructionsSysvar"; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "nodeOffset"; type: "u32"; }, { name: "compDefOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "executionStatus"; type: { defined: { name: "executionStatus"; }; }; }, { name: "callbackTransactionIndex"; type: "u8"; }]; discriminator: [11, 224, 42, 236, 0, 154, 74, 163]; name: "callbackComputation"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "comp"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "clusterOffset"; type: "u32"; }]; discriminator: [215, 218, 1, 166, 81, 218, 16, 151]; name: "claimComputationRent"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "failureAcc"; pda: { seeds: [{ kind: "const"; value: [70, 97, 105, 108, 117, 114, 101, 67, 108, 97, 105, 109, 65, 99, 99, 111, 117, 110, 116, 72, 101, 97, 100, 101, 114]; }, { kind: "arg"; path: "mxeProgram"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "chunk"; type: "bytes"; }, { name: "failureClaimOffset"; type: "u32"; }]; discriminator: [92, 52, 184, 203, 76, 221, 128, 69]; name: "claimFailureAppend"; }, { accounts: [{ name: "signer"; signer: true; }, { name: "failureAcc"; pda: { seeds: [{ kind: "const"; value: [70, 97, 105, 108, 117, 114, 101, 67, 108, 97, 105, 109, 65, 99, 99, 111, 117, 110, 116, 72, 101, 97, 100, 101, 114]; }, { kind: "arg"; path: "mxeProgram"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { name: "comp"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "nodeOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }]; discriminator: [192, 133, 215, 19, 76, 107, 111, 217]; name: "claimFailureFinalize"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "nodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; }, { name: "compAcc"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }, { kind: "arg"; path: "compOffset"; }]; }; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { name: "compDefAcc"; 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"; }, { account: "computationAccount"; kind: "account"; path: "comp_acc.computation_definition_offset"; }]; }; }, { name: "failureAcc"; pda: { seeds: [{ kind: "const"; value: [70, 97, 105, 108, 117, 114, 101, 67, 108, 97, 105, 109, 65, 99, 99, 111, 117, 110, 116, 72, 101, 97, 100, 101, 114]; }, { kind: "arg"; path: "mxeProgram"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "nodeOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "outputLenBytes"; type: "u32"; }]; discriminator: [204, 106, 245, 73, 212, 136, 61, 99]; name: "claimFailureInit"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; }, { name: "backupMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "backupMxeProgram"; }]; }; writable: true; }, { name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; writable: true; }, { name: "keyRecoveryFinalizeCompDef"; 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: "account"; path: "backupMxeProgram"; }, { kind: "const"; value: [3, 0, 0, 0]; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }]; discriminator: [249, 127, 56, 116, 125, 136, 84, 184]; docs: ["Closes all recovery-related accounts."]; name: "closeKeyRecovery"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }, { name: "clusterAcc"; optional: true; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "account"; path: "arxNodeAcc"; }]; }; }]; args: [{ name: "nodeOffset"; type: "u32"; }]; discriminator: [117, 244, 137, 148, 25, 190, 175, 164]; name: "deactivateArx"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "clusterId"; type: "u32"; }, { name: "deactivationEpoch"; type: { defined: { name: "epoch"; }; }; }]; discriminator: [13, 42, 182, 159, 184, 10, 212, 178]; name: "deactivateCluster"; }, { accounts: [{ name: "tinyMempool"; }, { name: "tinyExecpool"; }, { name: "smallMempool"; }, { name: "smallExecpool"; }, { name: "mediumMempool"; }, { name: "mediumExecpool"; }, { name: "largeMempool"; }, { name: "largeExecpool"; }]; args: []; discriminator: [57, 4, 200, 151, 58, 19, 120, 9]; docs: ["Only present so the mempool and execpool accounts are actually included in the idl, since we", "don't explicitly declare them in the accounts section of the other instructions."]; name: "dummyInstruction"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "compDefAcc"; 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: "compDefRaw"; 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, 82, 97, 119]; }, { kind: "account"; path: "compDefAcc"; }, { kind: "arg"; path: "rawCircuitIndex"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "rawCircuitIndex"; type: "u8"; }]; discriminator: [92, 195, 192, 21, 193, 242, 135, 194]; name: "embiggenRawCircuitAcc"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; }, { name: "recoveryClusterAcc"; 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"; }]; }; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; }]; args: [{ name: "nodeOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "keysharesOffset"; type: "u32"; }, { name: "keyshares"; type: { vec: { array: [{ array: ["u8", 32]; }, 5]; }; }; }]; discriminator: [236, 31, 169, 50, 185, 38, 47, 187]; name: "extendRecoveryKeyshares"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "compDefAcc"; 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"; }]; }; writable: true; }, { docs: ["At least the first raw circuit account must exist before finalizing"]; name: "compDefRaw"; 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, 82, 97, 119]; }, { kind: "account"; path: "compDefAcc"; }, { kind: "const"; value: [0]; }]; }; }]; args: [{ name: "compOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }]; discriminator: [174, 66, 159, 51, 199, 243, 219, 38]; name: "finalizeComputationDefinition"; }, { accounts: [{ name: "signer"; signer: true; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; writable: true; }, { name: "backupMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "backupMxeProgram"; }]; }; writable: true; }, { name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; }, { name: "computation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { name: "compDef"; 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: "account"; path: "backupMxeProgram"; }, { kind: "const"; value: [3, 0, 0, 0]; }]; }; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }, { name: "clusterOffset"; type: "u32"; }, { name: "compOffset"; type: "u64"; }, { name: "nodeOffset"; type: "u32"; }, { name: "executionStatus"; type: { defined: { name: "executionStatus"; }; }; }, { name: "callbackTransactionIndex"; type: "u8"; }]; discriminator: [143, 63, 33, 26, 66, 235, 94, 31]; docs: ["Callback for key_recovery_finalize computation."]; name: "finalizeKeyRecoveryCallback"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "payer"; signer: true; writable: true; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; }, { name: "backupMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "backupMxeProgram"; }]; }; }, { name: "recoveryClusterAcc"; 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: "originalMxeProgram"; }]; }; }, { name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; writable: true; }, { name: "keyRecoveryFinalizeCompDef"; 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: "account"; path: "backupMxeProgram"; }, { kind: "const"; value: [3, 0, 0, 0]; }]; }; }, { name: "keyRecoveryFinalizeComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "account"; path: "mxeRecoveryAccount"; }]; }; writable: true; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }, { name: "clusterOffset"; type: "u32"; }]; discriminator: [211, 40, 223, 121, 15, 169, 2, 59]; docs: ["Finalizes the key recovery execution after threshold is met and queues the computation."]; name: "finalizeKeyRecoveryExecution"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; }, { name: "recoveryClusterAcc"; 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"; }]; }; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; }, { name: "comp"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }, { kind: "arg"; path: "computationOffset"; }]; }; }]; args: [{ name: "nodeOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "computationOffset"; type: "u64"; }]; discriminator: [205, 57, 149, 12, 12, 176, 188, 74]; name: "finalizeKeyRecoverySharesUpload"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { name: "cluster"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "mxeProgram"; type: "pubkey"; }]; discriminator: [108, 137, 125, 95, 202, 237, 190, 158]; name: "finalizeMxeKeys"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterOffset"; type: "u32"; }]; discriminator: [19, 165, 166, 25, 174, 122, 166, 250]; name: "increaseMempoolSize"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }, { name: "feePool"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "startEpochTimestamp"; type: { defined: { name: "timestamp"; }; }; }]; discriminator: [220, 59, 207, 236, 108, 250, 47, 100]; name: "init"; }, { accounts: [{ name: "operatorSigner"; signer: true; writable: true; }, { name: "operatorAcc"; pda: { seeds: [{ kind: "const"; value: [79, 112, 101, 114, 97, 116, 111, 114]; }, { kind: "account"; path: "operatorSigner"; }]; }; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "nodeOffset"; type: "u32"; }, { name: "config"; type: { defined: { name: "arxNodeConfig"; }; }; }, { name: "cuCapacityClaim"; type: "u64"; }, { name: "blsPubkey"; type: { defined: { name: "bn254g2blsPublicKey"; }; }; }, { name: "metadata"; type: { defined: { name: "nodeMetadata"; }; }; }, { name: "x25519Pubkey"; type: { array: ["u8", 32]; }; }]; discriminator: [55, 177, 212, 125, 72, 118, 148, 232]; name: "initArxNode"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }, { name: "authority"; }, { docs: ["function"]; name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }, { name: "execpool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterId"; type: "u32"; }, { name: "mempoolSize"; type: { defined: { name: "mempoolSize"; }; }; }, { name: "clusterSize"; type: "u16"; }, { name: "cuPrice"; type: "u64"; }, { name: "tdInfo"; type: { option: { defined: { name: "nodeMetadata"; }; }; }; }]; discriminator: [144, 230, 5, 18, 93, 71, 133, 187]; name: "initCluster"; }, { accounts: [{ docs: ["Signer of the transaction."]; name: "signer"; signer: true; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { name: "compDefAcc"; 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"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; docs: ["System program account."]; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "computationDefinition"; type: { defined: { name: "computationDefinitionMeta"; }; }; }, { name: "circuitSourceOverride"; type: { option: { defined: { name: "circuitSource"; }; }; }; }, { name: "cuAmount"; type: "u64"; }, { name: "finalizationAuthority"; type: { option: "pubkey"; }; }]; discriminator: [45, 185, 155, 17, 97, 77, 230, 73]; docs: ["Initializes a computation definition."]; name: "initComputationDefinition"; }, { accounts: [{ name: "payer"; signer: true; writable: true; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; }, { docs: ["Full allocation happens in init_key_recovery_execution_part2."]; name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }]; discriminator: [73, 228, 114, 224, 181, 108, 251, 224]; docs: ["Part 1 of key recovery execution initialization.", "Creates the MxeRecoveryAccount with partial size due to Solana's 10KB limit.", "Call init_key_recovery_execution_part2 afterwards."]; name: "initKeyRecoveryExecutionPart1"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "payer"; signer: true; writable: true; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; }, { name: "backupMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "backupMxeProgram"; }]; }; writable: true; }, { name: "recoveryClusterAcc"; 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: "originalMxeProgram"; }]; }; }, { name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; writable: true; }, { docs: ["The computation definition account for MxeKeyRecoveryFinalize (on backup MXE)"]; name: "keyRecoveryFinalizeCompDef"; 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: "account"; path: "backupMxeProgram"; }, { kind: "const"; value: [3, 0, 0, 0]; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }]; discriminator: [181, 38, 231, 178, 21, 239, 196, 158]; docs: ["Part 2 of key recovery execution initialization.", "Finishes allocating MxeRecoveryAccount and creates the computation definition."]; name: "initKeyRecoveryExecutionPart2"; }, { accounts: [{ docs: ["Signer of the transaction."]; name: "signer"; signer: true; writable: true; }, { docs: ["Full allocation happens in init_mxe_part2."]; name: "recoveryClusterAcc"; 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: "account"; path: "mxeProgram"; }]; }; writable: true; }, { docs: ["constraint in tests because setting it would require us to deploy a program each time."]; name: "mxeProgram"; }, { address: "11111111111111111111111111111111"; docs: ["System program account."]; name: "systemProgram"; }]; args: []; discriminator: [134, 126, 69, 42, 180, 144, 202, 165]; docs: ["Initializes a MPC Execution Environment (part 1).", "Due to Solana's 10KB per-instruction allocation limit, this only partially", "allocates recovery_cluster_acc. Call init_mxe_part2 afterwards to finish", "allocation and add keygen to mempool."]; name: "initMxePart1"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { docs: ["Cluster to add to the MXE."]; name: "cluster"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; }, { docs: ["MXE account to initialize."]; name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "mxeProgram"; }]; }; writable: true; }, { name: "recoveryClusterAcc"; 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"; }]; }; writable: true; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mxeKeygenComputationDefinition"; 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: "account"; path: "mxeProgram"; }, { kind: "const"; value: [1, 0, 0, 0]; }]; }; writable: true; }, { name: "mxeKeygenComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "arg"; path: "keygenOffset"; }]; }; writable: true; }, { name: "keyRecoveryInitComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "arg"; path: "keyRecoveryInitOffset"; }]; }; writable: true; }, { name: "mxeAuthority"; optional: true; }, { docs: ["constraint in tests because setting it would require us to deploy a program each time."]; name: "mxeProgram"; }, { docs: ["The seeds constraint is only applied in non-testing builds."]; name: "programData"; pda: { program: { kind: "const"; value: [2, 168, 246, 145, 78, 136, 161, 176, 226, 16, 21, 62, 247, 99, 174, 43, 0, 194, 185, 61, 22, 193, 36, 210, 192, 83, 122, 16, 4, 128, 0, 0]; }; seeds: [{ kind: "account"; path: "mxeProgram"; }]; }; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "recoveryPeers"; type: { array: ["u32", 100]; }; }, { name: "keygenOffset"; type: "u64"; }, { name: "keyRecoveryInitOffset"; type: "u64"; }]; discriminator: [70, 121, 251, 59, 255, 152, 202, 136]; docs: ["Finishes MXE initialization (part 2).", "Reallocates recovery_cluster_acc to full size, initializes recovery_peers,", "and adds the keygen computation to the mempool."]; name: "initMxePart2"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "operatorAcc"; pda: { seeds: [{ kind: "const"; value: [79, 112, 101, 114, 97, 116, 111, 114]; }, { kind: "account"; path: "signer"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "meta"; type: { defined: { name: "operatorMeta"; }; }; }]; discriminator: [132, 210, 12, 91, 159, 94, 35, 54]; name: "initOperator"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "compDefAcc"; 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: "compDefRaw"; 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, 82, 97, 119]; }, { kind: "account"; path: "compDefAcc"; }, { kind: "arg"; path: "rawCircuitIndex"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "rawCircuitIndex"; type: "u8"; }]; discriminator: [16, 228, 193, 228, 93, 231, 58, 4]; name: "initRawCircuitAcc"; }, { accounts: [{ name: "nodeAuthority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterId"; type: "u32"; }, { name: "nodeBump"; type: "u32"; }, { name: "join"; type: "bool"; }]; discriminator: [150, 167, 124, 239, 108, 128, 31, 162]; name: "joinCluster"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }]; discriminator: [225, 222, 68, 9, 96, 160, 126, 211]; name: "leaveMxe"; }, { accounts: [{ name: "nodeAuthority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "clusterOffset"; type: "u32"; }, { name: "nodeOffset"; type: "u32"; }, { name: "proposedFee"; type: "u64"; }]; discriminator: [103, 204, 172, 134, 248, 252, 27, 170]; name: "proposeFee"; }, { accounts: [{ name: "clusterAuthority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterId"; type: "u32"; }, { name: "nodeBump"; type: "u32"; }]; discriminator: [148, 228, 222, 211, 161, 128, 118, 175]; name: "proposeJoinCluster"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { docs: ["This is ok-ish though, as we're just reading the bump to verify the PDA."]; name: "signSeed"; pda: { program: { kind: "arg"; path: "mxeProgram"; }; seeds: [{ kind: "const"; value: [65, 114, 99, 105, 117, 109, 83, 105, 103, 110, 101, 114, 65, 99, 99, 111, 117, 110, 116]; }]; }; signer: true; }, { name: "comp"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"; }, { kind: "arg"; path: "computationOffset"; }]; }; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"; }]; }; writable: true; }, { name: "compDefAcc"; 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: "computationDefinitionOffset"; }]; }; }, { name: "cluster"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"; }]; }; writable: true; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "computationDefinitionOffset"; type: "u32"; }, { name: "clusterIndex"; type: { option: "u16"; }; }, { name: "args"; type: { defined: { name: "argumentList"; }; }; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "callbackUrl"; type: { option: "string"; }; }, { name: "customCallbackInstructions"; type: { vec: { defined: { name: "callbackInstruction"; }; }; }; }, { name: "callbackTransactionsRequired"; type: "u8"; }, { name: "outputDeliveryFee"; type: "u64"; }, { name: "cuPriceMicro"; type: "u64"; }]; discriminator: [1, 149, 103, 13, 102, 227, 93, 164]; docs: ["Queues a computation.", "cu_price_micro: The priority price of a CU, in thousandths of lamports. Used", "to calculate the priority fee and rounded down."]; name: "queueComputation"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { name: "recoveryClusterAcc"; 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: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "keyRecoveryInitComputationDefinition"; 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: "account"; path: "mxeProgram"; }, { kind: "const"; value: [2, 0, 0, 0]; }]; }; writable: true; }, { name: "keyRecoveryInitComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { account: "mxeAccount"; kind: "account"; path: "mxe.key_recovery_init_offset"; }]; }; writable: true; }, { name: "mxeProgram"; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "clusterOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }]; discriminator: [76, 132, 32, 81, 11, 163, 98, 82]; docs: ["Queues the key recovery init computation for the MXE.", "Can only be called once after MXE keys are set."]; name: "queueKeyRecoveryInit"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "comp"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "mxeProgram"; type: "pubkey"; }]; discriminator: [146, 230, 72, 249, 217, 144, 70, 33]; docs: ["Reclaim fees for an expired computation that was never executed."]; name: "reclaimExpiredComputationFee"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "failureAcc"; pda: { seeds: [{ kind: "const"; value: [70, 97, 105, 108, 117, 114, 101, 67, 108, 97, 105, 109, 65, 99, 99, 111, 117, 110, 116, 72, 101, 97, 100, 101, 114]; }, { kind: "arg"; path: "mxeProgram"; }, { kind: "arg"; path: "compOffset"; }]; }; writable: true; }]; args: [{ name: "compOffset"; type: "u64"; }, { name: "mxeProgram"; type: "pubkey"; }]; discriminator: [159, 99, 116, 180, 42, 9, 202, 219]; name: "reclaimFailureRent"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { name: "mxeProgram"; }]; args: [{ name: "mxeProgram"; type: "pubkey"; }]; discriminator: [65, 99, 9, 69, 97, 38, 105, 253]; docs: ["Sets an MXE to the Recovery state, enabling the recovery process to begin."]; name: "recoverMxe"; }, { accounts: [{ name: "authority"; signer: true; writable: true; }, { name: "payer"; signer: true; writable: true; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; }, { name: "backupMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "backupMxeProgram"; }]; }; }, { name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; writable: true; }, { name: "keyRecoveryFinalizeCompDef"; 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: "account"; path: "backupMxeProgram"; }, { kind: "const"; value: [3, 0, 0, 0]; }]; }; }, { docs: ["The previous failed computation account"]; name: "previousComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "account"; path: "mxeRecoveryAccount"; }]; }; }, { name: "newComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { kind: "arg"; path: "newKeyRecoveryFinalizeOffset"; }]; }; writable: true; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "poolAccount"; pda: { seeds: [{ kind: "const"; value: [70, 101, 101, 80, 111, 111, 108]; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }, { name: "clusterOffset"; type: "u32"; }, { name: "newKeyRecoveryFinalizeOffset"; type: "u64"; }]; discriminator: [131, 109, 226, 183, 90, 203, 17, 191]; docs: ["Re-queues the key_recovery_finalize computation after a failed execution."]; name: "requeueKeyRecoveryFinalize"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "mxeProgram"; }]; }; }, { name: "executingPool"; pda: { seeds: [{ kind: "const"; value: [69, 120, 101, 99, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "mempool"; pda: { seeds: [{ kind: "const"; value: [77, 101, 109, 112, 111, 111, 108]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "cluster"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; }, { name: "mxeKeygenComputation"; pda: { seeds: [{ kind: "const"; value: [67, 111, 109, 112, 117, 116, 97, 116, 105, 111, 110, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "clusterOffset"; }, { account: "mxeAccount"; kind: "account"; path: "mxe.keygen_offset"; }]; }; writable: true; }, { name: "mxeProgram"; }]; args: [{ name: "clusterOffset"; type: "u32"; }]; discriminator: [90, 98, 117, 181, 88, 71, 135, 30]; docs: ["Re-queues the MXE keygen computation if it has expired from the mempool.", "This allows retrying the keygen if it wasn't processed in time."]; name: "requeueMxeKeygen"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }]; args: [{ name: "nodeOffset"; type: "u32"; }, { name: "config"; type: { defined: { name: "arxNodeConfig"; }; }; }]; discriminator: [163, 75, 176, 148, 145, 196, 238, 234]; name: "setArxNodeConfig"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; writable: true; }]; args: [{ name: "nodeOffset"; type: "u32"; }, { name: "meta"; type: { defined: { name: "nodeMetadata"; }; }; }]; discriminator: [176, 88, 44, 90, 127, 151, 62, 80]; name: "setArxNodeMetadata"; }, { accounts: [{ docs: ["Signer of the transaction."]; name: "signer"; signer: true; writable: true; }, { docs: ["MXE account to set the cluster for."]; name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "mxeProgram"; }]; }; }, { docs: ["Cluster to set for the MXE."]; name: "cluster"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; }, { name: "mxeProgram"; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "clusterOffset"; type: "u32"; }]; discriminator: [140, 96, 38, 83, 225, 128, 25, 176]; name: "setCluster"; }, { accounts: [{ name: "currentAuthority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "id"; }]; }; writable: true; }]; args: [{ name: "clusterId"; type: "u32"; }, { name: "newAuthority"; type: { option: "pubkey"; }; }]; discriminator: [94, 172, 32, 75, 38, 40, 31, 106]; name: "setClusterAuthority"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }]; args: [{ name: "nodeOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "mxeX25519Pubkey"; type: { array: ["u8", 32]; }; }, { name: "mxeEd25519VerifyingKey"; type: { array: ["u8", 32]; }; }, { name: "mxeElgamalPubkey"; type: { array: ["u8", 32]; }; }, { name: "mxePubkeyValidityProof"; type: { array: ["u8", 64]; }; }]; discriminator: [156, 205, 125, 215, 134, 88, 62, 144]; name: "setMxeKeys"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "mxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "mxeProgram"; }]; }; writable: true; }, { name: "recoveryClusterAcc"; 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"; }]; }; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { account: "mxeAccount"; kind: "account"; path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? "; }]; }; writable: true; }]; 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]; }; }]; discriminator: [49, 89, 116, 64, 81, 250, 112, 64]; name: "setMxeRecoveryKeysInit"; }, { accounts: [{ name: "nodeAuthority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }]; args: [{ name: "clusterId"; type: "u32"; }, { name: "nodeBump"; type: "u32"; }, { name: "aggregatedBlsPubkey"; type: { defined: { name: "bn254g2blsPublicKey"; }; }; }]; discriminator: [192, 135, 47, 120, 63, 18, 232, 164]; name: "submitAggregatedBlsPubkey"; }, { accounts: [{ name: "nodeSigner"; signer: true; writable: true; }, { name: "node"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "originalMxe"; pda: { seeds: [{ kind: "const"; value: [77, 88, 69, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "arg"; path: "originalMxeProgram"; }]; }; }, { name: "recoveryClusterAcc"; 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: "originalMxeProgram"; }]; }; }, { name: "mxeRecoveryAccount"; pda: { seeds: [{ kind: "const"; value: [77, 120, 101, 82, 101, 99, 111, 118, 101, 114, 121, 65, 99, 99, 111, 117, 110, 116]; }, { kind: "account"; path: "backupMxeProgram"; }, { kind: "account"; path: "originalMxeProgram"; }]; }; writable: true; }, { name: "originalMxeProgram"; }, { name: "backupMxeProgram"; }]; args: [{ name: "originalMxeProgram"; type: "pubkey"; }, { name: "backupMxeProgram"; type: "pubkey"; }, { name: "nodeOffset"; type: "u32"; }, { name: "peerIndex"; type: "u32"; }, { name: "share"; type: { array: [{ array: ["u8", 32]; }, 5]; }; }]; discriminator: [108, 74, 123, 253, 76, 98, 190, 164]; docs: ["Submits a recovery share from a recovery peer.", "Each share contains RESCUE_KEY_COUNT (5) field elements of 32 bytes each."]; name: "submitKeyRecoveryShare"; }, { accounts: [{ name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: []; discriminator: [47, 73, 68, 127, 116, 74, 89, 62]; name: "updateCurrentEpochIdempotent"; }, { accounts: [{ name: "signer"; signer: true; writable: true; }, { name: "compDefAcc"; 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: "compDefRaw"; 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, 82, 97, 119]; }, { kind: "account"; path: "compDefAcc"; }, { kind: "arg"; path: "rawCircuitIndex"; }]; }; writable: true; }, { address: "11111111111111111111111111111111"; name: "systemProgram"; }]; args: [{ name: "compOffset"; type: "u32"; }, { name: "mxeProgram"; type: "pubkey"; }, { name: "rawCircuitIndex"; type: "u8"; }, { name: "uploadData"; type: { array: ["u8", 814]; }; }, { name: "offset"; type: "u32"; }]; discriminator: [86, 238, 214, 111, 30, 23, 168, 100]; name: "uploadCircuit"; }, { accounts: [{ name: "nodeAuthority"; signer: true; writable: true; }, { name: "clusterAcc"; pda: { seeds: [{ kind: "const"; value: [67, 108, 117, 115, 116, 101, 114]; }, { kind: "arg"; path: "clusterOffset"; }]; }; writable: true; }, { name: "arxNodeAcc"; pda: { seeds: [{ kind: "const"; value: [65, 114, 120, 78, 111, 100, 101]; }, { kind: "arg"; path: "nodeOffset"; }]; }; }, { name: "clock"; pda: { seeds: [{ kind: "const"; value: [67, 108, 111, 99, 107, 65, 99, 99, 111, 117, 110, 116]; }]; }; writable: true; }]; args: [{ name: "clusterOffset"; type: "u32"; }, { name: "nodeOffset"; type: "u32"; }, { name: "feeVote"; type: "u64"; }]; discriminator: [39, 118, 79, 185, 118, 12, 71, 84]; name: "voteFee"; }]

metadata

metadata: object

NameType
description"The Arcium program"
name"arcium"
spec"0.1.0"
version"0.6.2"

types

types: [{ name: "abortReason"; type: { kind: "enum"; variants: [{ name: "invalidMac"; }, { name: "expectedSentShare"; }, { name: "expectedFieldElement"; }, { name: "expectedAbort"; }, { name: "malformedData"; }, { name: "computationFailed"; }, { name: "internalError"; }, { name: "preprocessingStreamError"; }, { name: "divisionByZero"; }, { name: "noSignature"; }, { name: "invalidSignature"; }, { name: "primitiveError"; }, { name: "invalidBatchLength"; }, { name: "quadraticNonResidue"; }, { name: "bitConversionError"; }, { name: "channelClosed"; }, { name: "timeoutElapsed"; }]; }; }, { name: "acccountAccessInfo"; repr: { kind: "c"; }; serialization: "bytemuck"; type: { fields: [{ name: "inner"; type: "u16"; }]; kind: "struct"; }; }, { name: "accountArgument"; type: { fields: [{ name: "pubkey"; type: "pubkey"; }, { name: "offset"; type: "u32"; }, { name: "length"; type: "u32"; }]; kind: "struct"; }; }, { name: "activation"; type: { fields: [{ docs: ["epoch for the cluster was activated. Epoch::INFINITY if inactive."]; name: "activationEpoch"; type: { defined: { name: "epoch"; }; }; }, { docs: ["epoch for the cluster to be deactivated. Epoch::INFINITY if none."]; name: "deactivationEpoch"; type: { defined: { name: "epoch"; }; }; }]; kind: "struct"; }; }, { docs: ["Container for arguments that separates small inline values from large indexed data"]; name: "argumentList"; type: { fields: [{ name: "args"; type: { vec: { defined: { name: "argumentRef"; }; }; }; }, { name: "byteArrays"; type: { vec: { array: ["u8", 32]; }; }; }, { name: "plaintextNumbers"; type: { vec: "u64"; }; }, { name: "values128Bit"; type: { vec: "u128"; }; }, { name: "accounts"; type: { vec: { defined: { name: "accountArgument"; }; }; }; }]; kind: "struct"; }; }, { docs: ["A reference to an argument - stores small values that don't affect alignment inline and large", "values as indices."]; name: "argumentRef"; type: { kind: "enum"; variants: [{ fields: ["bool"]; name: "plaintextBool"; }, { fields: ["u8"]; name: "plaintextU8"; }, { fields: ["i8"]; name: "plaintextI8"; }, { fields: ["u8"]; name: "plaintextU16"; }, { fields: ["u8"]; name: "plaintextU32"; }, { fields: ["u8"]; name: "plaintextU64"; }, { fields: ["u8"]; name: "plaintextU128"; }, { fields: ["u8"]; name: "plaintextFloat"; }, { fields: ["u8"]; name: "encryptedBool"; }, { fields: ["u8"]; name: "encryptedU8"; }, { fields: ["u8"]; name: "encryptedU16"; }, { fields: ["u8"]; name: "encryptedU32"; }, { fields: ["u8"]; name: "encryptedU64"; }, { fields: ["u8"]; name: "encryptedU128"; }, { fields: ["u8"]; name: "encryptedFloat"; }, { fields: ["u8"]; name: "x25519Pubkey"; }, { fields: ["u8"]; name: "arcisEd25519Signature"; }, { fields: ["u8"]; name: "account"; }, { fields: ["u8"]; name: "plaintextI16"; }, { fields: ["u8"]; name: "plaintextI32"; }, { fields: ["u8"]; name: "plaintextI64"; }, { fields: ["u8"]; name: "plaintextI128"; }, { fields: ["u8"]; name: "encryptedI8"; }, { fields: ["u8"]; name: "encryptedI16"; }, { fields: ["u8"]; name: "encryptedI32"; }, { fields: ["u8"]; name: "encryptedI64"; }, { fields: ["u8"]; name: "encryptedI128"; }, { fields: ["u8"]; name: "plaintextPoint"; }]; }; }, { name: "arxNode"; type: { fields: [{ docs: ["X25519 public key for usage when being a key recovery peer. MUST BE AT byte index 8 - 40"]; name: "x25519Pubkey"; type: { array: ["u8", 32]; }; }, { name: "primaryStakingAccount"; type: "pubkey"; }, { name: "metadata"; type: { defined: { name: "nodeMetadata"; }; }; }, { name: "config"; type: { defined: { name: "arxNodeConfig"; }; }; }, { docs: ["The offsets of the cluster the node is a member of."]; name: "clusterMembership"; type: { defined: { name: "clusterMembership"; }; }; }, { name: "cuCapacityClaim"; type: "u64"; }, { name: "isActive"; type: "bool"; }, { docs: ["BLS public key for this node (64 bytes compressed G2 point for alt-bn128)"]; name: "blsPubkey"; type: { defined: { name: "bn254g2blsPublicKey"; }; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { name: "arxNodeConfig"; type: { fields: [{ docs: ["Admin key for node management operations"]; name: "authority"; type: "pubkey"; }, { docs: ["Key used to sign computation callbacks - separated for operational security"]; name: "callbackAuthority"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "bn254g2blsPublicKey"; type: { fields: [{ array: ["u8", 64]; }]; kind: "struct"; }; }, { docs: ["A callback account to be provided to a computation.", "We don't specify signer, since node operators can't sign."]; name: "callbackAccount"; type: { fields: [{ name: "pubkey"; type: "pubkey"; }, { name: "isWritable"; type: "bool"; }]; kind: "struct"; }; }, { name: "callbackComputationEvent"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "mxeProgramId"; type: "pubkey"; }]; kind: "struct"; }; }, { docs: ["A custom callback instruction with its own program ID and discriminator."]; name: "callbackInstruction"; type: { fields: [{ name: "programId"; type: "pubkey"; }, { name: "discriminator"; type: "bytes"; }, { name: "accounts"; type: { vec: { defined: { name: "callbackAccount"; }; }; }; }]; kind: "struct"; }; }, { name: "circuitSource"; type: { kind: "enum"; variants: [{ fields: [{ defined: { name: "localCircuitSource"; }; }]; name: "local"; }, { fields: [{ defined: { name: "onChainCircuitSource"; }; }]; name: "onChain"; }, { fields: [{ defined: { name: "offChainCircuitSource"; }; }]; name: "offChain"; }]; }; }, { name: "claimFailureEvent"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "mxeProgramId"; type: "pubkey"; }]; kind: "struct"; }; }, { docs: ["An account storing the current network epoch"]; name: "clockAccount"; type: { fields: [{ name: "startEpoch"; type: { defined: { name: "epoch"; }; }; }, { name: "currentEpoch"; type: { defined: { name: "epoch"; }; }; }, { name: "startEpochTimestamp"; type: { defined: { name: "timestamp"; }; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { name: "cluster"; type: { fields: [{ name: "tdInfo"; type: { option: { defined: { name: "nodeMetadata"; }; }; }; }, { name: "authority"; type: { option: "pubkey"; }; }, { name: "clusterSize"; type: "u16"; }, { name: "activation"; type: { defined: { name: "activation"; }; }; }, { name: "maxCapacity"; type: "u64"; }, { docs: ["The price of compute units in this cluster."]; name: "cuPrice"; type: "u64"; }, { docs: ["The proposals for the cu price proposals in the next epoch.", "Index 0 is always the current price, we allow `MAX_FEE_PROPS` at most."]; name: "cuPriceProposals"; type: { array: ["u64", 32]; }; }, { docs: ["The epoch this cluster was last updated.", "Used to determine if the cluster needs to be updated."]; name: "lastUpdatedEpoch"; type: { defined: { name: "epoch"; }; }; }, { name: "nodes"; type: { vec: { defined: { name: "nodeRef"; }; }; }; }, { name: "pendingNodes"; type: { vec: "u32"; }; }, { 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"]; name: "blsPublicKey"; type: { defined: { generics: [{ kind: "type"; type: { defined: ...; }; }]; name: "setUnset"; }; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { name: "clusterMembership"; type: { kind: "enum"; variants: [{ name: "inactive"; }, { fields: ["u32"]; name: "active"; }, { fields: ["u32"]; name: "proposed"; }]; }; }, { docs: ["A computation execution call to a [super::mxe::ComputationDefinitionAccount]."]; name: "computationAccount"; type: { fields: [{ name: "payer"; type: "pubkey"; }, { docs: ["The program ID of the MXE that this computation is associated with."]; name: "mxeProgramId"; type: "pubkey"; }, { docs: ["The offset of the corresponding [super::mxe::ComputationDefinitionAccount]."]; name: "computationDefinitionOffset"; type: "u32"; }, { docs: ["The execution fee for the execution."]; name: "executionFee"; type: { defined: { name: "executionFee"; }; }; }, { name: "slot"; type: "u64"; }, { name: "slotCounter"; type: "u16"; }, { name: "status"; type: { defined: { name: "computationStatus"; }; }; }, { docs: ["The MXE's cluster to be used for execution.", "", "# Notes", "", "- [None] represents the default cluster,", "- [Some] specifies the index of the fallback cluster."]; name: "clusterIndex"; type: { option: "u16"; }; }, { name: "arguments"; type: { defined: { name: "argumentList"; }; }; }, { name: "callbackUrl"; type: { option: "string"; }; }, { name: "customCallbackInstructions"; type: { vec: { defined: { name: "callbackInstruction"; }; }; }; }, { name: "callbackTransactionsRequired"; type: "u8"; }, { name: "callbackTransactionsSubmittedBm"; type: "u16"; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { docs: ["An account representing a [ComputationDefinition] in a MXE."]; name: "computationDefinitionAccount"; type: { fields: [{ docs: ["The authority that is allowed to finalize a computation execution (callback).", "This is distinct from `upload_auth` (in `OnChainCircuitSource`) which controls the", "computation definition lifecycle (uploading/finalizing the definition itself).", "If set to None, anyone can finalize the computation execution."]; name: "finalizationAuthority"; type: { option: "pubkey"; }; }, { docs: ["The amount of CUs this computation will use."]; name: "cuAmount"; type: "u64"; }, { docs: ["The interface of the computation to execute."]; name: "definition"; type: { defined: { name: "computationDefinitionMeta"; }; }; }, { docs: ["Where to fetch the actual raw circuit to execute."]; name: "circuitSource"; type: { defined: { name: "circuitSource"; }; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { docs: ["A computation definition for execution in a MXE."]; name: "computationDefinitionMeta"; type: { fields: [{ name: "circuitLen"; type: "u32"; }, { name: "signature"; type: { defined: { name: "computationSignature"; }; }; }]; kind: "struct"; }; }, { name: "computationDefinitionRaw"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "bump"; type: "u8"; }, { docs: ["The length here is meaningless."]; name: "compiledCircuit"; type: { array: ["u8", 0]; }; }]; kind: "struct"; }; }, { name: "computationReference"; repr: { kind: "c"; }; serialization: "bytemuck"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "priorityFee"; type: "u64"; }, { name: "accs"; type: { array: [{ defined: { name: "acccountAccessInfo"; }; }, 12]; }; }]; kind: "struct"; }; }, { docs: ["The signature of a computation defined in a [ComputationDefinition]."]; name: "computationSignature"; type: { fields: [{ docs: ["The input parameters of the computation."]; name: "parameters"; type: { vec: { defined: { name: "parameter"; }; }; }; }, { docs: ["The output(s) of the computation."]; name: "outputs"; type: { vec: { defined: { name: "output"; }; }; }; }]; kind: "struct"; }; }, { name: "computationStatus"; type: { kind: "enum"; variants: [{ name: "queued"; }, { name: "finalized"; }]; }; }, { docs: ["The network epoch"]; name: "epoch"; type: { fields: ["u64"]; kind: "struct"; }; }, { generics: [{ kind: "const"; name: "maxParrallelComputations"; type: "usize"; }]; name: "executingPool"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "bump"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 7]; }; }, { name: "counter"; type: "u64"; }, { name: "execpoolIndex"; type: { array: ["u64", { generic: "maxParrallelComputations"; }]; }; }, { name: "currentlyExecuting"; type: { array: [{ defined: { name: "computationReference"; }; }, { generic: "maxParrallelComputations"; }]; }; }]; kind: "struct"; }; }, { name: "executionFailure"; type: { kind: "enum"; variants: [{ name: "serialization"; }, { name: "router"; }, { name: "circuit"; }, { name: "inputs"; }, { name: "protocolInit"; }, { name: "protocolRun"; }, { fields: [{ defined: { name: "abortReason"; }; }]; name: "abort"; }]; }; }, { name: "executionFee"; type: { fields: [{ docs: ["The base fee for the computation."]; name: "baseFee"; type: "u64"; }, { docs: ["The additional fee to enforce priortized execution in the mempool."]; name: "priorityFee"; type: "u64"; }, { docs: ["A fee for output delivery fees (i.e. tx fees)."]; name: "outputDeliveryFee"; type: "u64"; }]; kind: "struct"; }; }, { name: "executionStatus"; type: { kind: "enum"; variants: [{ name: "success"; }, { fields: [{ defined: { name: "executionFailure"; }; }, { array: ["u8", 32]; }]; name: "failure"; }]; }; }, { name: "failureClaimAccountHeader"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "bump"; type: "u8"; }, { name: "isComplete"; type: "bool"; }, { name: "padding"; type: { array: ["u8", 6]; }; }, { name: "challengeEndSlot"; type: "u64"; }, { name: "poster"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "feePool"; type: { fields: [{ name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { name: "finalizeComputationEvent"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "mxeProgramId"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "finalizeFailureDataEvent"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "mxeProgramId"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "initComputationEvent"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "mxeProgramId"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "largeExecPool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { generics: [{ kind: "const"; value: "100"; }]; name: "executingPool"; }; }; }]; kind: "struct"; }; }, { name: "largeMempool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { name: "largeMempoolInner"; }; }; }]; kind: "struct"; }; }, { name: "largeMempoolInner"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "lastUpdatedSlot"; type: "u64"; }, { name: "slotCounter"; type: "u16"; }, { name: "bump"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 5]; }; }, { name: "computations"; type: { defined: { name: "largeMempoolInnerBuffer"; }; }; }]; kind: "struct"; }; }, { name: "largeMempoolInnerBuffer"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "elems"; type: { array: [{ defined: { name: "largeMempoolInnerBufferHeap"; }; }, 180]; }; }, { docs: ["Bit array tracking which slots are valid (1 = valid, 0 = stale)", "1 bit per slot, packed into bytes. For $buffer_length=180, this is 23 bytes."]; name: "validBits"; type: { array: ["u8", 23]; }; }, { name: "startIndex"; type: "u8"; }, { name: "length"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 7]; }; }]; kind: "struct"; }; }, { name: "largeMempoolInnerBufferHeap"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "entries"; type: { array: [{ defined: { name: "computationReference"; }; }, 100]; }; }, { name: "count"; type: "u16"; }, { name: "padding"; type: { array: ["u8", 6]; }; }]; kind: "struct"; }; }, { name: "localCircuitSource"; type: { kind: "enum"; variants: [{ name: "mxeKeygen"; }, { name: "mxeKeyRecoveryInit"; }, { name: "mxeKeyRecoveryFinalize"; }]; }; }, { docs: ["A MPC Execution Environment."]; name: "mxeAccount"; type: { fields: [{ docs: ["The cluster executing the MXE."]; name: "cluster"; type: { option: "u32"; }; }, { docs: ["The offset used for the keygen computation account.", "Stored so requeue_mxe_keygen can find the computation account."]; name: "keygenOffset"; type: "u64"; }, { docs: ["The offset used for the key recovery init computation account.", "Stored so queue_key_recovery_init can find the computation account."]; name: "keyRecoveryInitOffset"; type: "u64"; }, { docs: ["The program ID of the program that this MXE is associated with. Needed so that when we", "index this account offchain we can find out what program it is associated with."]; name: "mxeProgramId"; type: "pubkey"; }, { docs: ["The management authority of the MXE."]; name: "authority"; type: { option: "pubkey"; }; }, { docs: ["The utility pubkeys, consisting of", "- x25519 pubkey (32 bytes), used for key exchange", "- ed25519 verifying key (32 bytes), used for signature verification", "- ElGamal pubkey (32 bytes), used for c-spl", "- ElGamal pubkey validity proof (64 bytes), used for c-spl"]; name: "utilityPubkeys"; type: { defined: { generics: [{ kind: "type"; type: { defined: ...; }; }]; name: "setUnset"; }; }; }, { docs: ["Fallback clusters that can execute this MXE as an alternative to the", "[MXEAccount::cluster]. There can be a maximum of [MAX_FALLBACK_CLUSTERS]", "fallback clusters."]; name: "fallbackClusters"; type: { vec: "u32"; }; }, { docs: ["The clusters that have rejected this MXE."]; name: "rejectedClusters"; type: { vec: "u32"; }; }, { docs: ["The offsets of all [ComputationDefinitionAccount]s of this MXE."]; name: "computationDefinitions"; type: { vec: "u32"; }; }, { docs: ["The status of this MXE (Active or Recovery)."]; name: "status"; type: { defined: { name: "mxeStatus"; }; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { name: "mediumExecPool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { generics: [{ kind: "const"; value: "10"; }]; name: "executingPool"; }; }; }]; kind: "struct"; }; }, { name: "mediumMempool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { name: "mediumMempoolInner"; }; }; }]; kind: "struct"; }; }, { name: "mediumMempoolInner"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "lastUpdatedSlot"; type: "u64"; }, { name: "slotCounter"; type: "u16"; }, { name: "bump"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 5]; }; }, { name: "computations"; type: { defined: { name: "mediumMempoolInnerBuffer"; }; }; }]; kind: "struct"; }; }, { name: "mediumMempoolInnerBuffer"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "elems"; type: { array: [{ defined: { name: "mediumMempoolInnerBufferHeap"; }; }, 180]; }; }, { docs: ["Bit array tracking which slots are valid (1 = valid, 0 = stale)", "1 bit per slot, packed into bytes. For $buffer_length=180, this is 23 bytes."]; name: "validBits"; type: { array: ["u8", 23]; }; }, { name: "startIndex"; type: "u8"; }, { name: "length"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 7]; }; }]; kind: "struct"; }; }, { name: "mediumMempoolInnerBufferHeap"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "entries"; type: { array: [{ defined: { name: "computationReference"; }; }, 10]; }; }, { name: "count"; type: "u16"; }, { name: "padding"; type: { array: ["u8", 6]; }; }]; kind: "struct"; }; }, { name: "mempoolSize"; type: { kind: "enum"; variants: [{ name: "tiny"; }, { name: "small"; }, { name: "medium"; }, { name: "large"; }]; }; }, { docs: ["Account for tracking key recovery execution state.", "PDA seeds: ["mxe_recovery", backup_mxe_pubkey, original_mxe_pubkey]"]; name: "mxeRecoveryAccount"; repr: { kind: "c"; }; serialization: "bytemuck"; type: { fields: [{ docs: ["The computation offset for the queued key_recovery_finalize circuit."]; name: "keyRecoveryFinalizeOffset"; type: "u64"; }, { docs: ["The shares submitted by recovery peers. Each peer submits RESCUE_KEY_COUNT (5) field", "elements. Each field element is 32 bytes. Zeros indicate not yet uploaded."]; name: "shares"; type: { array: [{ array: [{ array: ...; }, 5]; }, 100]; }; }, { name: "originalMxePubkey"; type: "pubkey"; }, { name: "backupMxePubkey"; type: "pubkey"; }, { docs: ["Whether the recovery has been finalized (threshold met and marked ready)."]; name: "isFinalized"; type: "u8"; }, { docs: ["Padding to ensure struct size is u64 aligned (6 bytes)"]; name: "padding2"; type: { array: ["u8", 6]; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { docs: ["The status of an MXE."]; name: "mxeStatus"; type: { kind: "enum"; variants: [{ name: "active"; }, { name: "recovery"; }]; }; }, { docs: ["location as [ISO 3166-1 alpha-2](https://www.iso.org/iso-3166-country-codes.html) country code"]; name: "nodeMetadata"; type: { fields: [{ docs: ["[Ipv4Addr], represented by it's 4 octects"]; name: "ip"; type: { array: ["u8", 4]; }; }, { docs: ["Needed for MPC protocol"]; name: "peerId"; type: { array: ["u8", 32]; }; }, { name: "location"; type: "u8"; }]; kind: "struct"; }; }, { 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."]; name: "nodeRef"; type: { fields: [{ name: "offset"; type: "u32"; }, { docs: ["Current total rewards the node has received in the current epoch in lamports."]; name: "currentTotalRewards"; type: "u64"; }, { name: "vote"; type: "u8"; }]; kind: "struct"; }; }, { name: "offChainCircuitSource"; type: { fields: [{ name: "source"; type: "string"; }, { name: "hash"; type: { array: ["u8", 32]; }; }]; kind: "struct"; }; }, { name: "onChainCircuitSource"; type: { fields: [{ docs: ["Specifies if the circuit for this computation has been fully uploaded,", "as this can take multiple transactions due to the circuit size."]; name: "isCompleted"; type: "bool"; }, { docs: ["The authority that is allowed to upload circuit data and finalize the computation", "definition. This controls the definition lifecycle, distinct from", "`finalization_authority` (in `ComputationDefinitionAccount`) which controls computation", "execution finalization."]; name: "uploadAuth"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "operator"; type: { fields: [{ name: "nodeOffsets"; type: { vec: "u32"; }; }, { name: "meta"; type: { defined: { name: "operatorMeta"; }; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { docs: ["location as [ISO 3166-1 alpha-2](https://www.iso.org/iso-3166-country-codes.html) country code"]; name: "operatorMeta"; type: { fields: [{ docs: ["URL should point to a JSON containing the following fields:", "- `name`: String, the name of the operator", "- `description`: String, a description of the operator", "- `icon`: String, a URL to an icon representing the operator", "- `url`: String, a URL to the operator's website"]; name: "url"; type: "string"; }, { name: "location"; type: "u8"; }]; kind: "struct"; }; }, { docs: ["An output of a computation.", "We currently don't support encrypted outputs yet since encrypted values are passed via", "data objects."]; name: "output"; type: { kind: "enum"; variants: [{ name: "plaintextBool"; }, { name: "plaintextU8"; }, { name: "plaintextU16"; }, { name: "plaintextU32"; }, { name: "plaintextU64"; }, { name: "plaintextU128"; }, { name: "ciphertext"; }, { name: "arcisX25519Pubkey"; }, { name: "plaintextFloat"; }, { name: "plaintextPoint"; }, { name: "plaintextI8"; }, { name: "plaintextI16"; }, { name: "plaintextI32"; }, { name: "plaintextI64"; }, { name: "plaintextI128"; }]; }; }, { docs: ["A parameter of a computation.", "We differentiate between plaintext and encrypted parameters and data objects.", "Plaintext parameters are directly provided as their value.", "Encrypted parameters are provided as an offchain reference to the data.", "Data objects are provided as a reference to the data object account."]; name: "parameter"; type: { kind: "enum"; variants: [{ name: "plaintextBool"; }, { name: "plaintextU8"; }, { name: "plaintextU16"; }, { name: "plaintextU32"; }, { name: "plaintextU64"; }, { name: "plaintextU128"; }, { name: "ciphertext"; }, { name: "arcisX25519Pubkey"; }, { name: "arcisSignature"; }, { name: "plaintextFloat"; }, { name: "plaintextI8"; }, { name: "plaintextI16"; }, { name: "plaintextI32"; }, { name: "plaintextI64"; }, { name: "plaintextI128"; }, { name: "plaintextPoint"; }]; }; }, { name: "queueComputationEvent"; type: { fields: [{ name: "computationOffset"; type: "u64"; }, { name: "mxeProgramId"; type: "pubkey"; }]; kind: "struct"; }; }, { name: "recoveryClusterAccount"; repr: { kind: "c"; }; serialization: "bytemuck"; type: { fields: [{ docs: ["The offsets of nodes in our key recovery cluster. 0 means null in this context.", "DO NOT PUT ANYTHING BEFORE THE RECOVERY_PEERS FIELD, IT'S EXPECTED TO BE AT OFFSET 8."]; name: "recoveryPeers"; type: { array: ["u32", 100]; }; }, { name: "recoveryKeyMaterial"; type: { defined: { name: "recoveryKeyMaterial"; }; }; }, { name: "padding"; type: { array: ["u8", 2]; }; }, { name: "bump"; type: "u8"; }]; kind: "struct"; }; }, { name: "recoveryKeyMaterial"; repr: { kind: "c"; }; serialization: "bytemuck"; type: { fields: [{ name: "nonce"; type: { array: ["u8", 16]; }; }, { name: "encryptedMxeKeys"; type: { array: [{ array: ["u8", 32]; }, 13]; }; }, { name: "keyMaterialHash"; type: { array: ["u8", 32]; }; }, { name: "recoveryKeyshares"; type: { array: [{ array: [{ array: ...; }, 5]; }, 100]; }; }, { name: "blsSig"; type: { array: ["u8", 64]; }; }, { name: "status"; type: "u8"; }]; kind: "struct"; }; }, { docs: ["Utility struct to store a value that needs to be set by a certain number of participants (keys", "in our case). Once all participants have set the value, the value is considered set and we only", "store it once."]; generics: [{ kind: "type"; name: "t"; }]; name: "setUnset"; type: { kind: "enum"; variants: [{ fields: [{ generic: "t"; }]; name: "set"; }, { fields: [{ generic: "t"; }, { vec: "bool"; }]; name: "unset"; }]; }; }, { name: "smallExecPool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { generics: [{ kind: "const"; value: "3"; }]; name: "executingPool"; }; }; }]; kind: "struct"; }; }, { name: "smallMempool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { name: "smallMempoolInner"; }; }; }]; kind: "struct"; }; }, { name: "smallMempoolInner"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "lastUpdatedSlot"; type: "u64"; }, { name: "slotCounter"; type: "u16"; }, { name: "bump"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 5]; }; }, { name: "computations"; type: { defined: { name: "smallMempoolInnerBuffer"; }; }; }]; kind: "struct"; }; }, { name: "smallMempoolInnerBuffer"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "elems"; type: { array: [{ defined: { name: "smallMempoolInnerBufferHeap"; }; }, 180]; }; }, { docs: ["Bit array tracking which slots are valid (1 = valid, 0 = stale)", "1 bit per slot, packed into bytes. For $buffer_length=180, this is 23 bytes."]; name: "validBits"; type: { array: ["u8", 23]; }; }, { name: "startIndex"; type: "u8"; }, { name: "length"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 7]; }; }]; kind: "struct"; }; }, { name: "smallMempoolInnerBufferHeap"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "entries"; type: { array: [{ defined: { name: "computationReference"; }; }, 3]; }; }, { name: "count"; type: "u16"; }, { name: "padding"; type: { array: ["u8", 6]; }; }]; kind: "struct"; }; }, { name: "timestamp"; type: { fields: [{ name: "timestamp"; type: "u64"; }]; kind: "struct"; }; }, { name: "tinyExecPool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { generics: [{ kind: "const"; value: "1"; }]; name: "executingPool"; }; }; }]; kind: "struct"; }; }, { name: "tinyMempool"; repr: { kind: "transparent"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "inner"; type: { defined: { name: "tinyMempoolInner"; }; }; }]; kind: "struct"; }; }, { name: "tinyMempoolInner"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "lastUpdatedSlot"; type: "u64"; }, { name: "slotCounter"; type: "u16"; }, { name: "bump"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 5]; }; }, { name: "computations"; type: { defined: { name: "tinyMempoolInnerBuffer"; }; }; }]; kind: "struct"; }; }, { name: "tinyMempoolInnerBuffer"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "elems"; type: { array: [{ defined: { name: "tinyMempoolInnerBufferHeap"; }; }, 180]; }; }, { docs: ["Bit array tracking which slots are valid (1 = valid, 0 = stale)", "1 bit per slot, packed into bytes. For $buffer_length=180, this is 23 bytes."]; name: "validBits"; type: { array: ["u8", 23]; }; }, { name: "startIndex"; type: "u8"; }, { name: "length"; type: "u8"; }, { name: "padding"; type: { array: ["u8", 7]; }; }]; kind: "struct"; }; }, { name: "tinyMempoolInnerBufferHeap"; repr: { kind: "c"; }; serialization: "bytemuckunsafe"; type: { fields: [{ name: "entries"; type: { array: [{ defined: { name: "computationReference"; }; }, 1]; }; }, { name: "count"; type: "u16"; }, { name: "padding"; type: { array: ["u8", 6]; }; }]; kind: "struct"; }; }, { name: "utilityPubkeys"; type: { fields: [{ name: "x25519Pubkey"; type: { array: ["u8", 32]; }; }, { name: "ed25519VerifyingKey"; type: { array: ["u8", 32]; }; }, { name: "elgamalPubkey"; type: { array: ["u8", 32]; }; }, { name: "pubkeyValidityProof"; type: { array: ["u8", 64]; }; }]; kind: "struct"; }; }]

Packer

Previous Page

ArciumLocalEnv

Next Page

On this page

Properties
accounts
address
errors
events
instructions
metadata
types