@across-protocol/sdk 4.2.16 → 4.3.0

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -39,10 +39,9 @@ import {
   bnUint32Max,
   isZeroValueDeposit,
   isZeroValueFillOrSlowFillRequest,
-  chainIsEvm,
-  isValidEvmAddress,
   duplicateEvent,
   invalidOutputToken,
+  Address,
   getNetworkName,
 } from "../../utils";
 import winston from "winston";
@@ -69,22 +68,21 @@ type DataCache = Record<string, Promise<LoadDataReturnValue>>;
 // V3 dictionary helper functions
 function updateExpiredDepositsV3(dict: ExpiredDepositsToRefundV3, deposit: V3DepositWithBlock): void {
   // A deposit refund for a deposit is invalid if the depositor has a bytes32 address input for an EVM chain. It is valid otherwise.
-  if (chainIsEvm(deposit.originChainId) && !isValidEvmAddress(deposit.depositor)) {
+  if (!deposit.depositor.isValidOn(deposit.originChainId)) {
     return;
   }
+
   const { originChainId, inputToken } = deposit;
-  if (!dict?.[originChainId]?.[inputToken]) {
-    assign(dict, [originChainId, inputToken], []);
-  }
-  dict[originChainId][inputToken].push(deposit);
+  dict[originChainId] ??= {};
+  dict[originChainId][inputToken.toBytes32()] ??= [];
+  dict[originChainId][inputToken.toBytes32()].push(deposit);
 }
 
 function updateBundleDepositsV3(dict: BundleDepositsV3, deposit: V3DepositWithBlock): void {
   const { originChainId, inputToken } = deposit;
-  if (!dict?.[originChainId]?.[inputToken]) {
-    assign(dict, [originChainId, inputToken], []);
-  }
-  dict[originChainId][inputToken].push(deposit);
+  dict[originChainId] ??= {};
+  dict[originChainId][inputToken.toBytes32()] ??= [];
+  dict[originChainId][inputToken.toBytes32()].push(deposit);
 }
 
 function updateBundleFillsV3(
@@ -92,29 +90,29 @@ function updateBundleFillsV3(
   fill: V3FillWithBlock,
   lpFeePct: BigNumber,
   repaymentChainId: number,
-  repaymentToken: string,
-  repaymentAddress: string
+  repaymentToken: Address,
+  repaymentAddress: Address
 ): void {
   // We shouldn't pass any unrepayable fills into this function, so we perform an extra safety check.
-  if (chainIsEvm(repaymentChainId) && !isValidEvmAddress(fill.relayer)) {
+  if (!fill.relayer.isValidOn(repaymentChainId)) {
     return;
   }
-  if (!dict?.[repaymentChainId]?.[repaymentToken]) {
-    assign(dict, [repaymentChainId, repaymentToken], {
-      fills: [],
-      totalRefundAmount: bnZero,
-      realizedLpFees: bnZero,
-      refunds: {},
-    });
-  }
+
+  dict[repaymentChainId] ??= {};
+  dict[repaymentChainId][repaymentToken.toBytes32()] ??= {
+    fills: [],
+    totalRefundAmount: bnZero,
+    realizedLpFees: bnZero,
+    refunds: {},
+  };
 
   const bundleFill: BundleFillV3 = { ...fill, lpFeePct, relayer: repaymentAddress };
 
   // Add all fills, slow and fast, to dictionary.
-  assign(dict, [repaymentChainId, repaymentToken, "fills"], [bundleFill]);
+  assign(dict, [repaymentChainId, repaymentToken.toBytes32(), "fills"], [bundleFill]);
 
   // All fills update the bundle LP fees.
-  const refundObj = dict[repaymentChainId][repaymentToken];
+  const refundObj = dict[repaymentChainId][repaymentToken.toBytes32()];
   const realizedLpFee = bundleFill.inputAmount.mul(bundleFill.lpFeePct).div(fixedPointAdjustment);
   refundObj.realizedLpFees = refundObj.realizedLpFees ? refundObj.realizedLpFees.add(realizedLpFee) : realizedLpFee;
 
@@ -128,10 +126,11 @@ function updateBundleFillsV3(
     // Instantiate dictionary if it doesn't exist.
     refundObj.refunds ??= {};
 
-    if (refundObj.refunds[bundleFill.relayer]) {
-      refundObj.refunds[bundleFill.relayer] = refundObj.refunds[bundleFill.relayer].add(refundAmount);
+    if (refundObj.refunds[bundleFill.relayer.toBytes32()]) {
+      refundObj.refunds[bundleFill.relayer.toBytes32()] =
+        refundObj.refunds[bundleFill.relayer.toBytes32()].add(refundAmount);
     } else {
-      refundObj.refunds[bundleFill.relayer] = refundAmount;
+      refundObj.refunds[bundleFill.relayer.toBytes32()] = refundAmount;
     }
   }
 }
@@ -141,21 +140,20 @@ function updateBundleExcessSlowFills(
   deposit: V3DepositWithBlock & { lpFeePct: BigNumber }
 ): void {
   const { destinationChainId, outputToken } = deposit;
-  if (!dict?.[destinationChainId]?.[outputToken]) {
-    assign(dict, [destinationChainId, outputToken], []);
-  }
-  dict[destinationChainId][outputToken].push(deposit);
+  dict[destinationChainId] ??= {};
+  dict[destinationChainId][outputToken.toBytes32()] ??= [];
+  dict[destinationChainId][outputToken.toBytes32()].push(deposit);
 }
 
 function updateBundleSlowFills(dict: BundleSlowFills, deposit: V3DepositWithBlock & { lpFeePct: BigNumber }): void {
-  if (chainIsEvm(deposit.destinationChainId) && !isValidEvmAddress(deposit.recipient)) {
+  if (!deposit.recipient.isValidOn(deposit.destinationChainId)) {
     return;
   }
+
   const { destinationChainId, outputToken } = deposit;
-  if (!dict?.[destinationChainId]?.[outputToken]) {
-    assign(dict, [destinationChainId, outputToken], []);
-  }
-  dict[destinationChainId][outputToken].push(deposit);
+  dict[destinationChainId] ??= {};
+  dict[destinationChainId][outputToken.toBytes32()] ??= [];
+  dict[destinationChainId][outputToken.toBytes32()].push(deposit);
 }
 
 // @notice Shared client for computing data needed to construct or validate a bundle.
@@ -507,22 +505,24 @@ export class BundleDataClient {
         // worst from the relayer's perspective.
         const { relayer, inputAmount: refundAmount } = fill;
         refundsForChain[chainToSendRefundTo] ??= {};
-        refundsForChain[chainToSendRefundTo][repaymentToken] ??= {};
-        const existingRefundAmount = refundsForChain[chainToSendRefundTo][repaymentToken][relayer] ?? bnZero;
-        refundsForChain[chainToSendRefundTo][repaymentToken][relayer] = existingRefundAmount.add(refundAmount);
+        refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()] ??= {};
+        const existingRefundAmount =
+          refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()][relayer.toBytes32()] ?? bnZero;
+        refundsForChain[chainToSendRefundTo][repaymentToken.toBytes32()][relayer.toBytes32()] =
+          existingRefundAmount.add(refundAmount);
       });
     }
     return refundsForChain;
   }
 
