@across-protocol/sdk 4.1.32 → 4.1.33

package/dist/types/utils/abi/typechain/factories/Multicall3__factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Multicall3__factory.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/abi/typechain/factories/Multicall3__factory.ts"],"names":[],"mappings":"AAIA,OAAO,EAAY,MAAM,EAAS,MAAM,QAAQ,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AA2brE,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAQ;IAC3B,MAAM,CAAC,eAAe,IAAI,mBAAmB;IAG7C,MAAM,CAAC,OAAO,CACZ,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GAAG,QAAQ,GAClC,UAAU;CAGd"}
+{"version":3,"file":"Multicall3__factory.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/abi/typechain/factories/Multicall3__factory.ts"],"names":[],"mappings":"AAIA,OAAO,EAAY,MAAM,EAAS,MAAM,QAAQ,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AA2brE,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAQ;IAC3B,MAAM,CAAC,eAAe,IAAI,mBAAmB;IAG7C,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU;CAGjF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.1.32",
+  "version": "4.1.33",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -16,8 +16,8 @@
     "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 run build:cjs & yarn run build:esm & yarn run build:types; wait",
-    "dev": "yarn run build:cjs & yarn run build:esm & yarn run build:types; wait",
+    "build": "yarn run clean && yarn typechain && yarn dev",
+    "dev": "concurrently --kill-others-on-fail --names 'cjs,esm,types' --prefix-colors 'blue,magenta,green' 'yarn run build:cjs' 'yarn run build:esm' 'yarn run build:types'",
     "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
     "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir ./dist/esm && echo > ./dist/esm/package.json '{\"type\":\"module\",\"sideEffects\":false}'",
     "build:types": "tsc --project tsconfig.build.json --module esnext --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
@@ -71,6 +71,7 @@
     "arlocal": "^1.1.65",
     "chai": "^4.3.8",
     "chai-exclude": "^2.1.0",
+    "concurrently": "^9.1.2",
     "dotenv": "^16.0.0",
     "eslint": "^8.49.0",
     "eslint-config-prettier": "^9.0.0",

package/src/arch/evm/index.ts

@@ -0,0 +1 @@
+export const platform = "evm"; // Placeholder for actual exports.

package/src/arch/index.ts

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

package/src/arch/svm/index.ts

@@ -0,0 +1 @@
+export const platform = "svm"; // Placeholder for actual exports.

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -58,6 +58,7 @@ import {
   verifyFillRepayment,
 } from "./utils";
 import { UNDEFINED_MESSAGE_HASH } from "../../constants";
+import { isEVMSpokePoolClient } from "../SpokePoolClient";
 
 // max(uint256) - 1
 export const INFINITE_FILL_DEADLINE = bnUint32Max;
