@across-protocol/sdk 4.1.46-beta.0 → 4.1.46-beta.2

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -17,6 +17,7 @@ import {
   isZeroAddress,
   toAddress,
   validateFillForDeposit,
+  chainIsEvm,
 } from "../../utils";
 import {
   duplicateEvent,
@@ -41,7 +42,7 @@ import {
 } from "../../interfaces";
 import { BaseAbstractClient, UpdateFailureReason } from "../BaseAbstractClient";
 import { AcrossConfigStoreClient } from "../AcrossConfigStoreClient";
-import { getRepaymentChainId, forceDestinationRepayment } from "../BundleDataClient";
+import { getRefundInformationFromFill } from "../BundleDataClient";
 import { HubPoolClient } from "../HubPoolClient";
 
 export type SpokePoolUpdateSuccess = {
@@ -365,22 +366,25 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         fill: FillWithBlock
       ) => {
         if (validateFillForDeposit(fill, deposit).valid) {
-          const repaymentChainId = getRepaymentChainId(fill, deposit);
-          // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills that
-          // we'll have to overwrite repayment information for. This includes fills for lite chains where the
-          // repayment address is invalid, and fills for non-lite chains where the repayment address is valid or
-          // the repayment chain is invalid. We don't check that the origin chain is a valid EVM chain for
-          // lite chain deposits yet because only EVM chains are supported on Across...for now. This means
-          // this logic will have to be revisited when we add SVM to log properly.
+          const fillRepaymentData = {
+            ...fill,
+            fromLiteChain: deposit.fromLiteChain,
+          };
+          const { chainToSendRefundTo: repaymentChainId } = getRefundInformationFromFill(
+            fillRepaymentData,
+            this.hubPoolClient!,
+            this.hubPoolClient!.latestBlockSearched
+          );
+          // In order to keep this function sync, we can't call verifyFillRepayment so we'll log any fills where
+          // the filler-specified repayment chain and repayment address is not a valid repayment upon
+          // first glance. In other words, the repayment address is not a valid EVM address or the repayment chain
+          // is not a valid EVM chain. In the case where the repayment address is not a valid EVM address, the dataworker
+          // might be able to overwrite the repayment address to the msg.sender on the fill txn, but to keep this
+          // functioon synchronous, we can't make that decision now. So this function might log some false positives.
           if (
             this.hubPoolClient &&
             !isSlowFill(fill) &&
-            (!isValidEvmAddress(fill.relayer) ||
-              forceDestinationRepayment(
-                repaymentChainId,
-                { ...deposit, quoteBlockNumber: this.hubPoolClient!.latestBlockSearched },
-                this.hubPoolClient
-              ))
+            (!chainIsEvm(repaymentChainId) || !isValidEvmAddress(fill.relayer))
           ) {
             groupedFills.unrepayableFills.push(fill);
           }
@@ -397,7 +401,7 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
 
     // Log any invalid deposits with same deposit id but different params.
     const invalidFillsForDeposit = invalidFills.filter((x) => {
-      const txnUid = `${x.transactionHash}:${x.logIndex}`;
+      const txnUid = `${x.txnRef}:${x.logIndex}`;
       // if txnUid doesn't exist in the invalidFills set, add it now, but log the corresponding fill.
       const newInvalidFill = x.depositId.eq(deposit.depositId) && !this.invalidFills.has(txnUid);
       if (newInvalidFill) {
@@ -450,6 +454,29 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
     return `${event.depositId.toString()}-${event.originChainId}`;
   }
 
+  protected canResolveZeroAddressOutputToken(deposit: DepositWithBlock): boolean {
+    if (
+      !this.hubPoolClient?.l2TokenHasPoolRebalanceRoute(
+        deposit.inputToken,
+        deposit.originChainId,
+        deposit.quoteBlockNumber
+      )
+    ) {
+      return false;
+    } else {
+      const l1Token = this.hubPoolClient?.getL1TokenForL2TokenAtBlock(
+        deposit.inputToken,
+        deposit.originChainId,
+        deposit.quoteBlockNumber
+      );
+      return this.hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
+        l1Token,
+        deposit.destinationChainId,
+        deposit.quoteBlockNumber
+      );
+    }
+  }
+
   /**
    * A wrapper over the `_update` method that handles errors and logs. This method additionally calls into the
    * HubPoolClient to update the state of this client with data from the HubPool contract.
@@ -709,8 +736,19 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @returns The destination token.
    */
   protected getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
-    // If there is no rate model client return address(0).
-    return this.hubPoolClient?.getL2TokenForDeposit(deposit) ?? ZERO_ADDRESS;
+    if (!this.canResolveZeroAddressOutputToken(deposit)) {
+      return ZERO_ADDRESS;
+    }
+    // L1 token should be resolved if we get here:
+    const l1Token = this.hubPoolClient!.getL1TokenForL2TokenAtBlock(
+      deposit.inputToken,
+      deposit.originChainId,
+      deposit.quoteBlockNumber
+    )!;
+    return (
+      this.hubPoolClient!.getL2TokenForL1TokenAtBlock(l1Token, deposit.destinationChainId, deposit.quoteBlockNumber) ??
+      ZERO_ADDRESS
+    );
   }
 
   /**

package/src/clients/mocks/MockConfigStoreClient.ts

@@ -2,7 +2,14 @@ import assert from "assert";
 import winston from "winston";
 import { Contract, ethers } from "ethers";
 import { Log } from "../../interfaces";
-import { getCurrentTime, EventSearchConfig, MakeOptional, isDefined, utf8ToHex } from "../../utils";
+import {
+  getCurrentTime,
+  EventSearchConfig,
+  MakeOptional,
+  isDefined,
+  utf8ToHex,
+  spreadEventWithBlockNumber,
+} from "../../utils";
 import {
   AcrossConfigStoreClient,
   ConfigStoreUpdate,
@@ -92,9 +99,9 @@ export class MockConfigStoreClient extends AcrossConfigStoreClient {
       chainId: this.chainId as number,
       searchEndBlock: this.eventSearchConfig.toBlock || latestBlockSearched,
       events: {
-        updatedGlobalConfigEvents: events["UpdatedGlobalConfig"],
+        updatedGlobalConfigEvents: events["UpdatedGlobalConfig"].map(spreadEventWithBlockNumber),
         globalConfigUpdateTimes,
-        updatedTokenConfigEvents: events["UpdatedTokenConfig"],
+        updatedTokenConfigEvents: events["UpdatedTokenConfig"].map(spreadEventWithBlockNumber),
       },
     });
   }

package/src/clients/mocks/MockHubPoolClient.ts

@@ -23,8 +23,7 @@ export class MockHubPoolClient extends HubPoolClient {
   private realizedLpFeePctOverride = false;
 
   private l1TokensMock: L1Token[] = []; // L1Tokens and their associated info.
-  private tokenInfoToReturn: L1Token = { address: "", decimals: 0, symbol: "" };
-  
+
   private spokePoolTokens: { [l1Token: string]: { [chainId: number]: string } } = {};
 
   private eventManager: EventManager;
@@ -91,15 +90,27 @@ export class MockHubPoolClient extends HubPoolClient {
     return this.l1TokensMock;
   }
 
-  getTokenInfoForAddress() {
-    return this.tokenInfoToReturn;
-  }
-
   setTokenMapping(l1Token: string, chainId: number, l2Token: string) {
     this.spokePoolTokens[l1Token] ??= {};
     this.spokePoolTokens[l1Token][chainId] = l2Token;
   }
 
+  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
+    if (this.spokePoolTokens[l1Token]?.[destinationChainId]) {
+      return true;
+    } else {
+      return super.l2TokenEnabledForL1TokenAtBlock(l1Token, destinationChainId, hubBlockNumber);
+    }
+  }
+  l2TokenHasPoolRebalanceRoute(l2Token: string, chainId: number, hubPoolBlock: number): boolean {
+    const l1Token = Object.keys(this.spokePoolTokens).find(
+      (l1Token) => this.spokePoolTokens[l1Token]?.[chainId] === l2Token
+    );
+    if (!l1Token) {
+      return super.l2TokenHasPoolRebalanceRoute(l2Token, chainId, hubPoolBlock);
+    } else return true;
+  }
+
   deleteTokenMapping(l1Token: string, chainId: number) {
     delete this.spokePoolTokens[l1Token]?.[chainId];
   }
@@ -120,10 +131,6 @@ export class MockHubPoolClient extends HubPoolClient {
     return this.l1TokensMock.find((token) => token.address === l1Token);
   }
 
-  setTokenInfoToReturn(tokenInfo: L1Token) {
-    this.tokenInfoToReturn = tokenInfo;
-  }
-
   _update(eventNames: string[]): Promise<HubPoolUpdate> {
     // Generate new "on chain" responses.
     const latestBlockSearched = this.eventManager.blockNumber;
@@ -162,6 +169,30 @@ export class MockHubPoolClient extends HubPoolClient {
     RootBundleExecuted: "uint256,uint256,uint256,address[],uint256[],int256[],int256[],address",
   };
 
+  setCrossChainContractsEvent(
+    l2ChainId: number,
+    adapter: string,
+    spokePool: string,
+    overrides: EventOverrides = {}
+  ): Log {
+    const event = "CrossChainContractsSet";
+
+    const topics: string[] = [];
+    const args = {
+      l2ChainId,
+      adapter,
+      spokePool,
+    };
+
+    return this.eventManager.generateEvent({
+      event,
+      address: this.hubPool.address,
+      topics: topics.map((topic) => topic.toString()),
+      args,
+      blockNumber: overrides.blockNumber,
+    });
+  }
+
   setPoolRebalanceRoute(
     destinationChainId: number,
     l1Token: string,

package/src/clients/mocks/MockSpokePoolClient.ts

@@ -129,7 +129,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
   }
 
   protected _deposit(event: string, deposit: Omit<Deposit, "messageHash"> & Partial<SortableEvent>): Log {
-    const { blockNumber, transactionIndex } = deposit;
+    const { blockNumber, txnIndex } = deposit;
     let { depositId, destinationChainId, inputAmount, outputAmount } = deposit;
     depositId ??= this.numberOfDeposits;
     this.numberOfDeposits = depositId.add(bnOne);
@@ -171,7 +171,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       topics: topics.map((topic) => topic.toString()),
       args,
       blockNumber,
-      transactionIndex,
+      transactionIndex: txnIndex,
     });
   }
 
@@ -187,7 +187,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
     event: string,
     fill: Omit<Fill, "messageHash"> & { message: string } & Partial<SortableEvent>
   ): Log {
-    const { blockNumber, transactionIndex } = fill;
+    const { blockNumber, txnIndex } = fill;
     let { originChainId, depositId, inputAmount, outputAmount, fillDeadline } = fill;
     originChainId ??= random(1, 42161, false);
     depositId ??= BigNumber.from(random(1, 100_000, false));
@@ -260,7 +260,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
       topics: topics.map((topic) => topic.toString()),
       args,
       blockNumber,
-      transactionIndex,
+      transactionIndex: txnIndex,
     });
   }
 
@@ -335,7 +335,7 @@ export class MockSpokePoolClient extends EVMSpokePoolClient {
         exclusiveRelayer: addressModifier(args.exclusiveRelayer ?? ZERO_ADDRESS),
       },
       blockNumber: request.blockNumber,
-      transactionIndex: request.transactionIndex,
+      transactionIndex: request.txnIndex,
     });
   }
 

package/src/interfaces/Common.ts

@@ -9,9 +9,9 @@ export type Log = _Log & {
 
 export interface SortableEvent {
   blockNumber: number;
-  transactionIndex: number;
+  txnIndex: number;
   logIndex: number;
-  transactionHash: string;
+  txnRef: string;
 }
 
 export interface BigNumberForToken {

package/src/utils/AddressUtils.ts

@@ -241,6 +241,10 @@ export class SvmAddress extends Address {
     return this.toBase58();
   }
 
+  override toEvmAddress(): string {
+    return toAddress(`0x${this.toBytes32().slice(-40)}`);
+  }
+
   // Constructs a new SvmAddress type.
   static from(bs58Address: string): SvmAddress {
     return new this(bs58.decode(bs58Address));

package/src/utils/DepositUtils.ts

@@ -2,7 +2,7 @@ import assert from "assert";
 import { SpokePoolClient } from "../clients";
 import { DEFAULT_CACHING_TTL, EMPTY_MESSAGE, UNDEFINED_MESSAGE_HASH, ZERO_BYTES } from "../constants";
 import { CachingMechanismInterface, Deposit, DepositWithBlock, Fill, RelayData, SlowFillRequest } from "../interfaces";
-import { getMessageHash, isUnsafeDepositId } from "./SpokeUtils";
+import { getMessageHash, isUnsafeDepositId, isZeroAddress } from "./SpokeUtils";
 import { getNetworkName } from "./NetworkUtils";
 import { bnZero } from "./BigNumberUtils";
 import { getDepositInCache, getDepositKey, setDepositInCache } from "./CachingUtils";
@@ -208,6 +208,11 @@ export function isZeroValueDeposit(deposit: Pick<Deposit, "inputAmount" | "messa
   return deposit.inputAmount.eq(0) && isMessageEmpty(deposit.message);
 }
 
+export function invalidOutputToken(deposit: Pick<DepositWithBlock, "outputToken">): boolean {
+  // If the output token is zero address, then it is invalid.
+  return isZeroAddress(deposit.outputToken);
+}
+
 export function isZeroValueFillOrSlowFillRequest(
   e: Pick<Fill | SlowFillRequest, "inputAmount" | "messageHash">
 ): boolean {

package/src/utils/EventUtils.ts

@@ -204,13 +204,19 @@ export function getPaginatedBlockRanges({
   return ranges;
 }
 
+export function logToSortableEvent(log: Log): SortableEvent {
+  return {
+    txnIndex: log.transactionIndex,
+    txnRef: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+  };
+}
+
 export function spreadEventWithBlockNumber(event: Log): SortableEvent {
   return {
     ...spreadEvent(event.args),
-    blockNumber: event.blockNumber,
-    transactionIndex: event.transactionIndex,
-    logIndex: event.logIndex,
-    transactionHash: event.transactionHash,
+    ...logToSortableEvent(event),
   };
 }
 
@@ -226,8 +232,8 @@ export function sortEventsAscendingInPlace<T extends SortableEvent>(events: T[])
     if (ex.blockNumber !== ey.blockNumber) {
       return ex.blockNumber - ey.blockNumber;
     }
-    if (ex.transactionIndex !== ey.transactionIndex) {
-      return ex.transactionIndex - ey.transactionIndex;
+    if (ex.txnIndex !== ey.txnIndex) {
+      return ex.txnIndex - ey.txnIndex;
     }
     return ex.logIndex - ey.logIndex;
   });
@@ -245,8 +251,8 @@ export function sortEventsDescendingInPlace<T extends SortableEvent>(events: T[]
     if (ex.blockNumber !== ey.blockNumber) {
       return ey.blockNumber - ex.blockNumber;
     }
-    if (ex.transactionIndex !== ey.transactionIndex) {
-      return ey.transactionIndex - ex.transactionIndex;
+    if (ex.txnIndex !== ey.txnIndex) {
+      return ey.txnIndex - ex.txnIndex;
     }
     return ey.logIndex - ex.logIndex;
   });
@@ -257,16 +263,16 @@ export function isEventOlder<T extends SortableEvent>(ex: T, ey: T): boolean {
   if (ex.blockNumber !== ey.blockNumber) {
     return ex.blockNumber < ey.blockNumber;
   }
-  if (ex.transactionIndex !== ey.transactionIndex) {
-    return ex.transactionIndex < ey.transactionIndex;
+  if (ex.txnIndex !== ey.txnIndex) {
+    return ex.txnIndex < ey.txnIndex;
   }
   return ex.logIndex < ey.logIndex;
 }
 
-export function getTransactionHashes(events: SortableEvent[]): string[] {
-  return [...Array.from(new Set(events.map((e) => e.transactionHash)))];
+export function getTransactionRefs(events: SortableEvent[]): string[] {
+  return [...Array.from(new Set(events.map((e) => e.txnRef)))];
 }
 
 export function duplicateEvent(a: SortableEvent, b: SortableEvent): boolean {
-  return a.transactionHash === b.transactionHash && a.logIndex === b.logIndex;
+  return a.txnRef === b.txnRef && a.logIndex === b.logIndex;
 }