@across-protocol/sdk 4.4.0-alpha.4 → 4.4.0-alpha.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.4.0-alpha.4",
+  "version": "4.4.0-alpha.6",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "repository": {
@@ -19,8 +19,6 @@
     "node": ">=22.18.0"
   },
   "scripts": {
-    "build-bigint-buffer": "node scripts/build-bigint-buffer.js",
-    "postinstall": "node scripts/build-bigint-buffer.js",
     "start": "yarn typechain && nodemon -e ts,tsx,json,js,jsx --watch ./src --ignore ./dist --exec 'yarn dev'",
     "build": "yarn run clean && yarn typechain && yarn generate-svm-artifacts && yarn dev",
     "generate-svm-artifacts": "bash scripts/svm/generateSvmAssets.sh && yarn generate-svm-clients",
@@ -43,7 +41,7 @@
     "bump-version:major": "yarn version --major --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "bump-version:minor": "yarn version --minor --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "bump-version:patch": "yarn version --patch --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
-    "stage-artifacts": "node scripts/stage-typechain-artifacts.js",
+    "stage-artifacts": "node scripts/stage-typechain-artifacts.cjs",
     "typechain": "yarn stage-artifacts && typechain --target ethers-v5 --out-dir src/utils/abi/typechain 'src/utils/abi/contracts/*.json'",
     "yalc:watch": "nodemon --watch src --ext ts,tsx,json,js,jsx --ignore src/utils/abi/ --exec 'yalc publish --push --changed'"
   },
@@ -65,90 +63,71 @@
   "devDependencies": {
     "@codama/nodes-from-anchor": "^1.2.2",
     "@codama/renderers-js": "^1.3.0",
-    "codama": "^1.3.0",
-    "@defi-wonderland/smock": "^2.4.0",
     "@nomicfoundation/hardhat-chai-matchers": "^1.0.6",
     "@nomiclabs/hardhat-ethers": "^2.2.1",
-    "@nomiclabs/hardhat-etherscan": "^3.1.7",
     "@openzeppelin/hardhat-upgrades": "^1.28.0",
-    "@size-limit/preset-small-lib": "^7.0.8",
     "@typechain/ethers-v5": "^11.1.1",
-    "@typechain/hardhat": "^6.1.6",
     "@types/async": "^3.2.24",
     "@types/chai": "^4.3.6",
-    "@types/dotenv": "^8.2.0",
     "@types/lodash": "^4.14.199",
-    "@types/lodash.get": "^4.4.7",
     "@types/mocha": "^10.0.1",
-    "@types/node": "^24.3.0",
+    "@types/node": "^25.6.0",
     "@types/sinon": "^21.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.6.0",
-    "@typescript-eslint/parser": "^6.6.0",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
     "arlocal": "^1.1.65",
     "chai": "^4.3.8",
     "chai-exclude": "^2.1.0",
+    "codama": "^1.3.0",
     "commander": "^14.0.0",
     "concurrently": "^9.1.2",
-    "dotenv": "^16.0.0",
-    "eslint": "^8.49.0",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-config-standard": "^17.1.0",
     "eslint-plugin-chai-expect": "^3.0.0",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-mocha": "^10.2.0",
-    "eslint-plugin-n": "^15.0.0",
-    "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^5.0.0",
-    "eslint-plugin-promise": "^6.1.1",
     "hardhat": "^2.28.0",
-    "hardhat-deploy": "^0.11.2",
-    "hardhat-gas-reporter": "^1.0.8",
     "hardhat-watcher": "^2.5.0",
     "husky": "^8.0.0",
-    "lint-staged": "^12.4.1",
+    "lint-staged": "^15.0.0",
     "nodemon": "^3.0.1",
     "prettier": "^3.0.3",
-    "sinon": "^16.0.0",
-    "size-limit": "^7.0.8",
-    "solidity-coverage": "^0.8.5",
-    "ts-jest": "^29.1.1",
+    "sinon": "^21.0.0",
+    "size-limit": "^11.0.0",
     "ts-node": "^10.9.1",
     "typechain": "^8.3.1",
-    "typescript": "^5.9"
+    "typescript": "^6"
   },
   "dependencies": {
     "@across-protocol/constants": "^3.1.100",
-    "@across-protocol/contracts": "5.0.4",
+    "@across-protocol/contracts": "5.0.5",
     "@coral-xyz/anchor": "^0.30.1",
     "@coral-xyz/borsh": "^0.30.1",
     "@eth-optimism/sdk": "^3.3.1",
     "@ethersproject/bignumber": "^5.7.0",
     "@nktkas/hyperliquid": "^0.25.9",
-    "@pinata/sdk": "^2.1.0",
+    "@solana-program/address-lookup-table": "^0.10.0",
     "@solana-program/compute-budget": "^0.11.0",
     "@solana-program/system": "^0.10.0",
     "@solana-program/token": "^0.9.0",
     "@solana-program/token-2022": "^0.6.1",
     "@solana/kit": "^5.4.0",
     "@solana/spl-token": "^0.4.14",
-    "@solana/sysvars": "^5.4.0",
     "@solana/web3.js": "^1.98.2",
-    "@solana-program/address-lookup-table": "^0.10.0",
     "@uma/contracts-node": "^0.4.0",
     "arweave": "^1.14.4",
-    "borsh": "0.7.0",
-    "buffer-layout": "^1.2.2",
     "async": "^3.2.5",
-    "axios": "^0.27.2",
+    "borsh": "0.7.0",
     "bs58": "^6.0.0",
+    "buffer-layout": "^1.2.2",
     "decimal.js": "^10.3.1",
     "ethers": "^5.7.2",
-    "lodash": "^4.17.23",
-    "lodash.get": "^4.4.2",
-    "node-gyp": "^11.0.0",
-    "superstruct": "^0.15.4",
+    "lodash": "^4.18.1",
+    "superstruct": "^1.0.3",
+    "tronweb": "^6.2.2",
     "tslib": "^2.6.2",
-    "viem": "^2.21.15",
+    "viem": "^2.47.10",
     "winston": "^3.17.0",
     "winston-transport": "^4.9.0"
   },
