@arcium-hq/client 0.6.5 → 0.7.0

package/build/index.cjs

@@ -1809,7 +1809,7 @@ function createPacker(fields, typeName = 'Packer') {
 var address = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
 var metadata = {
 	name: "arcium",
-	version: "0.6.5",
+	version: "0.7.0",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -4065,6 +4065,29 @@ var instructions = [
 					]
 				}
 			},
+			{
+				name: "cluster_acc",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
+			},
 			{
 				name: "executing_pool",
 				writable: true,
@@ -4153,6 +4176,17 @@ var instructions = [
 			{
 				name: "callback_transaction_index",
 				type: "u8"
+			},
+			{
+				name: "bls_sig",
+				type: {
+					option: {
+						array: [
+							"u8",
+							64
+						]
+					}
+				}
 			}
 		]
 	},
@@ -5244,6 +5278,17 @@ var instructions = [
 					]
 				}
 			},
+			{
+				name: "address_lookup_table",
+				docs: [
+					"Seeds are checked in the CPI to LUT program, so no need to check them here."
+				],
+				writable: true
+			},
+			{
+				name: "lut_program",
+				address: "AddressLookupTab1e1111111111111111111111111"
+			},
 			{
 				name: "comp_def_acc",
 				writable: true,
@@ -5358,6 +5403,11 @@ var instructions = [
 			224
 		],
 		accounts: [
+			{
+				name: "authority",
+				writable: true,
+				signer: true
+			},
 			{
 				name: "payer",
 				writable: true,
@@ -6155,6 +6205,17 @@ var instructions = [
 					]
 				}
 			},
+			{
+				name: "address_lookup_table",
+				docs: [
+					"Seeds are checked in the CPI to LUT program, so no need to check them here."
+				],
+				writable: true
+			},
+			{
+				name: "lut_program",
+				address: "AddressLookupTab1e1111111111111111111111111"
+			},
 			{
 				name: "clock",
 				writable: true,
@@ -6210,6 +6271,10 @@ var instructions = [
 			{
 				name: "key_recovery_init_offset",
 				type: "u64"
+			},
+			{
+				name: "recent_offset",
+				type: "u64"
 			}
 		]
 	},
@@ -6514,91 +6579,6 @@ var instructions = [
 			}
 		]
 	},
-	{
-		name: "leave_mxe",
-		discriminator: [
-			225,
-			222,
-			68,
-			9,
-			96,
-			160,
-			126,
-			211
-		],
-		accounts: [
-			{
-				name: "authority",
-				writable: true,
-				signer: true
-			},
-			{
-				name: "cluster_acc",
-				writable: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								67,
-								108,
-								117,
-								115,
-								116,
-								101,
-								114
-							]
-						},
-						{
-							kind: "arg",
-							path: "_id"
-						}
-					]
-				}
-			},
-			{
-				name: "mxe",
-				writable: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								77,
-								88,
-								69,
-								65,
-								99,
-								99,
-								111,
-								117,
-								110,
-								116
-							]
-						},
-						{
-							kind: "arg",
-							path: "_mxe_program"
-						}
-					]
-				}
-			},
-			{
-				name: "system_program",
-				address: "11111111111111111111111111111111"
-			}
-		],
-		args: [
-			{
-				name: "cluster_offset",
-				type: "u32"
-			},
-			{
-				name: "mxe_program",
-				type: "pubkey"
-			}
-		]
-	},
 	{
 		name: "propose_fee",
 		discriminator: [
@@ -6903,8 +6883,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						},
 						{
 							kind: "arg",
@@ -6958,8 +6939,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -6982,8 +6964,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -7054,8 +7037,9 @@ var instructions = [
 							]
 						},
 						{
-							kind: "arg",
-							path: "cluster_index.map_or(mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? , | i |\nmxe.fallback_clusters [i as usize])"
+							kind: "account",
+							path: "mxe.cluster.ok_or(ArciumError :: ClusterNotSet) ? ",
+							account: "MXEAccount"
 						}
 					]
 				}
