@arcium-hq/client 0.6.4 → 0.6.6

package/README.md

@@ -180,7 +180,7 @@ await uploadCircuit(
   "your_circuit_name",
   program.programId,
   rawCircuit,
-  true // use raw circuit
+  true // enable logging
 );
 ```
 

package/build/index.cjs

@@ -1809,7 +1809,7 @@ function createPacker(fields, typeName = 'Packer') {
 var address = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
 var metadata = {
 	name: "arcium",
-	version: "0.6.4",
+	version: "0.6.6",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -2904,6 +2904,107 @@ var instructions = [
 			}
 		]
 	},
+	{
+		name: "claim_node_fees",
+		discriminator: [
+			68,
+			13,
+			185,
+			34,
+			151,
+			76,
+			194,
+			43
+		],
+		accounts: [
+			{
+				name: "node_authority",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "recipient",
+				writable: true
+			},
+			{
+				name: "cluster",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								67,
+								108,
+								117,
+								115,
+								116,
+								101,
+								114
+							]
+						},
+						{
+							kind: "arg",
+							path: "cluster_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "node",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								65,
+								114,
+								120,
+								78,
+								111,
+								100,
+								101
+							]
+						},
+						{
+							kind: "arg",
+							path: "node_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "pool",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								70,
+								101,
+								101,
+								80,
+								111,
+								111,
+								108
+							]
+						}
+					]
+				}
+			}
+		],
+		args: [
+			{
+				name: "cluster_offset",
+				type: "u32"
+			},
+			{
+				name: "node_offset",
+				type: "u32"
+			}
+		]
+	},
 	{
 		name: "close_key_recovery",
 		docs: [
@@ -3964,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,
@@ -4052,6 +4176,17 @@ var instructions = [
 			{
 				name: "callback_transaction_index",
 				type: "u8"
+			},
+			{
+				name: "bls_sig",
+				type: {
+					option: {
+						array: [
+							"u8",
+							64
+						]
+					}
+				}
 			}
 		]
 	},
@@ -5143,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,
@@ -5257,6 +5403,11 @@ var instructions = [
 			224
 		],
 		accounts: [
+			{
+				name: "authority",
+				writable: true,
+				signer: true
+			},
 			{
 				name: "payer",
 				writable: true,
@@ -6054,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,
@@ -7036,12 +7198,6 @@ var instructions = [
 				name: "mxe_program",
 				type: "pubkey"
 			},
-			{
-				name: "callback_url",
-				type: {
-					option: "string"
-				}
-			},
 			{
 				name: "custom_callback_instructions",
 				type: {
@@ -7432,16 +7588,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: [
 			{
@@ -7449,51 +7605,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: [
@@ -9590,6 +9714,19 @@ var events = [
 			186
 		]
 	},
+	{
+		name: "KeyRecoveryEvent",
+		discriminator: [
+			83,
+			147,
+			226,
+			153,
+			39,
+			242,
+			109,
+			254
+		]
+	},
 	{
 		name: "QueueComputationEvent",
 		discriminator: [
@@ -9730,6 +9867,11 @@ var errors = [
 		name: "InvalidCallbackIndex",
 		msg: "Invalid callback transaction index"
 	},
+	{
+		code: 6212,
+		name: "MultiTxCallbacksDisabled",
+		msg: "Multi-transaction callbacks disabled"
+	},
 	{
 		code: 6300,
 		name: "ComputationDefinitionNotCompleted",
@@ -9960,6 +10102,16 @@ var errors = [
 		name: "MustNotBeCalledViaCpi",
 		msg: "This instruction must be called directly, not via CPI"
 	},
+	{
+		code: 6621,
+		name: "FeePriceExceedsMax",
+		msg: "Fee price exceeds maximum allowed"
+	},
+	{
+		code: 6622,
+		name: "NoFeesToClaim",
+		msg: "No fees available to claim"
+	},
 	{
 		code: 6700,
 		name: "MxeNotInRecoveryState",
@@ -10042,8 +10194,8 @@ var errors = [
 	},
 	{
 		code: 6716,
-		name: "FeePriceExceedsMax",
-		msg: "Fee price exceeds maximum allowed"
+		name: "MxeInRecoveryState",
+		msg: "MXE is in recovery state, cannot queue new computations"
 	}
 ];
 var types = [
@@ -10886,12 +11038,6 @@ var types = [
 						}
 					}
 				},
-				{
-					name: "callback_url",
-					type: {
-						option: "string"
-					}
-				},
 				{
 					name: "custom_callback_instructions",
 					type: {
@@ -11371,6 +11517,26 @@ 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: "LargeExecPool",
 		serialization: "bytemuckunsafe",
@@ -12949,6 +13115,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}
@@ -13108,6 +13279,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 lutIndex - The index of the lookup table (defaults to 0).
+ * @returns The derived address lookup table public key.
+ */
+function getLookupTableAddress(mxeProgramId, lutIndex = 0) {
+    const mxeAccount = getMXEAccAddress(mxeProgramId);
+    const lutIndexBuffer = new anchor__namespace.BN(lutIndex).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.
@@ -13360,6 +13557,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.
@@ -13371,10 +13583,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++) {
@@ -13417,15 +13636,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));
@@ -13450,8 +13680,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
@@ -13461,7 +13693,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);
@@ -13711,6 +13944,7 @@ async function initMxePart2(provider, clusterOffset, mxeProgramId, recoveryPeers
         mxeProgram: mxeProgramId,
         poolAccount: getFeePoolAccAddress(),
         mxeAuthority: mxeAuthority ?? provider.publicKey,
+        addressLookupTable: getLookupTableAddress(mxeProgramId),
     })
         .transaction();
     return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
@@ -13807,6 +14041,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;
@@ -13816,6 +14051,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;
@@ -13823,6 +14059,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;