@@ -156,10 +135,6 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node"
-  },
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
   "types": "./dist/types/src/index.d.ts",
@@ -200,19 +175,10 @@
     }
   },
   "resolutions": {
-    "**/eccrypto/secp256k1": "3.8.1",
-    "**/eth-crypto/secp256k1": "5.0.1",
-    "**/libp2p-crypto/secp256k1": "4.0.4",
     "**/ethereum-cryptography/secp256k1": "4.0.4",
     "**/arbundles/secp256k1": "4.0.4",
-    "**/ganache/secp256k1": "4.0.4",
     "**/ethereumjs-util/secp256k1": "3.8.1",
     "**/@solana/codecs": "5.4.0",
     "**/@solana/codecs-numbers": "5.4.0"
-  },
-  "overrides": {
-    "secp256k1@3.7.1": "3.8.1",
-    "secp256k1@4.0.3": "4.0.4",
-    "secp256k1@5.0.0": "5.0.1"
   }
 }

package/scripts/svm/generateSvmClients.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 /**
  * Generates Codama TypeScript clients from IDL files.
  * Reads IDL assets from the locally generated src/svm/assets/idl/ directory
@@ -5,22 +6,20 @@
  *
  * This is the SDK's own generation script, equivalent to the one in the contracts repo.
  */
+import path from "path";
 import { createFromRoot } from "codama";
 import { rootNodeFromAnchor, AnchorIdl } from "@codama/nodes-from-anchor";
 import { renderVisitor as renderJavaScriptVisitor } from "@codama/renderers-js";
-import path from "path";
 
-// Read IDL files directly from the generated assets
-const idlPath = path.join(__dirname, "..", "..", "src", "svm", "assets", "idl");
-const clientsPath = path.join(__dirname, "..", "..", "src", "svm", "clients");
+import SvmSpokeIdl from "../../src/svm/assets/idl/svm_spoke.json";
+import MulticallHandlerIdl from "../../src/svm/assets/idl/multicall_handler.json";
+import MessageTransmitterIdl from "../../src/svm/assets/idl/message_transmitter.json";
+import TokenMessengerMinterIdl from "../../src/svm/assets/idl/token_messenger_minter.json";
+import MessageTransmitterV2Idl from "../../src/svm/assets/idl/message_transmitter_v2.json";
+import TokenMessengerMinterV2Idl from "../../src/svm/assets/idl/token_messenger_minter_v2.json";
+import SponsoredCctpSrcPeripheryIdl from "../../src/svm/assets/idl/sponsored_cctp_src_periphery.json";
 