@@ -7119,12 +7103,6 @@ var instructions = [
 				name: "computation_definition_offset",
 				type: "u32"
 			},
-			{
-				name: "cluster_index",
-				type: {
-					option: "u16"
-				}
-			},
 			{
 				name: "args",
 				type: {
@@ -7137,12 +7115,6 @@ var instructions = [
 				name: "mxe_program",
 				type: "pubkey"
 			},
-			{
-				name: "callback_url",
-				type: {
-					option: "string"
-				}
-			},
 			{
 				name: "custom_callback_instructions",
 				type: {
@@ -7533,16 +7505,16 @@ var instructions = [
 		]
 	},
 	{
-		name: "reclaim_failure_rent",
+		name: "reclaim_failure_rent_idempotent",
 		discriminator: [
-			159,
-			99,
-			116,
-			180,
-			42,
-			9,
-			202,
-			219
+			138,
+			13,
+			253,
+			191,
+			226,
+			239,
+			246,
+			10
 		],
 		accounts: [
 			{
@@ -7550,51 +7522,19 @@ var instructions = [
 				writable: true,
 				signer: true
 			},
+			{
+				name: "recipient",
+				docs: [
+					"failure PDA"
+				],
+				writable: true
+			},
 			{
 				name: "failure_acc",
-				writable: true,
-				pda: {
-					seeds: [
-						{
-							kind: "const",
-							value: [
-								70,
-								97,
-								105,
-								108,
-								117,
-								114,
-								101,
-								67,
-								108,
-								97,
-								105,
-								109,
-								65,
-								99,
-								99,
-								111,
-								117,
-								110,
-								116,
-								72,
-								101,
-								97,
-								100,
-								101,
-								114
-							]
-						},
-						{
-							kind: "arg",
-							path: "mxe_program"
-						},
-						{
-							kind: "arg",
-							path: "comp_offset"
-						}
-					]
-				}
+				docs: [
+					"the checks and close by hand in the instruction handler."
+				],
+				writable: true
 			}
 		],
 		args: [
@@ -9691,6 +9631,19 @@ var events = [
 			186
 		]
 	},
+	{
+		name: "KeyRecoveryEvent",
+		discriminator: [
+			83,
+			147,
+			226,
+			153,
+			39,
+			242,
+			109,
+			254
+		]
+	},
 	{
 		name: "QueueComputationEvent",
 		discriminator: [
@@ -9831,6 +9784,11 @@ var errors = [
 		name: "InvalidCallbackIndex",
 		msg: "Invalid callback transaction index"
 	},
+	{
+		code: 6212,
+		name: "MultiTxCallbacksDisabled",
+		msg: "Multi-transaction callbacks disabled"
+	},
 	{
 		code: 6300,
 		name: "ComputationDefinitionNotCompleted",
@@ -10150,6 +10108,11 @@ var errors = [
 		code: 6715,
 		name: "ArithmeticOverflow",
 		msg: "Arithmetic overflow"
+	},
+	{
+		code: 6716,
+		name: "MxeInRecoveryState",
+		msg: "MXE is in recovery state, cannot queue new computations"
 	}
 ];
 var types = [
@@ -10970,20 +10933,6 @@ var types = [
 						}
 					}
 				},
-				{
-					name: "cluster_index",
-					docs: [
-						"The MXE's cluster to be used for execution.",
-						"",
-						"# Notes",
-						"",
-						"- [None] represents the default cluster,",
-						"- [Some] specifies the index of the fallback cluster."
-					],
-					type: {
-						option: "u16"
-					}
-				},
 				{
 					name: "arguments",
 					type: {
@@ -10992,12 +10941,6 @@ var types = [
 						}
 					}
 				},
-				{
-					name: "callback_url",
-					type: {
-						option: "string"
-					}
-				},
 				{
 					name: "custom_callback_instructions",
 					type: {
@@ -11320,6 +11263,16 @@ var types = [
 							}
 						}
 					]
+				},
+				{
+					name: "KeyRecoveryFailure",
+					fields: [
+						{
+							defined: {
+								name: "KeyRecoveryFailureReason"
+							}
+						}
+					]
 				}
 			]
 		}
@@ -11477,6 +11430,58 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "KeyRecoveryEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "computation_offset",
+					type: "u64"
+				},
+				{
+					name: "mxe_program_id",
+					type: "pubkey"
+				},
+				{
+					name: "backup_mxe_program_id",
+					type: "pubkey"
+				}
+			]
+		}
+	},
+	{
+		name: "KeyRecoveryFailureReason",
+		type: {
+			kind: "enum",
+			variants: [
+				{
+					name: "KeysDigestMismatch"
+				},
+				{
+					name: "X25519PubkeyMismatch"
+				},
+				{
+					name: "Ed25519VerifyingKeyMismatch"
+				},
+				{
+					name: "ElGamalPubkeyMismatch"
+				},
+				{
+					name: "TooManyCorruptPeers"
+				},
+				{
+					name: "Serialization"
+				},
+				{
+					name: "NoPubkeysSet"
+				},
+				{
+					name: "AccountNotFound"
+				}
+			]
+		}
+	},
 	{
 		name: "LargeExecPool",
 		serialization: "bytemuckunsafe",
@@ -11750,24 +11755,8 @@ var types = [
 					}
 				},
 				{
-					name: "fallback_clusters",
-					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."
-					],
-					type: {
-						vec: "u32"
-					}
-				},
-				{
-					name: "rejected_clusters",
-					docs: [
-						"The clusters that have rejected this MXE."
-					],
-					type: {
-						vec: "u32"
-					}
+					name: "lut_offset_slot",
+					type: "u64"
 				},
 				{
 					name: "computation_definitions",
@@ -13055,6 +13044,11 @@ const RECOVERY_CLUSTER_ACC_SEED = 'RecoveryClusterAccount';
  * @constant {string}
  */
 const MXE_RECOVERY_ACC_SEED = 'MxeRecoveryAccount';
+/**
+ * Seed for ComputationDefinitionRaw PDA
+ * @constant {string}
+ */
+const RAW_CIRCUIT_ACC_SEED = 'ComputationDefinitionRaw';
 /**
  * Maximum number of bytes that can be reallocated per instruction.
  * @constant {number}
@@ -13214,6 +13208,32 @@ function getMxeRecoveryAccAddress(backupMxeProgramId, originalMxeProgramId) {
     ];
     return generateArciumPDAFrom(seeds)[0];
 }
+/**
+ * Derives the raw circuit account address for a given computation definition and index.
+ * @param compDefPubkey - The public key of the computation definition account.
+ * @param rawCircuitIndex - The index of the raw circuit account (0-based).
+ * @returns The derived raw circuit account public key.
+ */
+function getRawCircuitAccAddress(compDefPubkey, rawCircuitIndex) {
+    const seeds = [
+        Buffer.from(RAW_CIRCUIT_ACC_SEED),
+        compDefPubkey.toBuffer(),
+        Buffer.from([rawCircuitIndex]),
+    ];
+    return generateArciumPDAFrom(seeds)[0];
+}
+/**
+ * Derives the address lookup table address for an MXE program.
+ * @param mxeProgramId - The public key of the MXE program.
+ * @param lutOffset - The index of the lookup table, to be fetched from the mxe account.
+ * @returns The derived address lookup table public key.
+ */
+function getLookupTableAddress(mxeProgramId, lutOffset) {
+    const mxeAccount = getMXEAccAddress(mxeProgramId);
+    const lutIndexBuffer = lutOffset.toArrayLike(Buffer, 'le', 8);
+    const seeds = [mxeAccount.toBuffer(), lutIndexBuffer];
+    return web3_js.PublicKey.findProgramAddressSync(seeds, web3_js.AddressLookupTableProgram.programId)[0];
+}
 /**
  * Generates a program-derived address (PDA) from the provided seeds and the Arcium program ID.
  * @param seeds - An array of Buffer seeds used for PDA derivation.
@@ -13466,6 +13486,21 @@ async function getMXEPublicKey(provider, mxeProgramId) {
 async function getMXEArcisEd25519VerifyingKey(provider, mxeProgramId) {
     return getMXEUtilityKey(provider, mxeProgramId, 'ed25519VerifyingKey');
 }
+/**
+ * Determines the current state of a circuit based on its on-chain configuration.
+ * @internal Called internally by `uploadCircuit` - most users don't need this directly.
+ * @param circuitSource - The circuitSource field from ComputationDefinitionAccount.
+ * @returns The current state of the circuit.
+ */
+function getCircuitState(circuitSource) {
+    if (!('onChain' in circuitSource) || !circuitSource.onChain) {
+        return 'Offchain';
+    }
+    if (circuitSource.onChain[0].isCompleted) {
+        return 'OnchainFinalized';
+    }
+    return 'OnchainPending';
+}
 /**
  * Uploads a circuit to the blockchain, splitting it into multiple accounts if necessary.
  * @param provider - The Anchor provider to use for transactions.
@@ -13477,10 +13512,17 @@ async function getMXEArcisEd25519VerifyingKey(provider, mxeProgramId) {
  * @returns An array of transaction signatures for all upload and finalize transactions.
  */
 async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, logging = true, chunkSize = 500) {
-    // 9 = 8-byte discriminator + 1-byte bump for ComputationDefinitionRaw account
-    const numAccs = Math.ceil(rawCircuit.length / (MAX_ACCOUNT_SIZE - 9));
     const compDefAccInfo = getCompDefAccInfo(circuitName, mxeProgramId);
     const program = getArciumProgram(provider);
+    const compDefAcc = await program.account.computationDefinitionAccount.fetch(compDefAccInfo.pubkey);
+    // Type assertion at boundary where Anchor's fetch() returns the account data
+    const state = getCircuitState(compDefAcc.circuitSource);
+    if (state !== 'OnchainPending') {
+        optionalLog(logging, `Circuit ${circuitName} skipped: ${state}`);
+        return [];
+    }
+    // 9 = 8-byte discriminator + 1-byte bump for ComputationDefinitionRaw account
+    const numAccs = Math.ceil(rawCircuit.length / (MAX_ACCOUNT_SIZE - 9));
     const sigs = [];
     const uploadPromises = [];
     for (let i = 0; i < numAccs; i++) {
@@ -13523,15 +13565,26 @@ async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramId) {
         .transaction();
 }
 async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramId, shouldLog = true, chunkSize = 500) {
+    const rawCircuitPda = getRawCircuitAccAddress(compDefAccInfo.pubkey, rawCircuitIndex);
+    const existingAcc = await provider.connection.getAccountInfo(rawCircuitPda);
+    // Skip entirely if account exists with correct size (pre-seeded at genesis or already uploaded)
+    // Account layout: 8-byte discriminator + 1-byte bump + circuit data
+    const requiredAccountSize = rawCircuitPart.length + 9;
+    if (existingAcc !== null && existingAcc.data.length >= requiredAccountSize) {
+        optionalLog(shouldLog, `Raw circuit acc ${rawCircuitIndex} already exists with sufficient size, skipping`);
+        return [];
+    }
     const sigs = [];
-    const initTx = await program.methods
-        .initRawCircuitAcc(compDefAccInfo.offset, mxeProgramId, rawCircuitIndex)
-        .accounts({
-        signer: provider.publicKey,
-    })
-        .rpc();
-    optionalLog(shouldLog, `Initiated raw circuit acc with raw circuit index ${rawCircuitIndex}`);
-    sigs.push(initTx);
+    if (existingAcc === null) {
+        const initTx = await program.methods
+            .initRawCircuitAcc(compDefAccInfo.offset, mxeProgramId, rawCircuitIndex)
+            .accounts({
+            signer: provider.publicKey,
+        })
+            .rpc();
+        optionalLog(shouldLog, `Initiated raw circuit acc with raw circuit index ${rawCircuitIndex}`);
+        sigs.push(initTx);
+    }
     if (rawCircuitPart.length > MAX_REALLOC_PER_IX) {
         // We only need to add size if the init didn't already make us big enough
         const nonAsyncTxCount = Math.ceil(rawCircuitPart.length / (MAX_REALLOC_PER_IX * MAX_EMBIGGEN_IX_PER_TX));
@@ -13556,8 +13609,10 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
     const blockInfo = await provider.connection.getLatestBlockhash();
     for (let i = 0; i < remainingTxCount; i += chunkSize) {
         optionalLog(shouldLog, `Sending chunk ${i / chunkSize + 1} of ${Math.ceil(remainingTxCount / chunkSize)}`);
-        const chunkPromises = []; // Array to hold promises for the current chunk
-        const currentChunkSize = Math.min(chunkSize, remainingTxCount - i); // Handle the last chunk
+        // Array to hold promises for the current chunk
+        const chunkPromises = [];
+        // Handle the last chunk
+        const currentChunkSize = Math.min(chunkSize, remainingTxCount - i);
         for (let j = 0; j < currentChunkSize; j++) {
             const offset = MAX_UPLOAD_PER_TX_BYTES * (i + j);
             // eslint-disable-next-line no-await-in-loop
@@ -13567,7 +13622,8 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
         // Wait for the current chunk to complete before proceeding
         // eslint-disable-next-line no-await-in-loop
         const chunkResults = await Promise.all(chunkPromises);
-        remainingTxs.push(...chunkResults); // Add the results of the current chunk to the main array
+        // Add the results of the current chunk to the main array
+        remainingTxs.push(...chunkResults);
         optionalLog(shouldLog, `Done sending chunk ${i / chunkSize + 1} of ${Math.ceil(remainingTxCount / chunkSize)}`);
     }
     return sigs.concat(remainingTxs);
@@ -13744,22 +13800,22 @@ async function submitKeyRecoveryShare(provider, originalMxeProgramId, backupMxeP
 }
 /**
  * Finalizes key recovery execution after the submission threshold is met.
- * This queues the key_recovery_final MPC computation on the backup cluster.
+ * This queues the key_recovery_finalize MPC computation on the backup cluster.
  * @param provider - The Anchor provider to use for transactions.
  * @param originalMxeProgramId - The public key of the original MXE program being recovered.
  * @param backupMxeProgramId - The public key of the backup MXE program.
  * @param clusterOffset - The cluster offset where the backup MXE is deployed.
- * @param keyRecoveryFinalOffset - The computation offset for the key_recovery_final computation.
+ * @param keyRecoveryFinalizeOffset - The computation offset for the key_recovery_finalize computation.
  * @returns The transaction signature.
  */
-async function finalizeKeyRecoveryExecution(provider, originalMxeProgramId, backupMxeProgramId, clusterOffset, keyRecoveryFinalOffset) {
+async function finalizeKeyRecoveryExecution(provider, originalMxeProgramId, backupMxeProgramId, clusterOffset, keyRecoveryFinalizeOffset) {
     const program = getArciumProgram(provider);
     const tx = await program.methods
         .finalizeKeyRecoveryExecution(originalMxeProgramId, backupMxeProgramId, clusterOffset)
         .accountsPartial({
         authority: provider.publicKey,
         payer: provider.publicKey,
-        keyRecoveryFinalizeComputation: getComputationAccAddress(clusterOffset, keyRecoveryFinalOffset),
+        keyRecoveryFinalizeComputation: getComputationAccAddress(clusterOffset, keyRecoveryFinalizeOffset),
         executingPool: getExecutingPoolAccAddress(clusterOffset),
         mempool: getMempoolAccAddress(clusterOffset),
         originalMxeProgram: originalMxeProgramId,
@@ -13800,7 +13856,7 @@ async function initMxePart1(provider, mxeProgramId) {
  * @param mxeAuthority - Optional authority for the MXE (defaults to provider.publicKey).
  * @returns The transaction signature.
  */
-async function initMxePart2(provider, clusterOffset, mxeProgramId, recoveryPeers, keygenOffset, keyRecoveryInitOffset, mxeAuthority) {
+async function initMxePart2(provider, clusterOffset, mxeProgramId, recoveryPeers, keygenOffset, keyRecoveryInitOffset, lutOffset, mxeAuthority) {
     const program = getArciumProgram(provider);
     // Ensure recoveryPeers has exactly 100 elements
     const paddedRecoveryPeers = [...recoveryPeers];
@@ -13811,12 +13867,13 @@ async function initMxePart2(provider, clusterOffset, mxeProgramId, recoveryPeers
         throw new Error('recoveryPeers must have at most 100 elements');
     }
     const tx = await program.methods
-        .initMxePart2(clusterOffset, mxeProgramId, paddedRecoveryPeers, keygenOffset, keyRecoveryInitOffset)
+        .initMxePart2(clusterOffset, mxeProgramId, paddedRecoveryPeers, keygenOffset, keyRecoveryInitOffset, lutOffset)
         .accountsPartial({
         signer: provider.publicKey,
         mxeProgram: mxeProgramId,
         poolAccount: getFeePoolAccAddress(),
         mxeAuthority: mxeAuthority ?? provider.publicKey,
+        addressLookupTable: getLookupTableAddress(mxeProgramId, lutOffset),
     })
         .transaction();
     return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
@@ -13913,6 +13970,7 @@ exports.getArciumEnv = getArciumEnv;
 exports.getArciumProgram = getArciumProgram;
 exports.getArciumProgramId = getArciumProgramId;
 exports.getArxNodeAccAddress = getArxNodeAccAddress;
+exports.getCircuitState = getCircuitState;
 exports.getClockAccAddress = getClockAccAddress;
 exports.getClusterAccAddress = getClusterAccAddress;
 exports.getCompDefAccAddress = getCompDefAccAddress;
@@ -13922,6 +13980,7 @@ exports.getComputationsInMempool = getComputationsInMempool;
 exports.getExecutingPoolAccAddress = getExecutingPoolAccAddress;
 exports.getExecutingPoolAccInfo = getExecutingPoolAccInfo;
 exports.getFeePoolAccAddress = getFeePoolAccAddress;
+exports.getLookupTableAddress = getLookupTableAddress;
 exports.getMXEAccAddress = getMXEAccAddress;
 exports.getMXEArcisEd25519VerifyingKey = getMXEArcisEd25519VerifyingKey;
 exports.getMXEPublicKey = getMXEPublicKey;
@@ -13929,6 +13988,7 @@ exports.getMempoolAccAddress = getMempoolAccAddress;
 exports.getMempoolAccInfo = getMempoolAccInfo;
 exports.getMempoolPriorityFeeStats = getMempoolPriorityFeeStats;
 exports.getMxeRecoveryAccAddress = getMxeRecoveryAccAddress;
+exports.getRawCircuitAccAddress = getRawCircuitAccAddress;
 exports.getRecoveryClusterAccAddress = getRecoveryClusterAccAddress;
 exports.initKeyRecoveryExecution = initKeyRecoveryExecution;
 exports.initMxePart1 = initMxePart1;