@across-protocol/contracts 3.0.17 → 3.0.18

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

@@ -31,6 +31,7 @@ const web3_js_1 = require("@solana/web3.js");
 const SvmSpoke_common_1 = require("./SvmSpoke.common");
 const MerkleTree_1 = require("@uma/common/dist/MerkleTree");
 const utils_1 = require("./utils");
+const SvmUtils_1 = require("../../src/SvmUtils");
 const { provider, connection, program, owner, chainId, seedBalance, initializeState } = SvmSpoke_common_1.common;
 const { recipient, setCurrentTime, assertSE, assert } = SvmSpoke_common_1.common;
 describe("svm_spoke.slow_fill", () => {
@@ -163,16 +164,19 @@ describe("svm_spoke.slow_fill", () => {
         }
         // Set the contract time to be after the exclusivityDeadline
         await setCurrentTime(program, state, relayer, new anchor_1.BN(relayData.exclusivityDeadline + 1));
-        await program.methods.requestV3SlowFill(relayHash, relayData).accounts(requestAccounts).signers([relayer]).rpc();
+        const tx = await program.methods
+            .requestV3SlowFill(relayHash, relayData)
+            .accounts(requestAccounts)
+            .signers([relayer])
+            .rpc();
         // Fetch and verify the RequestedV3SlowFill event
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "requestedV3SlowFill").data;
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "requestedV3SlowFill")?.data;
         assert.isNotNull(event, "RequestedV3SlowFill 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_1.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`);
@@ -293,28 +297,29 @@ describe("svm_spoke.slow_fill", () => {
             .remainingAccounts(fillRemainingAccounts)
             .instruction();
         const computeBudgetInstruction = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 1_400_000 });
-        await (0, web3_js_1.sendAndConfirmTransaction)(connection, new web3_js_1.Transaction().add(computeBudgetInstruction, ix), [payer]);
+        const tx = await (0, web3_js_1.sendAndConfirmTransaction)(connection, new web3_js_1.Transaction().add(computeBudgetInstruction, ix), [
+            payer,
+        ]);
         // Verify the results
         const fVaultBal = (await connection.getTokenAccountBalance(vault)).value.amount;
         const fRecipientBal = (await connection.getTokenAccountBalance(recipientTA)).value.amount;
         assert.strictEqual(BigInt(iVaultBal) - BigInt(fVaultBal), BigInt(leaf.updatedOutputAmount.toNumber()), "Vault balance should be reduced by relay amount");
         assert.strictEqual(BigInt(fRecipientBal) - BigInt(iRecipientBal), BigInt(leaf.updatedOutputAmount.toNumber()), "Recipient balance should be increased by relay amount");
         // Fetch and verify the FilledV3Relay event
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "filledV3Relay").data;
+        const events = await (0, utils_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_1.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_1.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), `{"slowFill":{}}`, "FillType should be SlowFill");
         // These props below are not part of relayData.
