@across-protocol/contracts 3.0.17 → 3.0.18

package/dist/test/svm/SvmSpoke.Bundle.js

@@ -144,11 +144,9 @@ describe("svm_spoke.bundle", () => {
             .relayRootBundle(relayerRefundRootArray, slowRelayRootArray)
             .accounts(relayRootBundleAccounts)
             .rpc();
-        // Wait for event processing
-        await new Promise((resolve) => setTimeout(resolve, 1000));
         // Check for the emitted event
-        const events = await (0, utils_1.readEvents)(connection, tx, [program]);
-        const event = events.find((event) => event.name === "relayedRootBundle").data;
+        let events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "relayedRootBundle")?.data;
         chai_1.assert.isTrue(event.rootBundleId.toString() === rootBundleId.toString(), "Root bundle ID should match");
         chai_1.assert.isTrue(event.relayerRefundRoot.toString() === relayerRefundRootArray.toString(), "Relayer refund root should match");
         chai_1.assert.isTrue(event.slowRelayRoot.toString() === slowRelayRootArray.toString(), "Slow relay root should match");
@@ -200,15 +198,14 @@ describe("svm_spoke.bundle", () => {
         };
         const proofAsNumbers = proof.map((p) => Array.from(p));
         await (0, utils_1.loadExecuteRelayerRefundLeafParams)(program, owner, stateAccountData.rootBundleId, leaf, proofAsNumbers);
-        await program.methods
+        const tx = await program.methods
             .executeRelayerRefundLeaf()
             .accounts(executeRelayerRefundLeafAccounts)
             .remainingAccounts(remainingAccounts)
             .rpc();
         // Verify the ExecutedRelayerRefundRoot event
-        await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-        let events = await (0, utils_1.readProgramEvents)(connection, program);
-        let event = events.find((event) => event.name === "executedRelayerRefundRoot").data;
+        let events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+        let event = events.find((event) => event.name === "executedRelayerRefundRoot")?.data;
         // Remove the expectedValues object and use direct assertions
         assertSE(event.amountToReturn, relayerRefundLeaves[0].amountToReturn, "amountToReturn should match");
         assertSE(event.chainId, chainId, "chainId should match");
@@ -221,6 +218,12 @@ describe("svm_spoke.bundle", () => {
         assertSE(event.refundAddresses[1], relayerB.publicKey, "Relayer B address should match");
         chai_1.assert.isFalse(event.deferredRefunds, "deferredRefunds should be false");
         assertSE(event.caller, owner, "caller should match");
+        event = events.find((event) => event.name === "tokensBridged")?.data;
+        assertSE(event.amountToReturn, relayerRefundLeaves[0].amountToReturn, "amountToReturn should match");
+        assertSE(event.chainId, chainId, "chainId should match");
+        assertSE(event.leafId, leaf.leafId, "leafId should match");
+        assertSE(event.l2TokenAddress, mint, "l2TokenAddress should match");
+        assertSE(event.caller, owner, "caller should match");
         const fVaultBal = (await connection.getTokenAccountBalance(vault)).value.amount;
         const fRelayerABal = (await connection.getTokenAccountBalance(relayerTA)).value.amount;
         const fRelayerBBal = (await connection.getTokenAccountBalance(relayerTB)).value.amount;
@@ -1180,16 +1183,14 @@ describe("svm_spoke.bundle", () => {
         };
         it("No deferred refunds in all Token Accounts", async () => {
             const tx = await executeRelayerRefundLeaf({ deferredRefunds: false });
-            await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-            const events = await (0, utils_1.readEvents)(connection, tx, [program]);
-            const event = events.find((event) => event.name === "executedRelayerRefundRoot").data;
+            const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+            const event = events.find((event) => event.name === "executedRelayerRefundRoot")?.data;
             chai_1.assert.isFalse(event.deferredRefunds, "deferredRefunds should be false");
         });
         it("Deferred refunds in all Claim Accounts", async () => {
             const tx = await executeRelayerRefundLeaf({ deferredRefunds: true });
-            await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-            const events = await (0, utils_1.readEvents)(connection, tx, [program]);
-            const event = events.find((event) => event.name === "executedRelayerRefundRoot").data;
+            const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+            const event = events.find((event) => event.name === "executedRelayerRefundRoot")?.data;
             chai_1.assert.isTrue(event.deferredRefunds, "deferredRefunds should be true");
         });
     });
@@ -1321,7 +1322,6 @@ describe("svm_spoke.bundle", () => {
             chai_1.assert.fail("Leaf verification should fail without leading 64 bytes");
         }
         catch (err) {
-            console.log("err", err);
             chai_1.assert.include(err.toString(), "Invalid Merkle proof", "Expected merkle verification to fail");
         }
     });
@@ -1399,7 +1399,6 @@ describe("svm_spoke.bundle", () => {
             chai_1.assert.fail("Leaf verification should fail without leading 64 bytes");
         }
         catch (err) {
-            console.log("err", err);
             chai_1.assert.include(err.toString(), "Invalid Merkle proof", "Expected merkle verification to fail");
         }
     });

package/dist/test/svm/SvmSpoke.Deposit.js

@@ -85,7 +85,8 @@ describe("svm_spoke.deposit", () => {
             .accounts(calledDepositAccounts)
             .instruction();
         const depositTx = new web3_js_1.Transaction().add(approveIx, depositIx);
-        await (0, web3_js_1.sendAndConfirmTransaction)(connection, depositTx, [payer, depositor]);
+        const tx = await (0, web3_js_1.sendAndConfirmTransaction)(connection, depositTx, [payer, depositor]);
+        return tx;
     };
     beforeEach(async () => {
         ({ state, seed } = await initializeState());
@@ -122,9 +123,8 @@ describe("svm_spoke.deposit", () => {
         depositData.inputAmount = depositData.inputAmount.add(new anchor_1.BN(69));
         // Execute the first deposit_v3 call
         let depositDataValues = Object.values(depositData);
-        await approvedDepositV3(depositDataValues);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        let events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx = await approvedDepositV3(depositDataValues);
+        let events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         let event = events[0].data; // 0th event is the latest event
         const expectedValues1 = { ...depositData, depositId: (0, utils_1.intToU8Array32)(1) }; // Verify the event props emitted match the depositData.
         for (let [key, value] of Object.entries(expectedValues1)) {
@@ -133,9 +133,8 @@ describe("svm_spoke.deposit", () => {
             assertSE(event[key], value, `${key} should match`);
         }
         // Execute the second deposit_v3 call
-        await approvedDepositV3(depositDataValues);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx2 = await approvedDepositV3(depositDataValues);
+        events = await (0, utils_1.readEventsUntilFound)(connection, tx2, [program]);
         event = events[0].data; // 0th event is the latest event.
         const expectedValues2 = { ...expectedValues1, depositId: (0, utils_1.intToU8Array32)(2) }; // Verify the event props emitted match the depositData.
         for (let [key, value] of Object.entries(expectedValues2)) {
@@ -286,7 +285,6 @@ describe("svm_spoke.deposit", () => {
             program: program.programId,
         };
         await program.methods.setEnableRoute(inputToken, fakeRouteChainId, true).accounts(fakeSetEnableRouteAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 2000));
         const fakeDepositAccounts = {
             state: fakeState.state,
             route: fakeRoutePda,
@@ -302,9 +300,8 @@ describe("svm_spoke.deposit", () => {
             ...depositData,
             destinationChainId: fakeRouteChainId,
         });
-        await approvedDepositV3(depositDataValues, fakeDepositAccounts);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        let events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx = await approvedDepositV3(depositDataValues, fakeDepositAccounts);
+        let events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         let event = events[0].data; // 0th event is the latest event.
         const expectedValues = {
             ...{ ...depositData, destinationChainId: fakeRouteChainId },
@@ -346,9 +343,8 @@ describe("svm_spoke.deposit", () => {
             .accounts(depositAccounts)
             .instruction();
         const depositTx = new web3_js_1.Transaction().add(approveIx, depositIx);
-        await (0, web3_js_1.sendAndConfirmTransaction)(connection, depositTx, [payer, depositor]);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx = await (0, web3_js_1.sendAndConfirmTransaction)(connection, depositTx, [payer, depositor]);
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         const event = events[0].data; // 0th event is the latest event.
         // Verify the event props emitted match the expected values
         const currentTime = await getCurrentTime(program, state);
@@ -407,9 +403,8 @@ describe("svm_spoke.deposit", () => {
         depositData.exclusiveRelayer = depositor.publicKey;
         depositData.exclusivityParameter = maxExclusivityOffsetSeconds;
         const depositDataValues = Object.values(depositData);
-        await approvedDepositV3(depositDataValues);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx = await approvedDepositV3(depositDataValues);
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         const event = events[0].data; // 0th event is the latest event
         assertSE(event.exclusivityDeadline, currentTime.add(maxExclusivityOffsetSeconds), "exclusivityDeadline should be current time + offset");
     });
@@ -420,9 +415,8 @@ describe("svm_spoke.deposit", () => {
         depositData.exclusiveRelayer = depositor.publicKey;
         depositData.exclusivityParameter = exclusivityDeadlineTimestamp;
         const depositDataValues = Object.values(depositData);
-        await approvedDepositV3(depositDataValues);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx = await approvedDepositV3(depositDataValues);
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         const event = events[0].data; // 0th event is the latest event;
         assertSE(event.exclusivityDeadline, exclusivityDeadlineTimestamp, "exclusivityDeadline should be passed in time");
     });
@@ -433,9 +427,8 @@ describe("svm_spoke.deposit", () => {
         depositData.exclusiveRelayer = depositor.publicKey;
         depositData.exclusivityParameter = zeroExclusivity;
         const depositDataValues = Object.values(depositData);
-        await approvedDepositV3(depositDataValues);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
+        const tx = await approvedDepositV3(depositDataValues);
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         const event = events[0].data; // 0th event is the latest event;
         assertSE(event.exclusivityDeadline, zeroExclusivity, "Exclusivity deadline should always be 0");
     });
@@ -462,11 +455,10 @@ describe("svm_spoke.deposit", () => {
             .accounts(depositAccounts) // Assuming depositAccounts is already set up correctly
             .instruction();
         const unsafeDepositTx = new web3_js_1.Transaction().add(approveIx, unsafeDepositIx);
-        await (0, web3_js_1.sendAndConfirmTransaction)(connection, unsafeDepositTx, [payer, depositor]);
+        const tx = await (0, web3_js_1.sendAndConfirmTransaction)(connection, unsafeDepositTx, [payer, depositor]);
         // Wait for a short period to ensure the event is emitted
-        await new Promise((resolve) => setTimeout(resolve, 500));
         // Read and verify the event
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
         const event = events[0].data; // Assuming the latest event is the one we want
         const expectedValues = { ...depositData, depositId: expectedDepositIdArray };
         for (let [key, value] of Object.entries(expectedValues)) {

package/dist/test/svm/SvmSpoke.Fill.AcrossPlus.js

@@ -176,7 +176,7 @@ describe("svm_spoke.fill.across_plus", () => {
             const computeBudgetIx = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 1_400_000 });
             await (0, SvmUtils_1.sendTransactionWithLookupTable)(connection, [computeBudgetIx, approveIx, fillIx], relayer);
             // Verify relayer's balance after the fill
-            await new Promise((resolve) => setTimeout(resolve, 1000)); // Make sure token transfers get processed.
+            await new Promise((resolve) => setTimeout(resolve, 500)); // Make sure token transfers get processed.
             const fRelayerBal = (await (0, spl_token_1.getAccount)(connection, relayerATA)).amount;
             assertSE(fRelayerBal, iRelayerBal - BigInt(distributionAmount * numberOfDistributions), "Relayer's balance should be reduced by the relay amount");
             // Verify all recipient account balances after the fill.

package/dist/test/svm/SvmSpoke.Fill.js

@@ -71,7 +71,8 @@ describe("svm_spoke.fill", () => {
             .remainingAccounts(fillRemainingAccounts)
             .instruction();
         const fillTx = new web3_js_1.Transaction().add(approveIx, fillIx);
-        await (0, web3_js_1.sendAndConfirmTransaction)(connection, fillTx, [payer, callingRelayer]);
+        const tx = await (0, web3_js_1.sendAndConfirmTransaction)(connection, fillTx, [payer, callingRelayer]);
+        return tx;
     };
     before("Funds relayer wallets", async () => {
         await connection.requestAirdrop(relayer.publicKey, 10_000_000_000); // 10 SOL
@@ -124,23 +125,22 @@ describe("svm_spoke.fill", () => {
     });
     it("Verifies FilledV3Relay event after filling a relay", async () => {
         const relayHash = Array.from((0, SvmUtils_1.calculateRelayHashUint8Array)(relayData, chainId));
-        await approvedFillV3Relay([relayHash, relayData, new anchor_1.BN(420), otherRelayer.publicKey]);
+        const tx = await approvedFillV3Relay([relayHash, relayData, new anchor_1.BN(420), otherRelayer.publicKey]);
         // Fetch and verify the FilledV3Relay event
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, SvmUtils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "filledV3Relay").data;
+        const events = await (0, SvmUtils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "filledV3Relay")?.data;
         assert.isNotNull(event, "FilledV3Relay event should be emitted");
         // Verify that the event data matches the relay data.
         Object.entries(relayData).forEach(([key, value]) => {
             if (key === "message") {
-                assertSE(event.messageHash, (0, utils_2.hashNonEmptyMessage)(value), `MessageHash should match`);
+                assertSE(event.messageHash, (0, SvmUtils_1.hashNonEmptyMessage)(value), `MessageHash should match`);
             }
             else
                 assertSE(event[key], value, `${key.charAt(0).toUpperCase() + key.slice(1)} should match`);
         });
         // RelayExecutionInfo should match.
         assertSE(event.relayExecutionInfo.updatedRecipient, relayData.recipient, "UpdatedRecipient should match");
-        assertSE(event.relayExecutionInfo.updatedMessageHash, (0, utils_2.hashNonEmptyMessage)(relayData.message), "UpdatedMessageHash should match");
+        assertSE(event.relayExecutionInfo.updatedMessageHash, (0, SvmUtils_1.hashNonEmptyMessage)(relayData.message), "UpdatedMessageHash should match");
         assertSE(event.relayExecutionInfo.updatedOutputAmount, relayData.outputAmount, "UpdatedOutputAmount should match");
         assert.equal(JSON.stringify(event.relayExecutionInfo.fillType), `{"fastFill":{}}`, "FillType should be FastFill");
         // These props below are not part of relayData.
@@ -213,7 +213,7 @@ describe("svm_spoke.fill", () => {
         assert.isNotNull(fillStatusAccountBefore, "Fill PDA should exist before closing");
         // Attempt to close the fill PDA before the fill deadline should fail.
         try {
-            await program.methods.closeFillPda(relayHash, relayData).accounts(closeFillPdaAccounts).signers([relayer]).rpc();
+            await program.methods.closeFillPda().accounts(closeFillPdaAccounts).signers([relayer]).rpc();
             assert.fail("Closing fill PDA should have failed before fill deadline");
         }
         catch (err) {
@@ -222,7 +222,7 @@ describe("svm_spoke.fill", () => {
         // Set the current time to past the fill deadline
         await setCurrentTime(program, state, relayer, new anchor_1.BN(relayData.fillDeadline + 1));
         // Close the fill PDA
-        await program.methods.closeFillPda(relayHash, relayData).accounts(closeFillPdaAccounts).signers([relayer]).rpc();
+        await program.methods.closeFillPda().accounts(closeFillPdaAccounts).signers([relayer]).rpc();
         // Verify the fill PDA is closed
         const fillStatusAccountAfter = await connection.getAccountInfo(accounts.fillStatus);
         assert.isNull(fillStatusAccountAfter, "Fill PDA should be closed after closing");
@@ -426,7 +426,7 @@ describe("svm_spoke.fill", () => {
         // Fill using the ALT.
         await (0, SvmUtils_1.sendTransactionWithLookupTable)(connection, [createTokenAccountsInstruction, approveInstruction, ...fillInstructions], relayer);
         // Verify balances after the fill
-        await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for tx processing
+        await new Promise((resolve) => setTimeout(resolve, 500)); // Wait for tx processing
         const fRelayerBal = (await (0, spl_token_1.getAccount)(connection, relayerTA)).amount;
         assertSE(fRelayerBal, iRelayerBal - BigInt(relayAmount * numberOfFills), "Relayer's balance should be reduced by total relay amount");
         recipientAssociatedTokens.forEach(async (recipientAssociatedToken) => {
@@ -466,11 +466,10 @@ describe("svm_spoke.fill", () => {
     it("Emits zeroed hash for empty message", async () => {
         updateRelayData({ ...relayData, message: Buffer.alloc(0) });
         const relayHash = Array.from((0, SvmUtils_1.calculateRelayHashUint8Array)(relayData, chainId));
-        await approvedFillV3Relay([relayHash, relayData, new anchor_1.BN(420), otherRelayer.publicKey]);
+        const tx = await approvedFillV3Relay([relayHash, relayData, new anchor_1.BN(420), otherRelayer.publicKey]);
         // Fetch and verify the FilledV3Relay event
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, SvmUtils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "filledV3Relay").data;
+        const events = await (0, SvmUtils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "filledV3Relay")?.data;
         assert.isNotNull(event, "FilledV3Relay event should be emitted");
         // Verify that the event data has zeroed message hash.
         assertSE(event.messageHash, new Uint8Array(32), `MessageHash should be zeroed`);

package/dist/test/svm/SvmSpoke.Ownership.js

@@ -62,23 +62,21 @@ describe("svm_spoke.ownership", () => {
         chai_1.assert.isFalse((await program.account.state.fetch(state)).pausedDeposits, "Deposits should not be paused");
         // Pause deposits as owner
         const pauseDepositsAccounts = { state, signer: owner, program: program.programId };
-        await program.methods.pauseDeposits(true).accounts(pauseDepositsAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const tx = await program.methods.pauseDeposits(true).accounts(pauseDepositsAccounts).rpc();
         // Fetch the updated state
         let stateAccountData = await program.account.state.fetch(state);
         chai_1.assert.isTrue(stateAccountData.pausedDeposits, "Deposits should be paused");
         // Verify the PausedDeposits event
-        let events = await (0, utils_1.readProgramEvents)(provider.connection, program);
+        let events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx, [program]);
         let pausedDepositEvents = events.filter((event) => event.name === "pausedDeposits");
         chai_1.assert.isTrue(pausedDepositEvents[0].data.isPaused, "PausedDeposits event should indicate deposits are paused");
         // Unpause deposits as owner
-        await program.methods.pauseDeposits(false).accounts(pauseDepositsAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const tx2 = await program.methods.pauseDeposits(false).accounts(pauseDepositsAccounts).rpc();
         // Fetch the updated state
         stateAccountData = await program.account.state.fetch(state);
         chai_1.assert.isFalse(stateAccountData.pausedDeposits, "Deposits should not be paused");
         // Verify the PausedDeposits event
-        events = await (0, utils_1.readProgramEvents)(provider.connection, program);
+        events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx2, [program]);
         pausedDepositEvents = events.filter((event) => event.name === "pausedDeposits");
         chai_1.assert.isFalse(pausedDepositEvents[0].data.isPaused, "PausedDeposits event should indicate deposits are unpaused");
         // Try to pause deposits as non-owner
@@ -95,23 +93,21 @@ describe("svm_spoke.ownership", () => {
         chai_1.assert.isFalse((await program.account.state.fetch(state)).pausedFills, "Fills should not be paused");
         // Pause fills as owner
         const pauseFillsAccounts = { state, signer: owner, program: program.programId };
-        await program.methods.pauseFills(true).accounts(pauseFillsAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const tx = await program.methods.pauseFills(true).accounts(pauseFillsAccounts).rpc();
         // Fetch the updated state
         let stateAccountData = await program.account.state.fetch(state);
         chai_1.assert.isTrue(stateAccountData.pausedFills, "Fills should be paused");
         // Verify the PausedFills event
-        let events = await (0, utils_1.readProgramEvents)(provider.connection, program);
+        let events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx, [program]);
         let pausedFillEvents = events.filter((event) => event.name === "pausedFills");
         chai_1.assert.isTrue(pausedFillEvents[0].data.isPaused, "PausedFills event should indicate fills are paused");
         // Unpause fills as owner
-        await program.methods.pauseFills(false).accounts(pauseFillsAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const tx2 = await program.methods.pauseFills(false).accounts(pauseFillsAccounts).rpc();
         // Fetch the updated state
         stateAccountData = await program.account.state.fetch(state);
         chai_1.assert.isFalse(stateAccountData.pausedFills, "Fills should not be paused");
         // Verify the PausedFills event
-        events = await (0, utils_1.readProgramEvents)(provider.connection, program);
+        events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx2, [program]);
         pausedFillEvents = events.filter((event) => event.name === "pausedFills");
         chai_1.assert.isFalse(pausedFillEvents[0].data.isPaused, "PausedFills event should indicate fills are unpaused");
         // Try to pause fills as non-owner
@@ -128,7 +124,6 @@ describe("svm_spoke.ownership", () => {
         // Transfer ownership to newOwner
         const transferOwnershipAccounts = { state, signer: owner };
         await program.methods.transferOwnership(newOwner.publicKey).accounts(transferOwnershipAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
         // Verify the new owner
         let stateAccountData = await program.account.state.fetch(state);
         chai_1.assert.equal(stateAccountData.owner.toString(), newOwner.publicKey.toString(), "Ownership should be transferred");
@@ -149,16 +144,15 @@ describe("svm_spoke.ownership", () => {
     it("Sets cross-domain admin", async () => {
         // Set cross-domain admin as owner
         const setCrossDomainAdminAccounts = { state, signer: owner, program: program.programId };
-        await program.methods
+        const tx = await program.methods
             .setCrossDomainAdmin(newCrossDomainAdmin.publicKey)
             .accounts(setCrossDomainAdminAccounts)
             .rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
         // Verify the new cross-domain admin
         let stateAccountData = await program.account.state.fetch(state);
         chai_1.assert.equal(stateAccountData.crossDomainAdmin.toString(), newCrossDomainAdmin.publicKey.toString(), "Cross-domain admin should be set");
         // Verify the SetXDomainAdmin event
-        let events = await (0, utils_1.readProgramEvents)(provider.connection, program);
+        let events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx, [program]);
         let setXDomainAdminEvents = events.filter((event) => event.name === "setXDomainAdmin");
         chai_1.assert.equal(setXDomainAdminEvents[0].data.newAdmin.toString(), newCrossDomainAdmin.publicKey.toString(), "SetXDomainAdmin event should indicate the new admin");
         // Try to set cross-domain admin as non-owner

package/dist/test/svm/SvmSpoke.RefundClaims.js

@@ -142,16 +142,18 @@ describe("svm_spoke.refund_claims", () => {
         const iVaultBal = (await connection.getTokenAccountBalance(vault)).value.amount;
         const iRelayerBal = (await connection.getTokenAccountBalance(tokenAccount)).value.amount;
         // Claim refund for the relayer.
-        await program.methods.claimRelayerRefundFor(relayer.publicKey).accounts(claimRelayerRefundAccounts).rpc();
+        const tx = await program.methods
+            .claimRelayerRefundFor(relayer.publicKey)
+            .accounts(claimRelayerRefundAccounts)
+            .rpc();
         // The relayer should have received funds from the vault.
         const fVaultBal = (await connection.getTokenAccountBalance(vault)).value.amount;
         const fRelayerBal = (await connection.getTokenAccountBalance(tokenAccount)).value.amount;
         assertSE(BigInt(iVaultBal) - BigInt(fVaultBal), relayerRefund, "Vault balance");
         assertSE(BigInt(fRelayerBal) - BigInt(iRelayerBal), relayerRefund, "Relayer balance");
         // Verify the ClaimedRelayerRefund event
-        await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "claimedRelayerRefund").data;
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "claimedRelayerRefund")?.data;
         assertSE(event.l2TokenAddress, mint, "l2TokenAddress should match");
         assertSE(event.claimAmount, relayerRefund, "Relayer refund amount should match");
         assertSE(event.refundAddress, relayer.publicKey, "Relayer refund address should match");
@@ -300,16 +302,15 @@ describe("svm_spoke.refund_claims", () => {
         claimRelayerRefundAccounts.tokenAccount = customTokenAccount;
         claimRelayerRefundAccounts.signer = relayer.publicKey; // Only relayer itself should be able to do this.
         // Relayer can claim refund to custom token account.
-        await program.methods.claimRelayerRefund().accounts(claimRelayerRefundAccounts).signers([relayer]).rpc();
+        const tx = await program.methods.claimRelayerRefund().accounts(claimRelayerRefundAccounts).signers([relayer]).rpc();
         // The relayer should have received funds from the vault.
         const fVaultBal = (await connection.getTokenAccountBalance(vault)).value.amount;
         const fRelayerBal = (await connection.getTokenAccountBalance(customTokenAccount)).value.amount;
         assertSE(BigInt(iVaultBal) - BigInt(fVaultBal), relayerRefund, "Vault balance");
         assertSE(BigInt(fRelayerBal) - BigInt(iRelayerBal), relayerRefund, "Relayer balance");
         // Verify the ClaimedRelayerRefund event
-        await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "claimedRelayerRefund").data;
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "claimedRelayerRefund")?.data;
         assertSE(event.l2TokenAddress, mint, "l2TokenAddress should match");
         assertSE(event.claimAmount, relayerRefund, "Relayer refund amount should match");
         assertSE(event.refundAddress, relayer.publicKey, "Relayer refund address should match");

package/dist/test/svm/SvmSpoke.Routes.js

@@ -60,25 +60,29 @@ describe("svm_spoke.routes", () => {
     });
     it("Sets, retrieves, and controls access to route enablement", async () => {
         // Enable the route as owner
-        await program.methods.setEnableRoute(tokenMint, routeChainId, true).accounts(setEnableRouteAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const tx = await program.methods
+            .setEnableRoute(tokenMint, routeChainId, true)
+            .accounts(setEnableRouteAccounts)
+            .rpc();
         // Retrieve and verify the route is enabled
         let routeAccount = await program.account.route.fetch(routePda);
         chai_1.assert.isTrue(routeAccount.enabled, "Route should be enabled");
         // Verify the enabledDepositRoute event
-        let events = (await (0, utils_1.readProgramEvents)(provider.connection, program)).filter((event) => event.name === "enabledDepositRoute");
+        let events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx, [program]);
         let event = events[0].data;
         chai_1.assert.strictEqual(event.originToken.toString(), tokenMint.toString(), "originToken event match");
         chai_1.assert.strictEqual(event.destinationChainId.toString(), routeChainId.toString(), "destinationChainId should match");
         chai_1.assert.isTrue(event.enabled, "enabledDepositRoute enabled");
         // Disable the route as owner
-        await program.methods.setEnableRoute(tokenMint, routeChainId, false).accounts(setEnableRouteAccounts).rpc();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        const tx2 = await program.methods
+            .setEnableRoute(tokenMint, routeChainId, false)
+            .accounts(setEnableRouteAccounts)
+            .rpc();
         // Retrieve and verify the route is disabled
         routeAccount = await program.account.route.fetch(routePda);
         chai_1.assert.isFalse(routeAccount.enabled, "Route should be disabled");
         // Verify the enabledDepositRoute event
-        events = (await (0, utils_1.readProgramEvents)(provider.connection, program)).filter((event) => event.name === "enabledDepositRoute");
+        events = await (0, utils_1.readEventsUntilFound)(provider.connection, tx2, [program]);
         event = events[0].data; // take most recent event, index 0.
         chai_1.assert.strictEqual(event.originToken.toString(), tokenMint.toString(), "originToken event match");
         chai_1.assert.strictEqual(event.destinationChainId.toString(), routeChainId.toString(), "destinationChainId should match");

package/dist/test/svm/SvmSpoke.SlowFill.AcrossPlus.js

@@ -32,8 +32,8 @@ const MerkleTree_1 = require("@uma/common/dist/MerkleTree");
 const SvmUtils_1 = require("../../src/SvmUtils");
 const SvmSpoke_common_1 = require("./SvmSpoke.common");
 const utils_1 = require("./utils");
-const { provider, connection, program, owner, chainId } = SvmSpoke_common_1.common;
-const { initializeState, assertSE } = SvmSpoke_common_1.common;
+const { provider, connection, program, owner, chainId, setCurrentTime } = SvmSpoke_common_1.common;
+const { initializeState, assertSE, assert } = SvmSpoke_common_1.common;
 describe("svm_spoke.slow_fill.across_plus", () => {
     anchor.setProvider(provider);
     const payer = anchor.AnchorProvider.env().wallet.payer;
@@ -277,4 +277,61 @@ describe("svm_spoke.slow_fill.across_plus", () => {
             await fillTokenDistributions(numberOfDistributions, true);
         });
     });
+    it("Can recover and close fill status PDA from event data", async () => {
+        // Construct ix to transfer all tokens from handler to the final recipient.
+        const transferIx = (0, spl_token_1.createTransferCheckedInstruction)(handlerATA, mint, finalRecipientATA, handlerSigner, relayData.outputAmount.toNumber(), tokenDecimals);
+        const multicallHandlerCoder = new SvmUtils_1.MulticallHandlerCoder([transferIx]);
+        const handlerMessage = multicallHandlerCoder.encode();
+        const message = new SvmUtils_1.AcrossPlusMessageCoder({
+            handler: handlerProgram.programId,
+            readOnlyLen: multicallHandlerCoder.readOnlyLen,
+            valueAmount: new anchor_1.BN(0),
+            accounts: multicallHandlerCoder.compiledMessage.accountKeys,
+            handlerMessage,
+        });
+        const encodedMessage = message.encode();
+        // Update relay data with the encoded message.
+        const newRelayData = { ...relayData, message: encodedMessage };
+        updateRelayData(newRelayData);
+        // Prepare request and execute slow fill instructions as we will need to use Address Lookup Table (ALT).
+        // Request and execute slow fill.
+        const { loadRequestParamsInstructions, requestIx, loadExecuteParamsInstructions, executeIx } = await createSlowFillIx(multicallHandlerCoder, true);
+        // Fill using the ALT and submit load params transactions.
+        for (let i = 0; i < loadRequestParamsInstructions.length; i += 1) {
+            await (0, web3_js_1.sendAndConfirmTransaction)(program.provider.connection, new web3_js_1.Transaction().add(loadRequestParamsInstructions[i]), [relayer]);
+        }
+        await (0, SvmUtils_1.sendTransactionWithLookupTable)(connection, [requestIx], relayer);
+        await new Promise((resolve) => setTimeout(resolve, 1000)); // Make sure request tx gets processed.
+        for (let i = 0; i < loadExecuteParamsInstructions.length; i += 1) {
+            await (0, web3_js_1.sendAndConfirmTransaction)(program.provider.connection, new web3_js_1.Transaction().add(loadExecuteParamsInstructions[i]), [relayer]);
+        }
+        const { txSignature } = await (0, SvmUtils_1.sendTransactionWithLookupTable)(connection, [executeIx], relayer);
+        await connection.confirmTransaction(txSignature, "confirmed");
+        await connection.getTransaction(txSignature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0,
+        });
+        // We don't close ALT here as that would require ~4 minutes between deactivation and closing, but we demonstrate
+        // being able to close the fill status PDA using only event data.
+        const events = await (0, SvmUtils_1.readEventsUntilFound)(connection, txSignature, [program]);
+        const eventData = events.find((event) => event.name === "filledV3Relay")?.data;
+        assert.isNotNull(eventData, "FilledV3Relay event should be emitted");
+        // Recover relay hash and derived fill status from event data.
+        const relayHashUint8Array = (0, SvmUtils_1.calculateRelayEventHashUint8Array)(eventData, chainId);
+        const [fillStatusPDA] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("fills"), relayHashUint8Array], program.programId);
+        const fillStatusAccount = await program.account.fillStatusAccount.fetch(fillStatusPDA);
+        assert.isTrue("filled" in fillStatusAccount.status, "Fill status account should be marked as filled");
+        assertSE(fillStatusAccount.relayer, relayer.publicKey, "Relayer should match in the fill status");
+        // Set the current time to past the fill deadline
+        await setCurrentTime(program, state, relayer, new anchor_1.BN(fillStatusAccount.fillDeadline + 1));
+        const closeFillPdaAccounts = {
+            signer: relayer.publicKey,
+            state,
+            fillStatus: fillStatusPDA,
+        };
+        await program.methods.closeFillPda().accounts(closeFillPdaAccounts).signers([relayer]).rpc();
+        // Verify the fill PDA is closed
+        const fillStatusAccountAfter = await connection.getAccountInfo(fillStatusPDA);
+        assert.isNull(fillStatusAccountAfter, "Fill PDA should be closed after closing");
+    });
 });