-const SvmSpokeIdl = require(path.join(idlPath, "svm_spoke.json"));
-const MulticallHandlerIdl = require(path.join(idlPath, "multicall_handler.json"));
-const MessageTransmitterIdl = require(path.join(idlPath, "message_transmitter.json"));
-const TokenMessengerMinterIdl = require(path.join(idlPath, "token_messenger_minter.json"));
-const MessageTransmitterV2Idl = require(path.join(idlPath, "message_transmitter_v2.json"));
-const TokenMessengerMinterV2Idl = require(path.join(idlPath, "token_messenger_minter_v2.json"));
-const SponsoredCctpSrcPeripheryIdl = require(path.join(idlPath, "sponsored_cctp_src_periphery.json"));
+const clientsPath = path.join(__dirname, "..", "..", "src", "svm", "clients");
 
 // Generate clients for each program
 let codama = createFromRoot(rootNodeFromAnchor(SvmSpokeIdl as AnchorIdl));

package/scripts/svm/renameClientsImports.ts

@@ -1,9 +1,10 @@
+/// <reference types="node" />
 /**
  * Post-processes generated Codama clients to replace @solana/web3.js imports with @solana/kit.
  * This is needed because Codama generates imports for @solana/web3.js by default.
  */
-const fs = require("fs");
-const path = require("path");
+import fs from "fs";
+import path from "path";
 
 const clientsPath = path.join(__dirname, "..", "..", "src", "svm", "clients");
 

package/src/addressAggregator/adapters/abstract.ts

@@ -1,6 +1,5 @@
-import axios from "axios";
 import { AdapterOptions, AddressListAdapter } from "../types";
-import { Logger } from "../../utils";
+import { Logger, fetchWithTimeout } from "../../utils";
 
 const { ACROSS_USER_AGENT = "across-protocol" } = process.env;
 
