@across-protocol/sdk 4.1.43 → 4.1.45-beta.0

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

@@ -1,124 +1,119 @@
 import _ from "lodash";
+import assert from "assert";
 import { providers } from "ethers";
-import { Deposit, DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
-import { getBlockRangeForChain, isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
+import { DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
+import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 
+/**
+ * @notice FillRepaymentInformation is a fill with additional properties required to determine where it can
+ * be repaid.
+ */
+type FillRepaymentInformation = Fill & { quoteBlockNumber: number; fromLiteChain: boolean };
+
+/**
+ * @notice Return repayment chain and repayment token for a fill, but does not verify if the returned
+ * repayment information is valid for the desired repayment address.
+ * @dev The passed in fill should be verified first via verifyFillRepayment().
+ * @param fill The fill to get the repayment information for.
+ * @return The chain to send the refund to and the token to use for the refund.
+ */
 export function getRefundInformationFromFill(
-  fill: Fill,
-  hubPoolClient: HubPoolClient,
-  blockRangesForChains: number[][],
-  chainIdListForBundleEvaluationBlockNumbers: number[],
-  fromLiteChain: boolean
+  relayData: FillRepaymentInformation,
+  hubPoolClient: HubPoolClient
 ): {
   chainToSendRefundTo: number;
   repaymentToken: string;
 } {
-  // Handle slow relay where repaymentChainId = 0. Slow relays always pay recipient on destination chain.
-  // So, save the slow fill under the destination chain, and save the fast fill under its repayment chain.
-  let chainToSendRefundTo = isSlowFill(fill) ? fill.destinationChainId : fill.repaymentChainId;
-  // If the fill is for a deposit originating from the lite chain, the repayment chain is the origin chain
-  // regardless of whether it is a slow or fast fill (we ignore slow fills but this is for posterity).
-  // @note fill.repaymentChainId should already be set to originChainId but reset it to be safe.
-  if (fromLiteChain) {
-    chainToSendRefundTo = fill.originChainId;
+  const chainToSendRefundTo = _getRepaymentChainId(relayData, hubPoolClient);
+  if (chainToSendRefundTo === relayData.originChainId) {
+    return {
+      chainToSendRefundTo,
+      repaymentToken: relayData.inputToken,
+    };
   }
 
-  // Save fill data and associate with repayment chain and L2 token refund should be denominated in.
-  const endBlockForMainnet = getBlockRangeForChain(
-    blockRangesForChains,
-    hubPoolClient.chainId,
-    chainIdListForBundleEvaluationBlockNumbers
-  )[1];
-
+  // Now figure out the equivalent L2 token for the repayment token. If the inputToken doesn't have a
+  // PoolRebalanceRoute, then the repayment chain would have been the originChainId after the getRepaymentChainId()
+  // call and we would have returned already, so the following call should always succeed.
   const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-    fill.inputToken,
-    fill.originChainId,
-    endBlockForMainnet
+    relayData.inputToken,
+    relayData.originChainId,
+    relayData.quoteBlockNumber
   );
 
   const repaymentToken = hubPoolClient.getL2TokenForL1TokenAtBlock(
     l1TokenCounterpart,
     chainToSendRefundTo,
-    endBlockForMainnet
+    relayData.quoteBlockNumber
   );
   return {
     chainToSendRefundTo,
     repaymentToken,
   };
 }
-
-export function getRepaymentChainId(fill: Fill, matchedDeposit: Deposit): number {
-  // Lite chain deposits force repayment on origin chain.
-  return matchedDeposit.fromLiteChain ? matchedDeposit.originChainId : fill.repaymentChainId;
-}
-
-export function forceDestinationRepayment(
-  repaymentChainId: number,
-  matchedDeposit: Deposit & { quoteBlockNumber: number },
-  hubPoolClient: HubPoolClient
-): boolean {
-  if (!matchedDeposit.fromLiteChain) {
-    try {
-      const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
-        matchedDeposit.inputToken,
-        matchedDeposit.originChainId,
-        matchedDeposit.quoteBlockNumber
-      );
-      hubPoolClient.getL2TokenForL1TokenAtBlock(l1TokenCounterpart, repaymentChainId, matchedDeposit.quoteBlockNumber);
-      // Repayment token could be found, this is a valid repayment chain.
-      return false;
-    } catch {
-      // Repayment token doesn't exist on repayment chain via PoolRebalanceRoutes, impossible to repay filler there.
-      return true;
-    }
-  } else {
-    return false;
-  }
-}
-
-// Verify that a fill sent to an EVM chain has a 20 byte address. If the fill does not, then attempt
-// to repay the `msg.sender` of the relay transaction. Otherwise, return undefined.
+/**
+ * @notice Verifies that the fill can be repaid. If the repayment address is not
+ * valid for the requested repayment chain, then this function will attempt to change the fill's repayment chain
+ * to the destination chain and its repayment address to the  msg.sender and if this is possible,
+ * return the fill. Otherwise, return undefined.
+ * @param _fill Fill with a requested repayment chain and address
+ * @return Fill with the applied repayment chain (depends on the validity of the requested repayment address)
+ * and applied repayment address, or undefined if the applied repayment address is not valid for the
+ * applied repayment chain.
+ */
 export async function verifyFillRepayment(
   _fill: FillWithBlock,
   destinationChainProvider: providers.Provider,
   matchedDeposit: DepositWithBlock,
   hubPoolClient: HubPoolClient
 ): Promise<FillWithBlock | undefined> {
-  const fill = _.cloneDeep(_fill);
+  const fill = {
+    ..._.cloneDeep(_fill),
+    fromLiteChain: matchedDeposit.fromLiteChain,
+    quoteBlockNumber: matchedDeposit.quoteBlockNumber,
+  };
 
   // Slow fills don't result in repayments so they're always valid.
   if (isSlowFill(fill)) {
     return fill;
   }
 
-  let repaymentChainId = getRepaymentChainId(fill, matchedDeposit);
+  let repaymentChainId = _getRepaymentChainId(fill, hubPoolClient);
 
-  // If repayment chain doesn't have a Pool Rebalance Route for the input token, then change the repayment
-  // chain to the destination chain.
-  if (forceDestinationRepayment(repaymentChainId, matchedDeposit, hubPoolClient)) {
-    repaymentChainId = fill.destinationChainId;
-  }
-
-  if (!isValidEvmAddress(fill.relayer)) {
+  // Repayments will always go to the fill.relayer address so check if its a valid EVM address. If its not, attempt
+  // to change it to the msg.sender of the FilledRelay.
+  if (_repaymentAddressNeedsToBeOverwritten(fill)) {
     // TODO: Handle case where fill was sent on non-EVM chain, in which case the following call would fail
     // or return something unexpected. We'd want to return undefined here.
+
+    // @todo: If chainIsEvm:
     const fillTransaction = await destinationChainProvider.getTransaction(fill.transactionHash);
     const destinationRelayer = fillTransaction?.from;
     // Repayment chain is still an EVM chain, but the msg.sender is a bytes32 address, so the fill is invalid.
     if (!isDefined(destinationRelayer) || !isValidEvmAddress(destinationRelayer)) {
       return undefined;
     }
-    if (!matchedDeposit.fromLiteChain) {
+    // If we can switch the repayment chain to the destination chain, then do so. We should only switch if the
+    // destination chain has a valid repayment token that is equivalent to the deposited input token. This would
+    // also be the same mapping as the repayment token on the repayment chain.
+    if (
+      !matchedDeposit.fromLiteChain &&
+      hubPoolClient.areTokensEquivalent(fill.inputToken, fill.originChainId, fill.outputToken, fill.destinationChainId)
+    ) {
       repaymentChainId = fill.destinationChainId;
-    } else {
-      // We can't switch repayment chain for a lite chain deposit so just check whether the repayment chain,
-      // which should be the origin chain, is an EVM chain.
+    }
+    // If we can't switch the chain, then we need to verify that the msg.sender is a valid address on the repayment chain.
+    // Because we already checked that the `destinationRelayer` was a valid EVM address above, we only need to check
+    // that the repayment chain is an EVM chain.
+    else {
       if (!chainIsEvm(repaymentChainId)) {
         return undefined;
       }
     }
     fill.relayer = destinationRelayer;
+
+    // @todo: If chainIsSvm:
   }
 
   // Repayment address is now valid and repayment chain is either origin chain for lite chain or the destination
@@ -126,3 +121,65 @@ export async function verifyFillRepayment(
   fill.repaymentChainId = repaymentChainId;
   return fill;
 }
+
+function _getRepaymentChainId(relayData: FillRepaymentInformation, hubPoolClient: HubPoolClient): number {
+  if (relayData.fromLiteChain) {
+    assert(!isSlowFill(relayData), "getRepaymentChainId: fromLiteChain and slow fill are mutually exclusive");
+    return relayData.originChainId;
+  }
+
+  // Handle slow relay where FilledRelay.repaymentChainId = 0, as hardcoded in the SpokePool contract.
+  // Slow relays always pay recipient on destination chain.
+  if (isSlowFill(relayData)) {
+    return relayData.destinationChainId;
+  }
+
+  // Repayment chain is valid if the input token and repayment chain are mapped to the same PoolRebalanceRoute.
+  const repaymentTokenIsValid = _repaymentChainTokenIsValid(relayData, hubPoolClient);
+  if (repaymentTokenIsValid) {
+    return relayData.repaymentChainId;
+  }
+
+  // If repayment chain is not valid, default to origin chain since we always know the input token can be refunded.
+  return relayData.originChainId;
+}
+
+function _repaymentChainTokenIsValid(relayData: FillRepaymentInformation, hubPoolClient: HubPoolClient): boolean {
+  if (
+    !hubPoolClient.l2TokenHasPoolRebalanceRoute(
+      relayData.inputToken,
+      relayData.originChainId,
+      relayData.quoteBlockNumber
+    )
+  ) {
+    return false;
+  }
+  const l1TokenCounterpart = hubPoolClient.getL1TokenForL2TokenAtBlock(
+    relayData.inputToken,
+    relayData.originChainId,
+    relayData.quoteBlockNumber
+  );
+  if (
+    !hubPoolClient.l2TokenEnabledForL1TokenAtBlock(
+      l1TokenCounterpart,
+      relayData.repaymentChainId,
+      relayData.quoteBlockNumber
+    )
+  ) {
+    return false;
+  }
+  return true;
+}
+
+function _repaymentAddressNeedsToBeOverwritten(fill: Fill): boolean {
+  // Slow fills don't result in repayments so they're always valid.
+  if (isSlowFill(fill)) {
+    return false;
+  }
+
+  // @todo add Solana logic here:
+  // - i.e. If chainIsSvm && !isValidSvmAddress(fill.relayer) then return false
+  //        If chainIsEvm && !isValidEvmAddress(fill.relayer) then return false
+  //        If chainIsEvm && isValidEvmAddress(fill.relayer) then return true
+  return !isValidEvmAddress(fill.relayer);
+}

package/src/clients/HubPoolClient.ts

@@ -265,6 +265,28 @@ export class HubPoolClient extends BaseAbstractClient {
     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 +551,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,
+            quoteBlockNumber: this.hubPoolClient!.latestBlockSearched,
+          };
+          const { chainToSendRefundTo: repaymentChainId } = getRefundInformationFromFill(
+            fillRepaymentData,
+            this.hubPoolClient!
+          );
+          // 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,25 @@ 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?.getL1TokenForDeposit(deposit);
+      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,6 +732,9 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
    * @returns The destination token.
    */
   protected getDestinationTokenForDeposit(deposit: DepositWithBlock): string {
+    if (!this.canResolveZeroAddressOutputToken(deposit)) {
+      return ZERO_ADDRESS;
+    }
     // If there is no rate model client return address(0).
     return this.hubPoolClient?.getL2TokenForDeposit(deposit) ?? 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/constants.ts

@@ -66,6 +66,19 @@ export const BRIDGED_USDC_SYMBOLS = [
   TOKEN_SYMBOLS_MAP.USDzC.symbol,
 ];
 
+export const STABLE_COIN_SYMBOLS = [
+  ...BRIDGED_USDC_SYMBOLS,
+  TOKEN_SYMBOLS_MAP.USDB.symbol,
+  TOKEN_SYMBOLS_MAP.USDC.symbol,
+  TOKEN_SYMBOLS_MAP.USDT.symbol,
+  TOKEN_SYMBOLS_MAP.DAI.symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDC"].symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDT"].symbol,
+  TOKEN_SYMBOLS_MAP["TATARA-USDS"].symbol,
+  TOKEN_SYMBOLS_MAP.GHO.symbol,
+  TOKEN_SYMBOLS_MAP.WGHO.symbol,
+];
+
 export const CUSTOM_GAS_TOKENS = {
   [CHAIN_IDs.POLYGON]: "MATIC",
   [CHAIN_IDs.POLYGON_AMOY]: "MATIC",

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

@@ -109,6 +109,12 @@ export function isBridgedUsdc(tokenSymbol: string): boolean {
   );
 }
 
+export function isStablecoin(tokenSymbol: string): boolean {
+  return constants.STABLE_COIN_SYMBOLS.some(
+    (stablecoinSymbol) => stablecoinSymbol.toLowerCase() === tokenSymbol.toLowerCase()
+  );
+}
+
 export function getTokenInfo(l2TokenAddress: string, chainId: number): L1Token {
   // @dev This might give false positives if tokens on different networks have the same address. I'm not sure how
   // to get around this...

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.

package/dist/cjs/addressAggregator/adapters/util.d.ts

@@ -1,4 +0,0 @@
-import { Logger } from "../../utils";
-export { Logger } from "../../utils";
-export declare function logError(name: string, error: unknown, logger?: Logger): Promise<string[]>;
-export declare function fetch(name: string, url: string, timeout?: number, retries?: number): Promise<unknown>;