@arcium-hq/client 0.8.3 → 0.8.5

package/build/index.cjs

@@ -1809,7 +1809,7 @@ function createPacker(fields, typeName = 'Packer') {
 var address = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
 var metadata = {
 	name: "arcium",
-	version: "0.8.3",
+	version: "0.8.5",
 	spec: "0.1.0",
 	description: "The Arcium program"
 };
@@ -6468,6 +6468,85 @@ var instructions = [
 			}
 		]
 	},
+	{
+		name: "init_recovery_peer_account",
+		discriminator: [
+			116,
+			29,
+			20,
+			126,
+			177,
+			149,
+			50,
+			147
+		],
+		accounts: [
+			{
+				name: "signer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "recovery_peer_account",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								82,
+								101,
+								99,
+								111,
+								118,
+								101,
+								114,
+								121,
+								80,
+								101,
+								101,
+								114,
+								65,
+								99,
+								99,
+								111,
+								117,
+								110,
+								116
+							]
+						},
+						{
+							kind: "arg",
+							path: "peer_offset"
+						}
+					]
+				}
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "peer_offset",
+				type: "u32"
+			},
+			{
+				name: "authority",
+				type: "pubkey"
+			},
+			{
+				name: "x25519_pubkey",
+				type: {
+					array: [
+						"u8",
+						32
+					]
+				}
+			}
+		]
+	},
 	{
 		name: "join_cluster",
 		discriminator: [
@@ -8840,29 +8919,41 @@ var instructions = [
 		],
 		accounts: [
 			{
-				name: "node_signer",
+				name: "signer",
 				writable: true,
 				signer: true
 			},
 			{
-				name: "node",
+				name: "recovery_peer_account",
 				pda: {
 					seeds: [
 						{
 							kind: "const",
 							value: [
-								65,
+								82,
+								101,
+								99,
+								111,
+								118,
+								101,
 								114,
-								120,
-								78,
+								121,
+								80,
+								101,
+								101,
+								114,
+								65,
+								99,
+								99,
 								111,
-								100,
-								101
+								117,
+								110,
+								116
 							]
 						},
 						{
 							kind: "arg",
-							path: "node_offset"
+							path: "peer_offset"
 						}
 					]
 				}
@@ -8987,7 +9078,7 @@ var instructions = [
 				type: "pubkey"
 			},
 			{
-				name: "node_offset",
+				name: "peer_offset",
 				type: "u32"
 			},
 			{
@@ -9512,6 +9603,19 @@ var accounts = [
 			183
 		]
 	},
+	{
+		name: "RecoveryPeerAccount",
+		discriminator: [
+			126,
+			243,
+			17,
+			238,
+			223,
+			222,
+			130,
+			120
+		]
+	},
 	{
 		name: "SmallExecPool",
 		discriminator: [
@@ -10483,7 +10587,7 @@ var types = [
 				{
 					name: "x25519_pubkey",
 					docs: [
-						"X25519 public key for usage when being a key recovery peer. MUST BE AT byte index 8 - 40"
+						"X25519 public key. MUST BE AT byte index 8 - 40"
 					],
 					type: {
 						array: [
@@ -12090,7 +12194,7 @@ var types = [
 				{
 					name: "ip",
 					docs: [
-						"[Ipv4Addr], represented by it's 4 octects"
+						"`Ipv4Addr`, represented by its 4 octets"
 					],
 					type: {
 						array: [
@@ -12505,6 +12609,38 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "RecoveryPeerAccount",
+		serialization: "bytemuck",
+		repr: {
+			kind: "c"
+		},
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "authority",
+					type: "pubkey"
+				},
+				{
+					name: "x25519_pubkey",
+					docs: [
+						"DO NOT PUT ANYTHING ELSE BEFORE THE X25519_PUBKEY FIELD, IT'S EXPECTED TO BE AT OFFSET 40."
+					],
+					type: {
+						array: [
+							"u8",
+							32
+						]
+					}
+				},
+				{
+					name: "bump",
+					type: "u8"
+				}
+			]
+		}
+	},
 	{
 		name: "SetUnset",
 		docs: [
@@ -13469,19 +13605,19 @@ async function getMXEUtilityKey(provider, mxeProgramId, field) {
     return null;
 }
 /**
- * Fetches and extracts the MXE x25519 public key from the MXE account.
+ * Fetches and extracts the MXE X25519 public key from the MXE account.
  * @param provider - The Anchor provider to use for fetching accounts.
  * @param mxeProgramId - The public key of the MXE program.
- * @returns The MXE's x25519 public key as a Uint8Array, or null if not set.
+ * @returns The MXE's X25519 public key as a Uint8Array, or null if not set.
  */
 async function getMXEPublicKey(provider, mxeProgramId) {
     return getMXEUtilityKey(provider, mxeProgramId, 'x25519Pubkey');
 }
 /**
- * Fetches and extracts the MXE arcis ed25519 verifying key from the MXE account.
+ * Fetches and extracts the MXE arcis Ed25519 verifying key from the MXE account.
  * @param provider - The Anchor provider to use for fetching accounts.
  * @param mxeProgramId - The public key of the MXE program.
- * @returns The MXE's arcis ed25519 verifying key as a Uint8Array, or null if not set.
+ * @returns The MXE's arcis Ed25519 verifying key as a Uint8Array, or null if not set.
  */
 async function getMXEArcisEd25519VerifyingKey(provider, mxeProgramId) {
     return getMXEUtilityKey(provider, mxeProgramId, 'ed25519VerifyingKey');
@@ -13511,7 +13647,7 @@ function getCircuitState(circuitSource) {
  * @param chunkSize - The number of upload transactions to send in parallel (default: 500).
  * @returns An array of transaction signatures for all upload and finalize transactions.
  */
-async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, logging = true, chunkSize = 500) {
+async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, logging = true, chunkSize = 500, confirmOptions) {
     const compDefAccInfo = getCompDefAccInfo(circuitName, mxeProgramId);
     const program = getArciumProgram(provider);
     const compDefAcc = await program.account.computationDefinitionAccount.fetch(compDefAccInfo.pubkey);
@@ -13526,11 +13662,11 @@ async function uploadCircuit(provider, circuitName, mxeProgramId, rawCircuit, lo
     const sigs = [];
     const uploadPromises = [];
     for (let i = 0; i < numAccs; i++) {
-        uploadPromises.push(uploadToCircuitAcc(provider, program, rawCircuit.subarray(i * (MAX_ACCOUNT_SIZE - 9), (i + 1) * (MAX_ACCOUNT_SIZE - 9)), i, compDefAccInfo, mxeProgramId, logging, chunkSize));
+        uploadPromises.push(uploadToCircuitAcc(provider, program, rawCircuit.subarray(i * (MAX_ACCOUNT_SIZE - 9), (i + 1) * (MAX_ACCOUNT_SIZE - 9)), i, compDefAccInfo, mxeProgramId, logging, chunkSize, confirmOptions));
     }
     sigs.push(...(await Promise.all(uploadPromises)).flat());
     const finalizeCompDefTx = await buildFinalizeCompDefTx(provider, compDefAccInfo.offset, mxeProgramId);
-    sigs.push(await signAndSendWithBlockhash(provider, finalizeCompDefTx, await provider.connection.getLatestBlockhash()));
+    sigs.push(await signAndSendWithBlockhash(provider, finalizeCompDefTx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions));
     return sigs;
 }
 async function queueKeyRecoveryInit(provider, clusterOffset, mxeProgramId, confirmOptions) {
@@ -13564,7 +13700,7 @@ async function buildFinalizeCompDefTx(provider, compDefOffset, mxeProgramId) {
     })
         .transaction();
 }
-async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramId, shouldLog = true, chunkSize = 500) {
+async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitIndex, compDefAccInfo, mxeProgramId, shouldLog = true, chunkSize = 500, confirmOptions) {
     const rawCircuitPda = getRawCircuitAccAddress(compDefAccInfo.pubkey, rawCircuitIndex);
     const existingAcc = await provider.connection.getAccountInfo(rawCircuitPda);
     // Skip entirely if account exists with correct size (pre-seeded at genesis or already uploaded)
@@ -13594,10 +13730,10 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
             const tx = await buildResizeTx(program, provider.publicKey, compDefAccInfo, mxeProgramId, rawCircuitIndex, MAX_REALLOC_PER_IX
                 + i * (MAX_REALLOC_PER_IX * MAX_EMBIGGEN_IX_PER_TX), rawCircuitPart.length);
             // eslint-disable-next-line no-await-in-loop
-            const blockInfo = await provider.connection.getLatestBlockhash();
+            const blockInfo = await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' });
             sigs.push(
             // eslint-disable-next-line no-await-in-loop
-            await signAndSendWithBlockhash(provider, tx, blockInfo));
+            await signAndSendWithBlockhash(provider, tx, blockInfo, confirmOptions));
             optionalLog(shouldLog, `Sent resize tx ${i} of ${nonAsyncTxCount}`);
         }
     }
@@ -13606,7 +13742,7 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
     const remainingTxCount = Math.ceil(rawCircuitPart.length / MAX_UPLOAD_PER_TX_BYTES);
     optionalLog(shouldLog, `Sending ${remainingTxCount} upload txs`);
     const remainingTxs = [];
-    const blockInfo = await provider.connection.getLatestBlockhash();
+    const blockInfo = await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' });
     for (let i = 0; i < remainingTxCount; i += chunkSize) {
         optionalLog(shouldLog, `Sending chunk ${i / chunkSize + 1} of ${Math.ceil(remainingTxCount / chunkSize)}`);
         // Array to hold promises for the current chunk
@@ -13617,7 +13753,7 @@ async function uploadToCircuitAcc(provider, program, rawCircuitPart, rawCircuitI
             const offset = MAX_UPLOAD_PER_TX_BYTES * (i + j);
             // eslint-disable-next-line no-await-in-loop
             const tx = await buildUploadCircuitTx(program, provider.publicKey, compDefAccInfo, mxeProgramId, Buffer.copyBytesFrom(rawCircuitPart, offset, MAX_UPLOAD_PER_TX_BYTES), offset, rawCircuitIndex);
-            chunkPromises.push(signAndSendWithBlockhash(provider, tx, blockInfo));
+            chunkPromises.push(signAndSendWithBlockhash(provider, tx, blockInfo, confirmOptions));
         }
         // Wait for the current chunk to complete before proceeding
         // eslint-disable-next-line no-await-in-loop
@@ -13720,7 +13856,7 @@ function getCompDefAccPDA(arciumProgramId, mxeProgramId, offset) {
  * @param mxeProgramId - The public key of the MXE program to recover.
  * @returns The transaction signature.
  */
-async function recoverMxe(provider, mxeProgramId) {
+async function recoverMxe(provider, mxeProgramId, confirmOptions) {
     const program = getArciumProgram(provider);
     const tx = await program.methods
         .recoverMxe(mxeProgramId)
@@ -13729,7 +13865,7 @@ async function recoverMxe(provider, mxeProgramId) {
         mxeProgram: mxeProgramId,
     })
         .transaction();
-    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
 /**
  * Initializes key recovery execution by creating the MxeRecoveryAccount and
@@ -13740,7 +13876,7 @@ async function recoverMxe(provider, mxeProgramId) {
  * @param backupMxeProgramId - The public key of the backup MXE program that will take over.
  * @returns The transaction signature from part2.
  */
-async function initKeyRecoveryExecution(provider, originalMxeProgramId, backupMxeProgramId) {
+async function initKeyRecoveryExecution(provider, originalMxeProgramId, backupMxeProgramId, confirmOptions) {
     // Part 1: Create MxeRecoveryAccount with partial size
     const program = getArciumProgram(provider);
     const tx1 = await program.methods
@@ -13751,7 +13887,7 @@ async function initKeyRecoveryExecution(provider, originalMxeProgramId, backupMx
         backupMxeProgram: backupMxeProgramId,
     })
         .transaction();
-    await signAndSendWithBlockhash(provider, tx1, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    await signAndSendWithBlockhash(provider, tx1, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
     // Part 2: Reallocate to full size and create computation definition
     const tx2 = await program.methods
         .initKeyRecoveryExecutionPart2(originalMxeProgramId, backupMxeProgramId)
@@ -13762,21 +13898,21 @@ async function initKeyRecoveryExecution(provider, originalMxeProgramId, backupMx
         backupMxeProgram: backupMxeProgramId,
     })
         .transaction();
-    return signAndSendWithBlockhash(provider, tx2, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    return signAndSendWithBlockhash(provider, tx2, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
 /**
  * Submits a re-encrypted key recovery share from a recovery peer.
- * Recovery peers must decrypt shares using their X25519 private key and re-encrypt
+ * Recovery peers must decrypt shares using their x25519 private key and re-encrypt
  * them for the backup MXE before submission.
  * @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 nodeOffset - The ARX node offset of the recovery peer.
+ * @param peerOffset - The offset of the recovery peer.
  * @param peerIndex - The index of this peer in the recovery peers list.
  * @param share - The re-encrypted share: 5 field elements of 32 bytes each (160 bytes total).
  * @returns The transaction signature.
  */
-async function submitKeyRecoveryShare(provider, originalMxeProgramId, backupMxeProgramId, nodeOffset, peerIndex, share) {
+async function submitKeyRecoveryShare(provider, originalMxeProgramId, backupMxeProgramId, peerOffset, peerIndex, share, confirmOptions) {
     const program = getArciumProgram(provider);
     // Convert to array of 5 elements, each 32 bytes
     const shareArrays = share.map(elem => Array.from(elem));
@@ -13789,14 +13925,14 @@ async function submitKeyRecoveryShare(provider, originalMxeProgramId, backupMxeP
         }
     }
     const tx = await program.methods
-        .submitKeyRecoveryShare(originalMxeProgramId, backupMxeProgramId, nodeOffset, peerIndex, shareArrays)
+        .submitKeyRecoveryShare(originalMxeProgramId, backupMxeProgramId, peerOffset, peerIndex, shareArrays)
         .accountsPartial({
-        nodeSigner: provider.publicKey,
+        signer: provider.publicKey,
         originalMxeProgram: originalMxeProgramId,
         backupMxeProgram: backupMxeProgramId,
     })
         .transaction();
-    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
 /**
  * Finalizes key recovery execution after the submission threshold is met.
@@ -13808,7 +13944,7 @@ async function submitKeyRecoveryShare(provider, originalMxeProgramId, backupMxeP
  * @param keyRecoveryFinalizeOffset - The computation offset for the key_recovery_finalize computation.
  * @returns The transaction signature.
  */
-async function finalizeKeyRecoveryExecution(provider, originalMxeProgramId, backupMxeProgramId, clusterOffset, keyRecoveryFinalizeOffset) {
+async function finalizeKeyRecoveryExecution(provider, originalMxeProgramId, backupMxeProgramId, clusterOffset, keyRecoveryFinalizeOffset, confirmOptions) {
     const program = getArciumProgram(provider);
     const tx = await program.methods
         .finalizeKeyRecoveryExecution(originalMxeProgramId, backupMxeProgramId, clusterOffset)
@@ -13822,7 +13958,7 @@ async function finalizeKeyRecoveryExecution(provider, originalMxeProgramId, back
         backupMxeProgram: backupMxeProgramId,
     })
         .transaction();
-    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
 /**
  * Initializes an MXE (part 1). Due to Solana's 10KB per-instruction allocation limit,
@@ -13832,7 +13968,7 @@ async function finalizeKeyRecoveryExecution(provider, originalMxeProgramId, back
  * @param mxeProgramId - The public key to use as the MXE program ID.
  * @returns The transaction signature.
  */
-async function initMxePart1(provider, mxeProgramId) {
+async function initMxePart1(provider, mxeProgramId, confirmOptions) {
     const program = getArciumProgram(provider);
     const tx = await program.methods
         .initMxePart1()
@@ -13841,7 +13977,7 @@ async function initMxePart1(provider, mxeProgramId) {
         mxeProgram: mxeProgramId,
     })
         .transaction();
-    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
 /**
  * Finishes MXE initialization (part 2).
@@ -13856,7 +13992,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, lutOffset, mxeAuthority) {
+async function initMxePart2(provider, clusterOffset, mxeProgramId, recoveryPeers, keygenOffset, keyRecoveryInitOffset, lutOffset, mxeAuthority, confirmOptions) {
     const program = getArciumProgram(provider);
     // Ensure recoveryPeers has exactly 100 elements
     const paddedRecoveryPeers = [...recoveryPeers];
@@ -13876,7 +14012,7 @@ async function initMxePart2(provider, clusterOffset, mxeProgramId, recoveryPeers
         addressLookupTable: getLookupTableAddress(mxeProgramId, lutOffset),
     })
         .transaction();
-    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: 'confirmed' }));
+    return signAndSendWithBlockhash(provider, tx, await provider.connection.getLatestBlockhash({ commitment: confirmOptions?.commitment || 'confirmed' }), confirmOptions);
 }
 
 /**
@@ -13903,38 +14039,78 @@ function getArciumEnv() {
     }
 }
 
+const POLL_INTERVAL_MS = 500;
 /**
- * Waits for the finalization of a computation by listening for the finalizeComputationEvent.
- * Resolves with the transaction signature once the computation is finalized.
- * @param provider - The Anchor provider to use for event listening.
- * @param computationOffset - The offset of the computation to wait for.
- * @param mxeProgramId - The public key of the MXE program.
- * @param commitment - (Optional) The desired finality/commitment level (default: 'confirmed').
- * @returns The transaction signature of the finalization event.
+ * Waits for a computation to finalize by polling the computation account
+ * status via HTTP RPC. Does not use WebSocket subscriptions.
+ *
+ * Polls every 500ms (same as Agave's send_and_confirm_transaction_with_config).
+ * Returns the most recent transaction signature on the computation account
+ * once finalization is detected.
+ *
+ * @param provider - The Anchor provider.
+ * @param computationOffset - The computation offset to wait for.
+ * @param mxeProgramId - The MXE program public key.
+ * @param commitment - Commitment level for RPC calls (default: 'confirmed').
+ * @param timeoutMs - Maximum wait time in milliseconds (default: 120000).
+ * @returns The transaction signature from the finalization.
+ * @throws Error if the MXE account has no cluster assigned.
+ * @throws Error if the computation does not finalize within timeoutMs.
  */
-async function awaitComputationFinalization(provider, computationOffset, mxeProgramId, commitment = 'confirmed') {
+async function awaitComputationFinalization(provider, computationOffset, mxeProgramId, commitment = 'confirmed', timeoutMs = 120_000) {
+    const conn = provider.connection;
     const arciumProgram = getArciumProgram(provider);
-    const eventListener = new anchor.EventManager(arciumProgram.programId, provider, arciumProgram.coder);
-    const finalizeComp = await awaitEvent(eventListener, 'finalizeComputationEvent', (e) => mxeProgramId.equals(e.mxeProgramId) && e.computationOffset.eq(computationOffset), commitment);
-    return finalizeComp.sig;
-}
-/**
- * Waits for a specific event to occur, matching a custom check, and returns the event and its signature.
- * @param eventListener - The EventManager instance to use for listening.
- * @param eventName - The name of the event to listen for.
- * @param eventCheck - A predicate function to check if the event matches the desired criteria.
- * @param commitment - (Optional) The desired finality/commitment level (default: 'confirmed').
- * @returns An object containing the event and its transaction signature.
- */
-async function awaitEvent(eventListener, eventName, eventCheck, commitment = 'confirmed') {
-    const foundEvent = await new Promise((res) => {
-        const listenerId = eventListener.addEventListener(eventName, (event, _slot, signature) => {
-            if (eventCheck(event))
-                res([event, signature, listenerId]);
-        }, commitment);
-    });
-    await eventListener.removeEventListener(foundEvent[2]);
-    return { event: foundEvent[0], sig: foundEvent[1] };
+    // Derive computation account PDA (requires clusterOffset from MXE account)
+    const mxeAccAddress = getMXEAccAddress(mxeProgramId);
+    const mxeAcc = await arciumProgram.account.mxeAccount.fetch(mxeAccAddress, commitment);
+    if (mxeAcc.cluster === null) {
+        throw new Error('MXE account has no cluster assigned');
+    }
+    const compAccAddress = getComputationAccAddress(mxeAcc.cluster, computationOffset);
+    const startTime = Date.now();
+    let lastStatus = 'unknown';
+    let rpcErrorCount = 0;
+    let lastError;
+    while (Date.now() - startTime < timeoutMs) {
+        let compAcc;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            compAcc = await arciumProgram.account.computationAccount.fetchNullable(compAccAddress, commitment);
+        }
+        catch (e) {
+            rpcErrorCount++;
+            lastError = e instanceof Error ? e.message : String(e);
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((r) => {
+                setTimeout(r, POLL_INTERVAL_MS);
+            });
+            continue;
+        }
+        if (compAcc !== null && 'finalized' in compAcc.status) {
+            lastStatus = 'finalized';
+            for (let sigRetry = 0; sigRetry < 10; sigRetry++) {
+                // eslint-disable-next-line no-await-in-loop
+                const sigs = await conn.getSignaturesForAddress(compAccAddress, { limit: 1 }, commitment);
+                if (sigs.length > 0)
+                    return sigs[0].signature;
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((r) => {
+                    setTimeout(r, POLL_INTERVAL_MS);
+                });
+            }
+            throw new Error('Computation finalized but transaction signature not indexed after retries.');
+        }
+        if (compAcc !== null)
+            lastStatus = 'queued';
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((r) => {
+            setTimeout(r, POLL_INTERVAL_MS);
+        });
+    }
+    const timeoutMsg = `Computation did not finalize within ${timeoutMs}ms (status: ${lastStatus})`;
+    throw rpcErrorCount > 0
+        ? new Error(timeoutMsg, { cause: new Error(`${rpcErrorCount} RPC errors, last: ${lastError}`) })
+        : new Error(timeoutMsg);
 }
 
 Object.defineProperty(exports, "x25519", {