@@ -28,18 +27,13 @@ export abstract class AbstractAdapter implements AddressListAdapter {
   }
 
   protected async fetch(name: string, url: string, timeout = 2000, retries = 1): Promise<unknown> {
-    const args = {
-      headers: { "User-Agent": ACROSS_USER_AGENT },
-      timeout,
-    };
-
     const errs: string[] = [];
     let tries = 0;
     do {
       try {
-        return (await axios(url, args)).data;
+        return await fetchWithTimeout(url, {}, { "User-Agent": ACROSS_USER_AGENT }, timeout);
       } catch (err) {
-        const errMsg = axios.isAxiosError(err) || err instanceof Error ? err.message : "unknown error";
+        const errMsg = err instanceof Error ? err.message : "unknown error";
         errs.push(errMsg);
         if (++tries <= retries) await this.sleep(Math.pow(1.5, tries) * 1000); // simple backoff
       }

package/src/apiClient/productionClient.ts

@@ -1,6 +1,5 @@
-import axios from "axios";
 import AbstractApiClient from "./abstractClient";
-import { BigNumber, parseEther } from "../utils";
+import { BigNumber, fetchWithTimeout, parseEther } from "../utils";
 import {
   CoingeckoDataReturnType,
   SuggestedFeeReturnType,
@@ -8,6 +7,18 @@ import {
   AcrossBridgeStatisticsType,
 } from "./types";
 
+type SuggestedFeesApiResponse = {
+  relayFeePct: string;
+  relayFeeTotal: string;
+  capitalFeePct: string;
+  capitalFeeTotal: string;
+  relayGasFeePct: string;
+  relayGasFeeTotal: string;
+  isAmountTooLow: boolean;
+  timestamp: string;
+  quoteBlock: string;
+};
+
 /**
  * An implementation of AbstractApiClient that uses the production API.
  * @class
@@ -20,13 +31,10 @@ export default class ProductionApiClient extends AbstractApiClient {
   }
 
   public async getCoinGeckoData(l1Token: string, baseCurrency: string): Promise<CoingeckoDataReturnType> {
-    const response = await axios.get(`${this.getServerlessApiUrl()}/api/coingecko`, {
-      params: {
-        l1Token,
-        baseCurrency,
-      },
+    const result = await fetchWithTimeout<{ price: string }>(`${this.getServerlessApiUrl()}/api/coingecko`, {
+      l1Token,
+      baseCurrency,
     });
-    const result = response.data;
     const price = baseCurrency === "usd" ? parseEther(String(result.price)) : BigNumber.from(result.price);
     return {
       price,
@@ -38,16 +46,16 @@ export default class ProductionApiClient extends AbstractApiClient {
     toChainid: number,
     fromChainid: number
   ): Promise<SuggestedFeeReturnType> {
-    const response = await axios.get(`${this.getServerlessApiUrl()}/api/suggested-fees`, {
-      params: {
+    const result = await fetchWithTimeout<SuggestedFeesApiResponse>(
+      `${this.getServerlessApiUrl()}/api/suggested-fees`,
+      {
         token: originToken,
         destinationChainId: toChainid,
         originChainId: fromChainid,
         amount: amount.toString(),
         skipAmountLimit: true,
-      },
-    });
-    const result = response.data;
+      }
+    );
     const relayFeePct = BigNumber.from(result["relayFeePct"]);
     const relayFeeTotal = BigNumber.from(result["relayFeeTotal"]);
 
@@ -85,13 +93,15 @@ export default class ProductionApiClient extends AbstractApiClient {
     fromChainId: string | number,
     toChainId: string | number
   ): Promise<BridgeLimitsReturnType> {
-    const { data } = await axios.get<BridgeLimitsReturnType>(
-      `${this.getServerlessApiUrl()}/api/limits?token=${token}&originChainId=${fromChainId}&destinationChainId=${toChainId}`
-    );
+    const data = await fetchWithTimeout<BridgeLimitsReturnType>(`${this.getServerlessApiUrl()}/api/limits`, {
+      token,
+      originChainId: fromChainId,
+      destinationChainId: toChainId,
+    });
     return data;
   }
   public async getAcrossStats(): Promise<AcrossBridgeStatisticsType> {
-    const axiosResponse = await axios.get<AcrossBridgeStatisticsType>(`${this.getScraperApiUrl()}/deposits/stats`);
-    return axiosResponse.data;
+    const data = await fetchWithTimeout<AcrossBridgeStatisticsType>(`${this.getScraperApiUrl()}/deposits/stats`);
+    return data;
   }
 }

package/src/arch/evm/SpokeUtils.ts

@@ -5,7 +5,6 @@ import { Deposit, FillStatus, FillWithBlock, RelayData, SpeedUpCommon } from "..
 import {
   bnUint32Max,
   BigNumber,
-  EvmAddress,
   toBN,
   bnZero,
   chunk,
@@ -25,8 +24,8 @@ type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> &
   Pick<Deposit, "speedUpSignature"> &
   Partial<SpeedUpCommon> & {
     destinationChainId: number;
-    recipient: EvmAddress;
-    outputToken: EvmAddress;
+    recipient: Address;
+    outputToken: Address;
   };
 
 /**
@@ -65,7 +64,7 @@ export function populateV3Relay(
     assert(isDefined(relayData.updatedOutputAmount));
     assert(isDefined(relayData.updatedMessage));
     return spokePool.populateTransaction.fillRelayWithUpdatedDeposit(
-      relayData,
+      evmRelayData,
       repaymentChainId,
       repaymentAddress.toBytes32(),
       relayData.updatedOutputAmount,

package/src/arch/evm/UpgradeUtils.ts

@@ -0,0 +1,18 @@
+import { Contract } from "ethers";
+import { paginatedEventQuery } from "../../utils";
+
+/**
+ * Query for EIP-1967 contract upgrade events.
+ * @param contract A contract instance (must be a UUPS or transparent proxy that emits the Upgraded event).
+ * @param startBlock Optional start of the block range (inclusive). Defaults to 0.
+ * @param endBlock Optional end of the block range (inclusive). Defaults to latest.
+ * @returns An array of block numbers at which upgrades occurred, sorted ascending.
+ */
+export async function get1967Upgrades(contract: Contract, startBlock?: number, endBlock?: number): Promise<number[]> {
+  const from = startBlock ?? 0;
+  const to = endBlock ?? (await contract.provider.getBlockNumber());
+
+  const events = await paginatedEventQuery(contract, contract.filters.Upgraded(), { from, to });
+
+  return events.map(({ blockNumber }) => blockNumber);
+}

package/src/arch/evm/index.ts

@@ -1,4 +1,5 @@
 export * from "./SpokeUtils";
 export * from "./BlockUtils";
+export * from "./UpgradeUtils";
 export * from "./utils";
 export * from "./MessageUtils";

package/src/arch/index.ts

@@ -1,2 +1,3 @@
 export * as evm from "./evm";
 export * as svm from "./svm";
+export * as tvm from "./tvm";

package/src/arch/svm/BlockUtils.ts

@@ -8,7 +8,7 @@ import { SVMProvider } from "./";
 import { getNearestSlotTime } from "./utils";
 import winston from "winston";
 
-interface SVMBlock extends Block {}
+type SVMBlock = Block;
 
 const now = getCurrentTime();
 const averageBlockTimes: { [chainId: number]: BlockTimeAverage } = {

package/src/arch/tvm/SpokeUtils.ts

@@ -0,0 +1,225 @@
+import assert from "assert";
+import { Contract, providers } from "ethers";
+import { CHAIN_IDs } from "../../constants";
+import { FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import { get1967Upgrades } from "../evm/UpgradeUtils";
+import { relayFillStatus as evmRelayFillStatus } from "../evm/SpokeUtils";
+import {
+  BigNumber,
+  getRelayDataHash,
+  isDefined,
+  isUnsafeDepositId,
+  paginatedEventQuery,
+  spreadEventWithBlockNumber,
+  unpackFillEvent,
+} from "../../utils";
+
+type BlockTag = providers.BlockTag;
+
+// Re-export functions that work unchanged on TRON's JSON-RPC.
+export { populateV3Relay, getTimestampForBlock, fillStatusArray } from "../evm/SpokeUtils";
+
+// Local implementations for functions requiring historical eth_call,
+// which TRON does not support (only "latest" blockTag is accepted).
+
+/**
+ * @notice Retrieve the on-chain time at a specific block number.
+ * TRON does not support historical eth_call so block timestamps are used
+ * instead of SpokePool.getCurrentTime(). In production these are equivalent.
+ */
+export async function getTimeAt(spokePool: Contract, blockNumber: number): Promise<number> {
+  const block = await spokePool.provider.getBlock(blockNumber);
+  return block.timestamp;
+}
+
+// Fallback fill deadline buffer (6 hours) used when a contract upgrade is
+// detected in the query range. An upgrade implies fillDeadlineBuffer may
+// have changed and we cannot read historical state on TRON, so we use a
+// conservative upper bound.
+const FALLBACK_FILL_DEADLINE_BUFFER = 21600; // 6 hours in seconds
+
+/**
+ * @notice Return the maximum fill deadline buffer across a block range.
+ * TRON does not support historical eth_call, so we read the current value.
+ * If a contract upgrade (EIP-1967 Upgraded event) occurred within the range,
+ * the value may have changed at the upgrade boundary. In that case, return
+ * the greater of the current value and a conservative 6-hour fallback.
+ */
+export async function getMaxFillDeadlineInRange(
+  spokePool: Contract,
+  startBlock: number,
+  endBlock: number
+): Promise<number> {
+  const [fillDeadlineBuffer, upgrades] = await Promise.all([
+    spokePool.fillDeadlineBuffer(),
+    get1967Upgrades(spokePool, startBlock, endBlock),
+  ]);
+
+  const currentBuffer = Number(fillDeadlineBuffer);
+
+  if (upgrades.length > 0) {
+    return Math.max(currentBuffer, FALLBACK_FILL_DEADLINE_BUFFER);
+  }
+
+  return currentBuffer;
+}
+
+/**
+ * @notice Not supported on TVM — callers should use findDepositBlock instead.
+ */
+export function getDepositIdAtBlock(_contract: Contract, _blockTag: number): Promise<BigNumber> {
+  throw new Error("getDepositIdAtBlock: not supported on TVM");
+}
+
+/**
+ * @notice Find the block at which a deposit was created.
+ * TRON does not support historical eth_call, so event queries replace the
+ * EVM binary-search over numberOfDeposits().
+ */
+export async function findDepositBlock(
+  spokePool: Contract,
+  depositId: BigNumber,
+  lowBlock: number,
+  highBlock?: number
+): Promise<number | undefined> {
+  if (isUnsafeDepositId(depositId)) {
+    throw new Error(`Cannot search for depositId ${depositId}`);
+  }
+
+  highBlock ??= await spokePool.provider.getBlockNumber();
+  assert(highBlock > lowBlock, `Block numbers out of range (${lowBlock} >= ${highBlock})`);
+
+  const events = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
+    { from: lowBlock, to: highBlock }
+  );
+
+  if (events.length === 0) {
+    return undefined;
+  }
+
+  return events[0].blockNumber;
+}
+
+/**
+ * @notice Determine the fill status of a relay at a given block.
+ * For "latest" queries, delegates to the EVM implementation (TRON's
+ * eth_call works normally for "latest"). For historical queries the
+ * status is reconstructed from on-chain events because TRON does not
+ * support eth_call with historical blockTags.
+ */
+export async function relayFillStatus(
+  spokePool: Contract,
+  relayData: RelayData,
+  blockTag: BlockTag = "latest",
+  destinationChainId?: number
+): Promise<FillStatus> {
+  if (blockTag === "latest") {
+    return evmRelayFillStatus(spokePool, relayData, blockTag, destinationChainId);
+  }
+
+  destinationChainId ??= await spokePool.chainId();
+  assert(isDefined(destinationChainId));
+
+  const hash = getRelayDataHash(relayData, destinationChainId);
+
+  // Historical blockTag: check the current state first as an optimisation.
+  // Fill status can only increase (Unfilled -> RequestedSlowFill -> Filled),
+  // so if the deposit is still Unfilled now it was Unfilled at every prior block.
+  const latestStatus = Number(await spokePool.fillStatuses(hash));
+  if (latestStatus === FillStatus.Unfilled) {
+    return FillStatus.Unfilled;
+  }
+
+  // Reconstruct from events up to the requested block.
+  const fromBlock = 0;
+  const toBlock = Number(blockTag);
+
+  const fillEvents = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+    { from: fromBlock, to: toBlock }
+  );
+
+  if (fillEvents.length > 0) {
+    return FillStatus.Filled;
+  }
+
+  // No fill before blockTag — check for slow fill requests.
+  if (latestStatus >= FillStatus.RequestedSlowFill) {
+    const slowFillEvents = await paginatedEventQuery(
+      spokePool,
+      spokePool.filters.RequestedSlowFill(null, null, null, null, relayData.originChainId, relayData.depositId),
+      { from: fromBlock, to: toBlock }
+    );
+
+    if (slowFillEvents.length > 0) {
+      return FillStatus.RequestedSlowFill;
+    }
+  }
+
+  return FillStatus.Unfilled;
+}
+
+/**
+ * @notice Find the block at which a fill was completed.
+ * TRON does not support historical eth_call, so event queries replace the
+ * EVM binary-search over fillStatuses().
+ */
+export async function findFillBlock(
+  spokePool: Contract,
+  relayData: RelayData,
+  lowBlockNumber: number,
+  highBlockNumber?: number
+): Promise<number | undefined> {
+  const { provider } = spokePool;
+  highBlockNumber ??= await provider.getBlockNumber();
+  assert(highBlockNumber > lowBlockNumber, `Block numbers out of range (${lowBlockNumber} >= ${highBlockNumber})`);
+
+  const events = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+    { from: lowBlockNumber, to: highBlockNumber }
+  );
+
+  if (events.length === 0) {
+    return undefined;
+  }
+
+  return events[0].blockNumber;
+}
+
+/**
+ * @notice Find the fill event for a deposit.
+ * Queries fill events directly rather than binary-searching then re-querying.
+ */
+export async function findFillEvent(
+  spokePool: Contract,
+  relayData: RelayData,
+  lowBlockNumber: number,
+  highBlockNumber?: number
+): Promise<FillWithBlock | undefined> {
+  const { provider } = spokePool;
+  highBlockNumber ??= await provider.getBlockNumber();
+
+  const events = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+    { from: lowBlockNumber, to: highBlockNumber }
+  );
+
+  if (events.length === 0) {
+    return undefined;
+  }
+
+  const event = events[0];
+  // In production the chainId returned from the provider matches 1:1 with the actual chainId. Querying the provider
+  // object saves an RPC query because the chainId is cached by StaticJsonRpcProvider instances. In hre, the SpokePool
+  // may be configured with a different chainId than what is returned by the provider.
+  const destinationChainId = Object.values(CHAIN_IDs).includes(relayData.originChainId)
+    ? (await spokePool.provider.getNetwork()).chainId
+    : Number(await spokePool.chainId());
+
+  return unpackFillEvent(spreadEventWithBlockNumber(event), destinationChainId);
+}