@@ -388,9 +389,15 @@ export class BundleDataClient {
       await forEachAsync(fillsToCount, async (_fill) => {
         const matchingDeposit = this.spokePoolClients[_fill.originChainId].getDeposit(_fill.depositId);
         assert(isDefined(matchingDeposit), "Deposit not found for fill.");
+
+        const spokeClient = this.spokePoolClients[_fill.destinationChainId];
+        if (!isEVMSpokePoolClient(spokeClient)) {
+          // FIXME: Handle non-EVM chains.
+          throw new Error("Destination chain is not an EVM chain.");
+        }
         const fill = await verifyFillRepayment(
           _fill,
-          this.spokePoolClients[_fill.destinationChainId].spokePool.provider,
+          spokeClient.spokePool.provider,
           matchingDeposit,
           this.clients.hubPoolClient
         );
@@ -890,6 +897,10 @@ export class BundleDataClient {
                 assert(isDefined(deposits) && deposits.length > 0, "Deposit should exist in relay hash dictionary.");
                 v3RelayHashes[relayDataHash].fill = fill;
                 if (fill.blockNumber >= destinationChainBlockRange[0]) {
+                  if (!isEVMSpokePoolClient(destinationClient)) {
+                    // FIXME: Handle non-EVM chains.
+                    throw new Error("Destination chain is not an EVM chain.");
+                  }
                   const fillToRefund = await verifyFillRepayment(
                     fill,
                     destinationClient.spokePool.provider,
@@ -989,6 +1000,11 @@ export class BundleDataClient {
                 }
                 v3RelayHashes[relayDataHash].deposits = [matchedDeposit];
 
+                if (!isEVMSpokePoolClient(destinationClient)) {
+                  // FIXME: Handle non-EVM chains.
+                  throw new Error("Destination chain is not an EVM chain.");
+                }
+
                 const fillToRefund = await verifyFillRepayment(
                   fill,
                   destinationClient.spokePool.provider,
@@ -1163,6 +1179,10 @@ export class BundleDataClient {
           // include this pre fill if the fill is in an older bundle.
           if (fill) {
             if (fill.blockNumber < destinationChainBlockRange[0]) {
+              if (!isEVMSpokePoolClient(destinationClient)) {
+                // FIXME: Handle non-EVM chains.
+                throw new Error("Destination chain is not an EVM chain.");
+              }
               const fillToRefund = await verifyFillRepayment(
                 fill,
                 destinationClient.spokePool.provider,
@@ -1215,6 +1235,10 @@ export class BundleDataClient {
             const prefill = await this.findMatchingFillEvent(deposit, destinationClient);
             assert(isDefined(prefill), `findFillEvent# Cannot find prefill: ${relayDataHash}`);
             assert(getRelayEventKey(prefill) === relayDataHash, "Relay hashes should match.");
+            if (!isEVMSpokePoolClient(destinationClient)) {
+              // FIXME: Handle non-EVM chains.
+              throw new Error("Destination chain is not an EVM chain.");
+            }
             const verifiedFill = await verifyFillRepayment(
               prefill,
               destinationClient.spokePool.provider,
@@ -1511,6 +1535,10 @@ export class BundleDataClient {
     deposit: DepositWithBlock,
     spokePoolClient: SpokePoolClient
   ): Promise<FillWithBlock | undefined> {
+    if (!isEVMSpokePoolClient(spokePoolClient)) {
+      // FIXME: Handle non-EVM chains.
+      throw new Error("Destination chain is not an EVM chain.");
+    }
     return await findFillEvent(
       spokePoolClient.spokePool,
       deposit,

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -0,0 +1,206 @@
+import { Contract, EventFilter } from "ethers";
+import { BigNumber, DepositSearchResult, getNetworkName, InvalidFill, MakeOptional, toBN } from "../../utils";
+import {
+  EventSearchConfig,
+  paginatedEventQuery,
+  sortEventsAscendingInPlace,
+  spreadEventWithBlockNumber,
+} from "../../utils/EventUtils";
+import { isUpdateFailureReason } from "../BaseAbstractClient";
+import { knownEventNames, SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
+import winston from "winston";
+import { HubPoolClient } from "../HubPoolClient";
+import {
+  findDepositBlock,
+  getMaxFillDeadlineInRange as getMaxFillDeadline,
+  getTimeAt as _getTimeAt,
+  relayFillStatus,
+  isZeroAddress,
+  getTimestampForBlock as _getTimestampForBlock,
+} from "../../utils/SpokeUtils";
+import { DepositWithBlock, FillStatus, RelayData } from "../../interfaces";
+
+/**
+ * An EVM-specific SpokePoolClient.
+ */
+export class EVMSpokePoolClient extends SpokePoolClient {
+  constructor(
+    logger: winston.Logger,
+    public readonly spokePool: Contract,
+    hubPoolClient: HubPoolClient | null,
+    chainId: number,
+    deploymentBlock: number,
+    eventSearchConfig: MakeOptional<EventSearchConfig, "toBlock"> = { fromBlock: 0, maxBlockLookBack: 0 }
+  ) {
+    super(logger, hubPoolClient, chainId, deploymentBlock, eventSearchConfig);
+  }
+
+  public override relayFillStatus(
+    relayData: RelayData,
+    blockTag?: number | "latest",
+    destinationChainId?: number
+  ): Promise<FillStatus> {
+    return relayFillStatus(this.spokePool, relayData, blockTag, destinationChainId);
+  }
+
+  public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {
+    return getMaxFillDeadline(this.spokePool, startBlock, endBlock);
+  }
+
+  private _availableEventsOnSpoke(eventNames: string[] = knownEventNames): { [eventName: string]: EventFilter } {
+    return Object.fromEntries(
+      this.spokePool.interface.fragments
+        .filter(({ name, type }) => type === "event" && eventNames.includes(name))
+        .map(({ name }) => [name, this.spokePool.filters[name]()])
+    );
+  }
+
+  public override _queryableEventNames(): string[] {
+    return Object.keys(this._availableEventsOnSpoke(knownEventNames));
+  }
+
+  protected override async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
+    const searchConfig = await this.updateSearchConfig(this.spokePool.provider);
+    if (isUpdateFailureReason(searchConfig)) {
+      const reason = searchConfig;
+      return { success: false, reason };
+    }
+
+    const eventSearchConfigs = eventsToQuery.map((eventName) => {
+      if (!this._queryableEventNames().includes(eventName)) {
+        throw new Error(`SpokePoolClient: Cannot query unrecognised SpokePool event name: ${eventName}`);
+      }
+
+      const _searchConfig = { ...searchConfig }; // shallow copy
+
+      // By default, an event's query range is controlled by the `eventSearchConfig` passed in during instantiation.
+      // However, certain events have special overriding requirements to their search ranges:
+      // - EnabledDepositRoute: The full history is always required, so override the requested fromBlock.
+      if (eventName === "EnabledDepositRoute" && !this.isUpdated) {
+        _searchConfig.fromBlock = this.deploymentBlock;
+      }
+
+      return {
+        filter: this._availableEventsOnSpoke()[eventName],
+        searchConfig: _searchConfig,
+      };
+    });
+
+    const { spokePool } = this;
+    this.log("debug", `Updating SpokePool client for chain ${this.chainId}`, {
+      eventsToQuery,
+      searchConfig,
+      spokePool: spokePool.address,
+    });
+
+    const timerStart = Date.now();
+    const multicallFunctions = ["getCurrentTime"];
+    const [multicallOutput, ...events] = await Promise.all([
+      spokePool.callStatic.multicall(
+        multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
+        { blockTag: searchConfig.toBlock }
+      ),
+      ...eventSearchConfigs.map((config) => paginatedEventQuery(this.spokePool, config.filter, config.searchConfig)),
+    ]);
+    this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
+
+    const [currentTime] = multicallFunctions.map(
+      (fn, idx) => spokePool.interface.decodeFunctionResult(fn, multicallOutput[idx])[0]
+    );
+
+    if (!BigNumber.isBigNumber(currentTime) || currentTime.lt(this.currentTime)) {
+      const errMsg = BigNumber.isBigNumber(currentTime)
+        ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
+        : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
+      throw new Error(`SpokePoolClient::update: ${errMsg}`);
+    }
+
+    // Sort all events to ensure they are stored in a consistent order.
+    events.forEach((events) => sortEventsAscendingInPlace(events));
+
+    return {
+      success: true,
+      currentTime: currentTime.toNumber(), // uint32
+      searchEndBlock: searchConfig.toBlock,
+      events,
+    };
+  }
+
+  public override getTimeAt(blockNumber: number): Promise<number> {
+    return _getTimeAt(this.spokePool, blockNumber);
+  }
+
+  public override async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
+    let deposit = this.getDeposit(depositId);
+    if (deposit) {
+      return { found: true, deposit };
+    }
+
+    // No deposit found; revert to searching for it.
+    const upperBound = this.latestBlockSearched || undefined; // Don't permit block 0 as the high block.
+    const fromBlock = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
+    const chain = getNetworkName(this.chainId);
+    if (!fromBlock) {
+      const reason =
+        `Unable to find ${chain} depositId ${depositId}` +
+        ` within blocks [${this.deploymentBlock}, ${upperBound ?? "latest"}].`;
+      return { found: false, code: InvalidFill.DepositIdNotFound, reason };
+    }
+
+    const toBlock = fromBlock;
+    const tStart = Date.now();
+    // Check both V3FundsDeposited and FundsDeposited events to look for a specified depositId.
+    const { maxBlockLookBack } = this.eventSearchConfig;
+    const query = (
+      await Promise.all([
+        paginatedEventQuery(
+          this.spokePool,
+          this.spokePool.filters.V3FundsDeposited(null, null, null, null, null, depositId),
+          { fromBlock, toBlock, maxBlockLookBack }
+        ),
+        paginatedEventQuery(
+          this.spokePool,
+          this.spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
+          { fromBlock, toBlock, maxBlockLookBack }
+        ),
+      ])
+    ).flat();
+    const tStop = Date.now();
+
+    const event = query.find(({ args }) => args["depositId"].eq(depositId));
+    if (event === undefined) {
+      return {
+        found: false,
+        code: InvalidFill.DepositIdNotFound,
+        reason: `${chain} depositId ${depositId} not found at block ${fromBlock}.`,
+      };
+    }
+
+    deposit = {
+      ...spreadEventWithBlockNumber(event),
+      originChainId: this.chainId,
+      quoteBlockNumber: await this.getBlockNumber(Number(event.args["quoteTimestamp"])),
+      fromLiteChain: true, // To be updated immediately afterwards.
+      toLiteChain: true, // To be updated immediately afterwards.
+    } as DepositWithBlock;
+
+    if (isZeroAddress(deposit.outputToken)) {
+      deposit.outputToken = this.getDestinationTokenForDeposit(deposit);
+    }
+    deposit.fromLiteChain = this.isOriginLiteChain(deposit);
+    deposit.toLiteChain = this.isDestinationLiteChain(deposit);
+
+    this.logger.debug({
+      at: "SpokePoolClient#findDeposit",
+      message: "Located V3 deposit outside of SpokePoolClient's search range",
+      deposit,
+      elapsedMs: tStop - tStart,
+    });
+
+    return { found: true, deposit };
+  }
+
+  public override getTimestampForBlock(blockNumber: number): Promise<number> {
+    return _getTimestampForBlock(this.spokePool.provider, blockNumber);
+  }
+}