@@ -531,7 +536,7 @@ describe("svm_spoke.slow_fill", () => {
         // Relay root bundle of slow fill leaf with empty message.
         const { relayHash, leaf, rootBundleId, proofAsNumbers, rootBundle } = await relaySlowFillRootBundle(undefined, undefined, Buffer.alloc(0));
         // Request V3 slow fill
-        await program.methods
+        const tx1 = await program.methods
             .requestV3SlowFill(Array.from(relayHash), leaf.relayData)
             .accounts(requestAccounts)
             .signers([relayer])
@@ -549,19 +554,19 @@ describe("svm_spoke.slow_fill", () => {
             recipientTokenAccount: recipientTA,
             program: program.programId,
         };
-        await program.methods
+        const tx2 = await program.methods
             .executeV3SlowRelayLeaf(Array.from(relayHash), leaf, rootBundleId, proofAsNumbers)
             .accounts(executeSlowRelayLeafAccounts)
             .remainingAccounts(fillRemainingAccounts)
             .rpc();
         // Fetch and verify message hash in the RequestedV3SlowFill and FilledV3Relay events
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
-        const requestEvent = events.find((event) => event.name === "requestedV3SlowFill").data;
-        const fillEvent = events.find((event) => event.name === "filledV3Relay").data;
+        const requestEvents = await (0, utils_1.readEventsUntilFound)(connection, tx1, [program]);
+        const requestEvent = requestEvents.find((event) => event.name === "requestedV3SlowFill")?.data;
         assert.isNotNull(requestEvent, "RequestedV3SlowFill event should be emitted");
-        assert.isNotNull(fillEvent, "FilledV3Relay event should be emitted");
         assertSE(requestEvent.messageHash, new Uint8Array(32), `MessageHash should be zeroed`);
+        const fillEvents = await (0, utils_1.readEventsUntilFound)(connection, tx2, [program]);
+        const fillEvent = fillEvents.find((event) => event.name === "filledV3Relay")?.data;
+        assert.isNotNull(fillEvent, "FilledV3Relay event should be emitted");
         assertSE(fillEvent.messageHash, new Uint8Array(32), `MessageHash should be zeroed`);
         assertSE(fillEvent.relayExecutionInfo.updatedMessageHash, new Uint8Array(32), `UpdatedMessageHash should be zeroed`);
     });

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

@@ -260,15 +260,13 @@ describe("svm_spoke.token_bridge", () => {
         // Create a new Keypair for the message event data.
         const simpleBridgeMessageSentEventData = anchor_1.web3.Keypair.generate();
         // Perform the bridge operation.
-        await program.methods
+        const tx = await program.methods
             .bridgeTokensToHubPool(new anchor_1.BN(simpleBridgeAmount))
             .accounts({ ...bridgeTokensToHubPoolAccounts, messageSentEventData: simpleBridgeMessageSentEventData.publicKey })
             .signers([simpleBridgeMessageSentEventData])
             .rpc();
-        // Wait for the event to be emitted.
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const events = await (0, utils_1.readProgramEvents)(connection, program);
-        const event = events.find((event) => event.name === "bridgedToHubPool").data;
+        const events = await (0, utils_1.readEventsUntilFound)(connection, tx, [program]);
+        const event = events.find((event) => event.name === "bridgedToHubPool")?.data;
         chai_1.assert.isNotNull(event, "BridgedToHubPool event should be emitted");
         chai_1.assert.strictEqual(event.amount.toString(), simpleBridgeAmount.toString(), "Invalid amount");
         chai_1.assert.strictEqual(event.mint.toString(), mint.toString(), "Invalid mint");

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

@@ -31,6 +31,7 @@ const ethers_1 = require("ethers");
 const spl_token_1 = require("@solana/spl-token");
 const SvmUtils_1 = require("../../src/SvmUtils");
 const chai_1 = require("chai");
+const crypto_1 = require("crypto");
 const provider = anchor.AnchorProvider.env();
 const program = anchor.workspace.SvmSpoke;
 const owner = provider.wallet.publicKey;
@@ -52,7 +53,7 @@ const message = Buffer.from("Test message");
 const depositQuoteTimeBuffer = new anchor_1.BN(3600); // 1 hour.
 const fillDeadlineBuffer = new anchor_1.BN(3600 * 4); // 4 hours.
 const initializeState = async (seed, initialState) => {
-    const actualSeed = seed || new anchor_1.BN(Math.floor(Math.random() * 1000000));
+    const actualSeed = seed || new anchor_1.BN((0, crypto_1.randomBytes)(8).toString("hex"), 16); // Generate a random u64
     const seeds = [Buffer.from("state"), actualSeed.toArrayLike(Buffer, "le", 8)];
     const [state] = web3_js_1.PublicKey.findProgramAddressSync(seeds, program.programId);
     if (!initialState) {

package/dist/test/svm/utils.d.ts

@@ -2,10 +2,10 @@ import { BN, Program } from "@coral-xyz/anchor";
 import { AccountMeta, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
 import { BigNumber } from "ethers";
 import { SvmSpoke } from "../../target/types/svm_spoke";
-import { readEvents, readProgramEvents, calculateRelayHashUint8Array, findProgramAddress } from "../../src/SvmUtils";
+import { readEvents, readProgramEvents, calculateRelayHashUint8Array, findProgramAddress, readEventsUntilFound } from "../../src/SvmUtils";
 import { MerkleTree } from "@uma/common";
 import { RelayData } from "./SvmSpoke.common";
-export { readEvents, readProgramEvents, calculateRelayHashUint8Array, findProgramAddress };
+export { readEvents, readProgramEvents, calculateRelayHashUint8Array, findProgramAddress, readEventsUntilFound };
 export declare function printLogs(connection: any, program: any, tx: any): Promise<void>;
 export declare function randomAddress(): string;
 export declare function randomBigInt(bytes?: number, signed?: boolean): bigint;
@@ -82,10 +82,9 @@ export declare function createFillV3RelayParamsInstructions(program: Program<Svm
 export declare function loadFillV3RelayParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData, repaymentChainId: BN, repaymentAddress: PublicKey): Promise<void>;
 export declare function loadRequestV3SlowFillParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData): Promise<TransactionInstruction[]>;
 export declare function loadExecuteV3SlowRelayLeafParams(program: Program<SvmSpoke>, signer: Keypair, slowFillLeaf: SlowFillLeaf, rootBundleId: number, proof: number[][]): Promise<TransactionInstruction[]>;
-export declare function intToU8Array32(num: number): number[];
-export declare function u8Array32ToInt(u8Array: Uint8Array): bigint;
+export declare function intToU8Array32(num: number | BN): number[];
+export declare function u8Array32ToInt(u8Array: Uint8Array | number[]): bigint;
 export declare function testAcrossPlusMessage(): {
     encodedMessage: Buffer;
     fillRemainingAccounts: AccountMeta[];
 };
-export declare function hashNonEmptyMessage(message: Buffer): Uint8Array;

package/dist/test/svm/utils.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayerRefundHashFn = exports.findProgramAddress = exports.calculateRelayHashUint8Array = exports.readProgramEvents = exports.readEvents = void 0;
+exports.relayerRefundHashFn = exports.readEventsUntilFound = exports.findProgramAddress = exports.calculateRelayHashUint8Array = exports.readProgramEvents = exports.readEvents = void 0;
 exports.printLogs = printLogs;
 exports.randomAddress = randomAddress;
 exports.randomBigInt = randomBigInt;
@@ -40,7 +40,6 @@ exports.loadExecuteV3SlowRelayLeafParams = loadExecuteV3SlowRelayLeafParams;
 exports.intToU8Array32 = intToU8Array32;
 exports.u8Array32ToInt = u8Array32ToInt;
 exports.testAcrossPlusMessage = testAcrossPlusMessage;
-exports.hashNonEmptyMessage = hashNonEmptyMessage;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
 const ethers_1 = require("ethers");
@@ -50,6 +49,7 @@ Object.defineProperty(exports, "readEvents", { enumerable: true, get: function (
 Object.defineProperty(exports, "readProgramEvents", { enumerable: true, get: function () { return SvmUtils_1.readProgramEvents; } });
 Object.defineProperty(exports, "calculateRelayHashUint8Array", { enumerable: true, get: function () { return SvmUtils_1.calculateRelayHashUint8Array; } });
 Object.defineProperty(exports, "findProgramAddress", { enumerable: true, get: function () { return SvmUtils_1.findProgramAddress; } });
+Object.defineProperty(exports, "readEventsUntilFound", { enumerable: true, get: function () { return SvmUtils_1.readEventsUntilFound; } });
 const common_1 = require("@uma/common");
 async function printLogs(connection, program, tx) {
     const latestBlockHash = await connection.getLatestBlockhash();
@@ -295,22 +295,36 @@ async function loadExecuteV3SlowRelayLeafParams(program, signer, slowFillLeaf, r
     return loadInstructions;
 }
 function intToU8Array32(num) {
-    if (!Number.isInteger(num) || num < 0) {
-        throw new Error("Input must be a non-negative integer");
+    let bigIntValue;
+    if (typeof num === "number") {
+        if (!Number.isInteger(num) || num < 0) {
+            throw new Error("Input must be a non-negative integer");
+        }
+        bigIntValue = BigInt(num);
+    }
+    else if (anchor_1.BN.isBN(num)) {
+        if (num.isNeg()) {
+            throw new Error("Input must be a non-negative BN");
+        }
+        bigIntValue = BigInt(num.toString());
+    }
+    else {
+        throw new Error("Input must be a non-negative integer or BN");
     }
     const u8Array = new Array(32).fill(0);
     let i = 0;
-    while (num > 0 && i < 32) {
-        u8Array[i++] = num & 0xff; // Get least significant byte
-        num >>= 8; // Shift right by 8 bits
+    while (bigIntValue > 0 && i < 32) {
+        u8Array[i++] = Number(bigIntValue & 0xffn); // Get least significant byte
+        bigIntValue >>= 8n; // Shift right by 8 bits
     }
     return u8Array;
 }
 function u8Array32ToInt(u8Array) {
-    if (!(u8Array instanceof Uint8Array) || u8Array.length !== 32) {
-        throw new Error("Input must be a Uint8Array of length 32");
+    const isValidArray = (arr) => Array.isArray(arr) && arr.every(Number.isInteger);
+    if ((u8Array instanceof Uint8Array || isValidArray(u8Array)) && u8Array.length === 32) {
+        return Array.from(u8Array).reduce((num, byte, i) => num | (BigInt(byte) << BigInt(i * 8)), 0n);
     }
-    return u8Array.reduce((num, byte, i) => num | (BigInt(byte) << BigInt(i * 8)), 0n);
+    throw new Error("Input must be a Uint8Array or an array of 32 numbers.");
 }
 // Encodes empty list of multicall handler instructions to be used as a test message field for fills.
 function testAcrossPlusMessage() {
@@ -331,11 +345,3 @@ function testAcrossPlusMessage() {
     ];
     return { encodedMessage, fillRemainingAccounts };
 }
-function hashNonEmptyMessage(message) {
-    if (message.length > 0) {
-        const hash = ethers_1.ethers.utils.keccak256(message);
-        return Uint8Array.from(Buffer.from(hash.slice(2), "hex"));
-    }
-    // else return zeroed bytes32
-    return new Uint8Array(32);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@across-protocol/contracts",
-  "version": "3.0.17",
+  "version": "3.0.18",
   "author": "UMA Team",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -39,7 +39,7 @@
     "pre-commit-hook": "sh scripts/preCommitHook.sh"
   },
   "dependencies": {
-    "@across-protocol/constants": "^3.1.19",
+    "@across-protocol/constants": "^3.1.22",
     "@coral-xyz/anchor": "^0.30.1",
     "@defi-wonderland/smock": "^2.3.4",
     "@eth-optimism/contracts": "^0.5.40",