-  getUpcomingDepositAmount(chainId: number, l2Token: string, latestBlockToSearch: number): BigNumber {
+  getUpcomingDepositAmount(chainId: number, l2Token: Address, latestBlockToSearch: number): BigNumber {
     const spokePoolClient = this.spokePoolClientManager.getClient(chainId);
     if (!isDefined(spokePoolClient)) {
       return toBN(0);
     }
     return spokePoolClient
       .getDeposits()
-      .filter((deposit) => deposit.blockNumber > latestBlockToSearch && deposit.inputToken === l2Token)
+      .filter((deposit) => deposit.blockNumber > latestBlockToSearch && deposit.inputToken.eq(l2Token))
       .reduce((acc, deposit) => {
         return acc.add(deposit.inputAmount);
       }, toBN(0));
@@ -645,18 +645,18 @@ export class BundleDataClient {
     const executedRefunds: { [tokenAddress: string]: { [relayer: string]: BigNumber } } = {};
     for (const refundLeaf of executedRefundLeaves) {
       const tokenAddress = refundLeaf.l2TokenAddress;
-      if (executedRefunds[tokenAddress] === undefined) {
-        executedRefunds[tokenAddress] = {};
+      if (executedRefunds[tokenAddress.toBytes32()] === undefined) {
+        executedRefunds[tokenAddress.toBytes32()] = {};
       }
-      const executedTokenRefunds = executedRefunds[tokenAddress];
+      const executedTokenRefunds = executedRefunds[tokenAddress.toBytes32()];
 
       for (let i = 0; i < refundLeaf.refundAddresses.length; i++) {
         const relayer = refundLeaf.refundAddresses[i];
         const refundAmount = refundLeaf.refundAmounts[i];
-        if (executedTokenRefunds[relayer] === undefined) {
-          executedTokenRefunds[relayer] = bnZero;
+        if (executedTokenRefunds[relayer.toBytes32()] === undefined) {
+          executedTokenRefunds[relayer.toBytes32()] = bnZero;
         }
-        executedTokenRefunds[relayer] = executedTokenRefunds[relayer].add(refundAmount);
+        executedTokenRefunds[relayer.toBytes32()] = executedTokenRefunds[relayer.toBytes32()].add(refundAmount);
       }
     }
     return executedRefunds;
@@ -695,15 +695,15 @@ export class BundleDataClient {
     return allRefunds;
   }
 
-  getRefundsFor(bundleRefunds: CombinedRefunds, relayer: string, chainId: number, token: string): BigNumber {
-    if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token]) {
+  getRefundsFor(bundleRefunds: CombinedRefunds, relayer: Address, chainId: number, token: Address): BigNumber {
+    if (!bundleRefunds[chainId] || !bundleRefunds[chainId][token.toBytes32()]) {
       return BigNumber.from(0);
     }
-    const allRefunds = bundleRefunds[chainId][token];
-    return allRefunds && allRefunds[relayer] ? allRefunds[relayer] : BigNumber.from(0);
+    const allRefunds = bundleRefunds[chainId][token.toBytes32()];
+    return allRefunds && allRefunds[relayer.toBytes32()] ? allRefunds[relayer.toBytes32()] : BigNumber.from(0);
   }
 
-  getTotalRefund(refunds: CombinedRefunds[], relayer: string, chainId: number, refundToken: string): BigNumber {
+  getTotalRefund(refunds: CombinedRefunds[], relayer: Address, chainId: number, refundToken: Address): BigNumber {
     return refunds.reduce((totalRefund, refunds) => {
       return totalRefund.add(this.getRefundsFor(refunds, relayer, chainId, refundToken));
     }, bnZero);
@@ -916,7 +916,11 @@ export class BundleDataClient {
             "Not using correct bundle deposit hash key"
           );
           if (deposit.blockNumber >= originChainBlockRange[0]) {
-            if (bundleDepositsV3?.[originChainId]?.[deposit.inputToken]?.find((d) => duplicateEvent(deposit, d))) {
+            if (
+              bundleDepositsV3?.[originChainId]?.[deposit.inputToken.toBytes32()]?.find((d) =>
+                duplicateEvent(deposit, d)
+              )
+            ) {
               this.logger.debug({
                 at: "BundleDataClient#loadData",
                 message: "Duplicate deposit detected",

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

@@ -17,6 +17,7 @@ import {
   fixedPointAdjustment,
   count2DDictionaryValues,
   count3DDictionaryValues,
+  toAddressType,
 } from "../../../utils";
 import {
   addLastRunningBalance,
@@ -65,10 +66,10 @@ export function getRefundsFromBundle(
     Object.entries(depositsForChain).forEach(([l2TokenAddress, deposits]) => {
       deposits.forEach((deposit) => {
         if (combinedRefunds[originChainId][l2TokenAddress] === undefined) {
-          combinedRefunds[originChainId][l2TokenAddress] = { [deposit.depositor]: deposit.inputAmount };
+          combinedRefunds[originChainId][l2TokenAddress] = { [deposit.depositor.toBytes32()]: deposit.inputAmount };
         } else {
-          const existingRefundAmount = combinedRefunds[originChainId][l2TokenAddress][deposit.depositor];
-          combinedRefunds[originChainId][l2TokenAddress][deposit.depositor] = deposit.inputAmount.add(
+          const existingRefundAmount = combinedRefunds[originChainId][l2TokenAddress][deposit.depositor.toBytes32()];
+          combinedRefunds[originChainId][l2TokenAddress][deposit.depositor.toBytes32()] = deposit.inputAmount.add(
             existingRefundAmount ?? bnZero
           );
         }
@@ -153,19 +154,23 @@ export function _buildPoolRebalanceRoot(
         // If the repayment token and repayment chain ID do not map to a PoolRebalanceRoute graph, then
         // there are no relevant L1 running balances.
         if (
-          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(l2TokenAddress, repaymentChainId, mainnetBundleEndBlock)
+          !clients.hubPoolClient.l2TokenHasPoolRebalanceRoute(
+            toAddressType(l2TokenAddress, repaymentChainId),
+            repaymentChainId,
+            mainnetBundleEndBlock
+          )
         ) {
           chainWithRefundsOnly.add(repaymentChainId);
           return;
         }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          l2TokenAddress,
+          toAddressType(l2TokenAddress, repaymentChainId),
           repaymentChainId,
           mainnetBundleEndBlock
         );
 
-        updateRunningBalance(runningBalances, repaymentChainId, l1TokenCounterpart, totalRefundAmount);
-        updateRunningBalance(realizedLpFees, repaymentChainId, l1TokenCounterpart, totalRealizedLpFee);
+        updateRunningBalance(runningBalances, repaymentChainId, l1TokenCounterpart.toEvmAddress(), totalRefundAmount);
+        updateRunningBalance(realizedLpFees, repaymentChainId, l1TokenCounterpart.toEvmAddress(), totalRealizedLpFee);
       }
     );
   });
@@ -182,12 +187,17 @@ export function _buildPoolRebalanceRoot(
     Object.entries(depositsForChain).forEach(([outputToken, deposits]) => {
       deposits.forEach((deposit) => {
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          outputToken,
+          toAddressType(outputToken, destinationChainId),
           destinationChainId,
           mainnetBundleEndBlock
         );
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
-        updateRunningBalance(runningBalances, destinationChainId, l1TokenCounterpart, deposit.inputAmount.sub(lpFee));
+        updateRunningBalance(
+          runningBalances,
+          destinationChainId,
+          l1TokenCounterpart.toEvmAddress(),
+          deposit.inputAmount.sub(lpFee)
+        );
         // Slow fill LP fees are accounted for when the slow fill executes and a V3FilledRelay is emitted. i.e. when
         // the slow fill execution is included in bundleFillsV3.
       });
@@ -206,12 +216,17 @@ export function _buildPoolRebalanceRoot(
     Object.entries(slowFilledDepositsForChain).forEach(([outputToken, slowFilledDeposits]) => {
       slowFilledDeposits.forEach((deposit) => {
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          outputToken,
+          toAddressType(outputToken, destinationChainId),
           destinationChainId,
           mainnetBundleEndBlock
         );
         const lpFee = deposit.lpFeePct.mul(deposit.inputAmount).div(fixedPointAdjustment);
-        updateRunningBalance(runningBalances, destinationChainId, l1TokenCounterpart, lpFee.sub(deposit.inputAmount));
+        updateRunningBalance(
+          runningBalances,
+          destinationChainId,
+          l1TokenCounterpart.toEvmAddress(),
+          lpFee.sub(deposit.inputAmount)
+        );
         // Slow fills don't add to lpFees, only when the slow fill is executed and a V3FilledRelay is emitted, so
         // we don't need to subtract it here. Moreover, the HubPoole expects bundleLpFees to be > 0.
       });
@@ -271,11 +286,11 @@ export function _buildPoolRebalanceRoot(
           return;
         }
         const l1TokenCounterpart = clients.hubPoolClient.getL1TokenForL2TokenAtBlock(
-          inputToken,
+          toAddressType(inputToken, originChainId),
           originChainId,
           mainnetBundleEndBlock
         );
-        updateRunningBalance(runningBalances, originChainId, l1TokenCounterpart, deposit.inputAmount);
+        updateRunningBalance(runningBalances, originChainId, l1TokenCounterpart.toEvmAddress(), deposit.inputAmount);
       });
     });
   });

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

@@ -2,7 +2,7 @@ import _ from "lodash";
 import assert from "assert";
 import { providers } from "ethers";
 import { DepositWithBlock, Fill, FillWithBlock } from "../../../interfaces";
-import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm } from "../../../utils";
+import { isSlowFill, isValidEvmAddress, isDefined, chainIsEvm, Address, toAddressType } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 import { SVMProvider } from "../../../arch/svm";
 
@@ -25,7 +25,7 @@ export function getRefundInformationFromFill(
   bundleEndBlockForMainnet: number
 ): {
   chainToSendRefundTo: number;
-  repaymentToken: string;
+  repaymentToken: Address;
 } {
   const chainToSendRefundTo = _getRepaymentChainId(relayData, hubPoolClient, bundleEndBlockForMainnet);
   if (chainToSendRefundTo === relayData.originChainId) {
@@ -49,6 +49,7 @@ export function getRefundInformationFromFill(
     chainToSendRefundTo,
     bundleEndBlockForMainnet
   );
+
   return {
     chainToSendRefundTo,
     repaymentToken,
@@ -125,7 +126,11 @@ export async function verifyFillRepayment(
           return undefined;
         }
       }
-      fill.relayer = destinationRelayer;
+      fill.relayer = toAddressType(destinationRelayer, fill.destinationChainId);
+      assert(
+        fill.relayer.isValidOn(fill.destinationChainId),
+        `Cannot re-assign fill to msg.sender: ${destinationRelayer}`
+      );
     } else {
       return undefined;
     }
@@ -196,9 +201,8 @@ function _repaymentAddressNeedsToBeOverwritten(fill: Fill): boolean {
     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);
+  // @dev If the repayment chain is EVM, the repayment address is valid if the address is 20 bytes.
+  // If the repayment chain is SVM, the repayment address is valid if the address is strictly greater than
+  // 20 bytes.
+  return !fill.relayer.isValidOn(fill.repaymentChainId);
 }

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

@@ -21,6 +21,12 @@ export function buildPoolRebalanceLeafTree(poolRebalanceLeaves: PoolRebalanceLea
   }
 
   const paramType = getParamType("MerkleLibTest", "verifyPoolRebalance", "rebalance");
-  const hashFn = (input: PoolRebalanceLeaf) => utils.keccak256(utils.defaultAbiCoder.encode([paramType], [input]));
+  const hashFn = (input: PoolRebalanceLeaf) => {
+    const ethersLeaf = {
+      ...input,
+      l1Tokens: input.l1Tokens.map((l1Token) => l1Token.toEvmAddress()),
+    };
+    return utils.keccak256(utils.defaultAbiCoder.encode([paramType], [ethersLeaf]));
+  };
   return new MerkleTree<PoolRebalanceLeaf>(poolRebalanceLeaves, hashFn);
 }

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

@@ -1,7 +1,7 @@
 import { MerkleTree } from "@across-protocol/contracts/dist/utils/MerkleTree";
 import { RunningBalances, PoolRebalanceLeaf, Clients, SpokePoolTargetBalance } from "../../../interfaces";
 import { SpokePoolClient } from "../../SpokePoolClient";
-import { BigNumber, bnZero, compareAddresses } from "../../../utils";
+import { BigNumber, bnZero, compareAddresses, EvmAddress } from "../../../utils";
 import { HubPoolClient } from "../../HubPoolClient";
 import { V3DepositWithBlock } from "./shims";
 import { AcrossConfigStoreClient } from "../../AcrossConfigStoreClient";
@@ -151,7 +151,7 @@ export function addLastRunningBalance(
       const { runningBalance } = hubPoolClient.getRunningBalanceBeforeBlockForChain(
         latestMainnetBlock,
         Number(repaymentChainId),
-        l1TokenAddress
+        EvmAddress.from(l1TokenAddress)
       );
       if (!runningBalance.eq(bnZero)) {
         updateRunningBalance(runningBalances, Number(repaymentChainId), l1TokenAddress, runningBalance);
@@ -172,7 +172,7 @@ export function updateRunningBalanceForDeposit(
     deposit.originChainId,
     mainnetBundleEndBlock
   );
-  updateRunningBalance(runningBalances, deposit.originChainId, l1TokenCounterpart, updateAmount);
+  updateRunningBalance(runningBalances, deposit.originChainId, l1TokenCounterpart.toEvmAddress(), updateAmount);
 }
 
 export function constructPoolRebalanceLeaves(
@@ -253,7 +253,7 @@ export function constructPoolRebalanceLeaves(
           runningBalances: leafRunningBalances,
           groupIndex: groupIndexForChainId++,
           leafId: leaves.length,
-          l1Tokens: l1TokensToIncludeInThisLeaf,
+          l1Tokens: l1TokensToIncludeInThisLeaf.map((l1TokenAddr: string) => EvmAddress.from(l1TokenAddr)),
         });
       }
     });

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

@@ -14,8 +14,8 @@ import {
   union,
   type,
 } from "superstruct";
-import { UNDEFINED_MESSAGE_HASH } from "../../../constants";
-import { BigNumber } from "../../../utils";
+import { CHAIN_IDs, UNDEFINED_MESSAGE_HASH } from "../../../constants";
+import { BigNumber, EvmAddress, RawAddress, SvmAddress, toAddressType } from "../../../utils";
 
 const PositiveIntegerStringSS = pattern(string(), /\d+/);
 const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{40}$/);
@@ -31,19 +31,31 @@ const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (
   }
 });
 
+// Accept any concrete implementation of `Address` (Evm, Svm, or Raw) but avoid using the
+// abstract `Address` class directly to keep TypeScript happy.
+const AddressInstanceSS = union([instance(EvmAddress), instance(SvmAddress), instance(RawAddress)]);
+
+const AddressType = coerce(AddressInstanceSS, string(), (value) => {
+  // Addresses are posted to arweave in their native format (base16 for EVM, base58 for SVM). The chainId for
+  // for the event data is not directly available, so infer it based on the shape of the address. RawAddress
+  // will be instantiated if the address format does not match the expected family.
+  const chainId = value.startsWith("0x") ? CHAIN_IDs.MAINNET : CHAIN_IDs.SOLANA;
+  return toAddressType(value, chainId);
+});
+
 const FillTypeSS = number();
 
 const V3RelayDataSS = {
-  inputToken: string(),
+  inputToken: AddressType,
   inputAmount: BigNumberType,
-  outputToken: string(),
+  outputToken: AddressType,
   outputAmount: BigNumberType,
   fillDeadline: number(),
-  exclusiveRelayer: string(),
+  exclusiveRelayer: AddressType,
   exclusivityDeadline: number(),
   originChainId: number(),
-  depositor: string(),
-  recipient: string(),
+  depositor: AddressType,
+  recipient: AddressType,
   depositId: BigNumberType,
   message: string(),
 };
@@ -67,7 +79,7 @@ const V3DepositSS = {
   quoteTimestamp: number(),
   relayerFeePct: optional(BigNumberType),
   speedUpSignature: optional(string()),
-  updatedRecipient: optional(string()),
+  updatedRecipient: optional(AddressType),
   updatedOutputAmount: optional(BigNumberType),
   updatedMessage: optional(string()),
 };
@@ -88,7 +100,7 @@ const V3DepositWithBlockLpFeeSS = object({
 const V3RelayExecutionEventInfoSS = object({
   updatedOutputAmount: BigNumberType,
   fillType: FillTypeSS,
-  updatedRecipient: string(),
+  updatedRecipient: AddressType,
   updatedMessage: optional(string()),
   updatedMessageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
 });
@@ -98,7 +110,7 @@ const V3FillSS = {
   message: optional(string()),
   messageHash: defaulted(string(), UNDEFINED_MESSAGE_HASH),
   destinationChainId: number(),
-  relayer: string(),
+  relayer: AddressType,
   repaymentChainId: number(),
   relayExecutionInfo: V3RelayExecutionEventInfoSS,
   quoteTimestamp: number(),