@across-protocol/sdk 4.1.44 → 4.1.45-beta.1

package/src/clients/BundleDataClient/utils/PoolRebalanceUtils.ts

@@ -163,12 +163,13 @@ export function updateRunningBalanceForDeposit(
   runningBalances: RunningBalances,
   hubPoolClient: HubPoolClient,
   deposit: V3DepositWithBlock,
-  updateAmount: BigNumber
+  updateAmount: BigNumber,
+  mainnetBundleEndBlock: number
 ): void {
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
     deposit.inputToken,
     deposit.originChainId,
-    deposit.quoteBlockNumber
+    mainnetBundleEndBlock
   );
   updateRunningBalance(runningBalances, deposit.originChainId, l1TokenCounterpart, updateAmount);
 }

package/src/clients/HubPoolClient.ts

@@ -231,40 +231,41 @@ export class HubPoolClient extends BaseAbstractClient {
     return sortEventsDescending(l2Tokens)[0].l1Token;
   }
 
-  /**
-   * Returns the L1 token that should be used for an L2 Bridge event. This function is
-   * designed to be used by the caller to associate the L2 token with its mapped L1 token
-   * at the HubPool equivalent block number of the L2 event.
-   * @param deposit Deposit event
-   * @param returns string L1 token counterpart for Deposit
-   */
-  getL1TokenForDeposit(deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">): string {
+  protected getL1TokenForDeposit(
+    deposit: Pick<DepositWithBlock, "originChainId" | "inputToken" | "quoteBlockNumber">
+  ): string {
     // L1-->L2 token mappings are set via PoolRebalanceRoutes which occur on mainnet,
     // so we use the latest token mapping. This way if a very old deposit is filled, the relayer can use the
     // latest L2 token mapping to find the L1 token counterpart.
     return this.getL1TokenForL2TokenAtBlock(deposit.inputToken, deposit.originChainId, deposit.quoteBlockNumber);
   }
 
-  /**
-   * Returns the L2 token that should be used as a counterpart to a deposit event. For example, the caller
-   * might want to know what the refund token will be on l2ChainId for the deposit event.
-   * @param l2ChainId Chain where caller wants to get L2 token counterpart for
-   * @param event Deposit event
-   * @returns string L2 token counterpart on l2ChainId
-   */
-  getL2TokenForDeposit(
-    deposit: Pick<DepositWithBlock, "originChainId" | "destinationChainId" | "inputToken" | "quoteBlockNumber">,
-    l2ChainId = deposit.destinationChainId
-  ): string {
-    const l1Token = this.getL1TokenForDeposit(deposit);
-    // Use the latest hub block number to find the L2 token counterpart.
-    return this.getL2TokenForL1TokenAtBlock(l1Token, l2ChainId, deposit.quoteBlockNumber);
-  }
-
   l2TokenEnabledForL1Token(l1Token: string, destinationChainId: number): boolean {
     return this.l1TokensToDestinationTokens?.[l1Token]?.[destinationChainId] != undefined;
   }
 
+  l2TokenEnabledForL1TokenAtBlock(l1Token: string, destinationChainId: number, hubBlockNumber: number): boolean {
+    // Find the last mapping published before the target block.
+    const l2Token: DestinationTokenWithBlock | undefined = sortEventsDescending(
+      this.l1TokensToDestinationTokensWithBlock?.[l1Token]?.[destinationChainId] ?? []
+    ).find((mapping: DestinationTokenWithBlock) => mapping.blockNumber <= hubBlockNumber);
+    return l2Token !== undefined;
+  }
+
+  l2TokenHasPoolRebalanceRoute(l2Token: string, l2ChainId: number, hubPoolBlock = this.latestBlockSearched): boolean {
+    return Object.values(this.l1TokensToDestinationTokensWithBlock).some((destinationTokenMapping) => {
+      return Object.entries(destinationTokenMapping).some(([_l2ChainId, setPoolRebalanceRouteEvents]) => {
+        return setPoolRebalanceRouteEvents.some((e) => {
+          return (
+            e.blockNumber <= hubPoolBlock &&
+            compareAddressesSimple(e.l2Token, l2Token) &&
+            Number(_l2ChainId) === l2ChainId
+          );
+        });
+      });
+    });
+  }
+
   /**
    * @dev If tokenAddress + chain do not exist in TOKEN_SYMBOLS_MAP then this will throw.
    * @param tokenAddress Token address on `chain`
@@ -529,21 +530,23 @@ export class HubPoolClient extends BaseAbstractClient {
     chainIdB: number,
     hubPoolBlock = this.latestBlockSearched
   ): boolean {
-    try {
-      // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
-      const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
-      const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
-      if (l1TokenA !== l1TokenB) {
-        return false;
-      }
-
-      // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
-      const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
-      const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
-      return tokenA === _tokenA && tokenB === _tokenB;
-    } catch {
-      return false; // One or both input tokens were not recognised.
+    if (
+      !this.l2TokenHasPoolRebalanceRoute(tokenA, chainIdA, hubPoolBlock) ||
+      !this.l2TokenHasPoolRebalanceRoute(tokenB, chainIdB, hubPoolBlock)
+    ) {
+      return false;
     }
+    // Resolve both SpokePool tokens back to their respective HubPool tokens and verify that they match.
+    const l1TokenA = this.getL1TokenForL2TokenAtBlock(tokenA, chainIdA, hubPoolBlock);
+    const l1TokenB = this.getL1TokenForL2TokenAtBlock(tokenB, chainIdB, hubPoolBlock);
+    if (l1TokenA !== l1TokenB) {
+      return false;
+    }
+
+    // Resolve both HubPool tokens back to a current SpokePool token and verify that they match.
+    const _tokenA = this.getL2TokenForL1TokenAtBlock(l1TokenA, chainIdA, hubPoolBlock);
+    const _tokenB = this.getL2TokenForL1TokenAtBlock(l1TokenB, chainIdB, hubPoolBlock);
+    return tokenA === _tokenA && tokenB === _tokenB;
   }
 
   getSpokeActivationBlockForChain(chainId: number): number {

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);
           }
@@ -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/MockHubPoolClient.ts

@@ -100,6 +100,22 @@ export class MockHubPoolClient extends HubPoolClient {
     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];
   }

package/src/svm/eventsClient.ts

@@ -1,6 +1,5 @@
 import { getDeployedAddress, SvmSpokeIdl } from "@across-protocol/contracts";
 import { getSolanaChainId } from "@across-protocol/contracts/dist/src/svm/web3-v1";
-import { BorshEventCoder, utils } from "@coral-xyz/anchor";
 import web3, {
   Address,
   Commitment,
@@ -9,8 +8,9 @@ import web3, {
   RpcTransport,
   Signature,
 } from "@solana/kit";
+import { bs58 } from "../utils";
 import { EventData, EventName, EventWithData } from "./types";
-import { getEventName, parseEventData } from "./utils/events";
+import { decodeEvent } from "./utils/events";
 import { isDevnet } from "./utils/helpers";
 
 // Utility type to extract the return type for the JSON encoding overload. We only care about the overload where the
@@ -185,17 +185,11 @@ export class SvmSpokeEventsClient {
           this.svmSpokeAddress === ixProgramId &&
           this.svmSpokeEventAuthority === singleIxAccount
         ) {
-          const ixData = utils.bytes.bs58.decode(ix.data);
+          const ixData = bs58.decode(ix.data);
           // Skip the first 8 bytes (assumed header) and encode the rest.
-          const eventData = utils.bytes.base64.encode(Buffer.from(new Uint8Array(ixData).slice(8)));
-          const event = new BorshEventCoder(SvmSpokeIdl).decode(eventData);
-          if (!event?.name) throw new Error("Event name is undefined");
-          const name = getEventName(event.name);
-          events.push({
-            program: this.svmSpokeAddress,
-            data: parseEventData(event?.data),
-            name,
-          });
+          const eventData = Buffer.from(ixData.slice(8)).toString("base64");
+          const { name, data } = decodeEvent(SvmSpokeIdl, eventData);
+          events.push({ program: this.svmSpokeAddress, name, data });
         }
       }
     }

package/src/svm/index.ts

@@ -1 +1,3 @@
 export * from "./eventsClient";
+export * from "./types";
+export * as utils from "./utils";

package/src/svm/utils/events.ts

@@ -1,6 +1,6 @@
-import { BN } from "@coral-xyz/anchor";
-import web3 from "@solana/kit";
-import { EventName, SVMEventNames } from "../types";
+import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
+import { address } from "@solana/kit";
+import { EventName, EventData, SVMEventNames } from "../types";
 
 /**
  * Parses event data from a transaction.
@@ -15,7 +15,7 @@ export function parseEventData(eventData: any): any {
 
   if (typeof eventData === "object") {
     if (eventData.constructor.name === "PublicKey") {
-      return web3.address(eventData.toString());
+      return address(eventData.toString());
     }
     if (BN.isBN(eventData)) {
       return BigInt(eventData.toString());
@@ -30,6 +30,18 @@ export function parseEventData(eventData: any): any {
   return eventData;
 }
 
+/**
+ * Decodes a raw event according to a supplied IDL.
+ */
+export function decodeEvent(idl: Idl, rawEvent: string): { data: EventData; name: EventName } {
+  const event = new BorshEventCoder(idl).decode(rawEvent);
+  if (!event) throw new Error(`Malformed rawEvent for IDL ${idl.address}: ${rawEvent}`);
+  return {
+    name: getEventName(event.name),
+    data: parseEventData(event.data),
+  };
+}
+
 /**
  * Converts a snake_case string to camelCase.
  */

package/src/svm/utils/index.ts

@@ -0,0 +1 @@
+export * from "./events";

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/common.ts

@@ -1,4 +1,5 @@
 import Decimal from "decimal.js";
+import bs58 from "bs58";
 import { ethers } from "ethers";
 import { BigNumber, BigNumberish, BN, formatUnits, parseUnits, toBN } from "./BigNumberUtils";
 import { ConvertDecimals } from "./FormattingUtils";
@@ -8,6 +9,7 @@ export const AddressZero = ethers.constants.AddressZero;
 export const MAX_BIG_INT = BigNumber.from(Number.MAX_SAFE_INTEGER.toString());
 
 export const { keccak256 } = ethers.utils;
+export { bs58 };
 
 /**
  * toBNWei.