@across-protocol/sdk 4.2.14-alpha.1 → 4.2.15

package/src/interfaces/HubPool.ts

@@ -1,4 +1,4 @@
-import { Address, BigNumber, EvmAddress } from "../utils";
+import { BigNumber } from "../utils";
 import { SortableEvent } from "./Common";
 
 export interface PoolRebalanceLeaf {
@@ -8,7 +8,7 @@ export interface PoolRebalanceLeaf {
   netSendAmounts: BigNumber[];
   runningBalances: BigNumber[];
   leafId: number;
-  l1Tokens: EvmAddress[];
+  l1Tokens: string[];
 }
 
 export interface RelayerRefundLeaf {
@@ -16,8 +16,8 @@ export interface RelayerRefundLeaf {
   chainId: number;
   refundAmounts: BigNumber[];
   leafId: number;
-  l2TokenAddress: Address;
-  refundAddresses: Address[];
+  l2TokenAddress: string;
+  refundAddresses: string[];
 }
 
 export interface ProposedRootBundle extends SortableEvent {
@@ -27,7 +27,7 @@ export interface ProposedRootBundle extends SortableEvent {
   poolRebalanceRoot: string;
   relayerRefundRoot: string;
   slowRelayRoot: string;
-  proposer: EvmAddress;
+  proposer: string;
 }
 
 export type RealizedLpFee = {
@@ -55,7 +55,7 @@ export interface ExecutedRootBundle extends SortableEvent {
   netSendAmounts: BigNumber[];
   runningBalances: BigNumber[];
   leafId: number;
-  l1Tokens: EvmAddress[];
+  l1Tokens: string[];
   proof: string[];
 }
 
@@ -76,14 +76,8 @@ export interface RelayerRefundLeafWithGroup extends RelayerRefundLeaf {
   groupIndex: number;
 }
 
-export interface L1TokenInfo {
-  address: EvmAddress;
-  symbol: string;
-  decimals: number;
-}
-
-export interface TokenInfo {
-  address: Address;
+export interface L1Token {
+  address: string;
   symbol: string;
   decimals: number;
 }
@@ -93,30 +87,27 @@ export interface LpToken {
   liquidReserves: BigNumber;
 }
 
-// TODO: I think I don't change string -> Address in the Events. I change right after the event is read
 export interface CrossChainContractsSet extends SortableEvent {
   l2ChainId: number;
-  spokePool: Address;
+  spokePool: string;
 }
 
-// TODO: I think I don't change string -> Address in the Events. I change right after the event is read
 export interface DestinationTokenWithBlock extends SortableEvent {
-  l2Token: Address;
-  l1Token: EvmAddress;
+  l2Token: string;
+  l1Token: string;
 }
 
-// TODO: I think I don't change string -> Address in the Events. I change right after the event is read
 export interface SetPoolRebalanceRoot extends SortableEvent {
   destinationChainId: number;
-  l1Token: EvmAddress;
-  destinationToken: Address;
+  l1Token: string;
+  destinationToken: string;
 }
 
 export interface PendingRootBundle {
   poolRebalanceRoot: string;
   relayerRefundRoot: string;
   slowRelayRoot: string;
-  proposer: EvmAddress;
+  proposer: string;
   unclaimedPoolRebalanceLeafCount: number;
   challengePeriodEndTimestamp: number;
   bundleEvaluationBlockNumbers: number[];

package/src/interfaces/SpokePool.ts

@@ -1,20 +1,20 @@
 import { SortableEvent } from "./Common";
 import { SpokePoolClient } from "../clients";
-import { BigNumber, Address, EvmAddress } from "../utils";
+import { BigNumber } from "../utils";
 import { RelayerRefundLeaf } from "./HubPool";
 
 export interface RelayData {
   originChainId: number;
-  depositor: Address;
-  recipient: Address;
+  depositor: string;
+  recipient: string;
   depositId: BigNumber;
-  inputToken: Address;
+  inputToken: string;
   inputAmount: BigNumber;
-  outputToken: Address;
+  outputToken: string;
   outputAmount: BigNumber;
   message: string;
   fillDeadline: number;
-  exclusiveRelayer: Address;
+  exclusiveRelayer: string;
   exclusivityDeadline: number;
 }
 
@@ -23,7 +23,7 @@ export interface Deposit extends RelayData {
   destinationChainId: number;
   quoteTimestamp: number;
   speedUpSignature?: string;
-  updatedRecipient?: Address;
+  updatedRecipient?: string;
   updatedOutputAmount?: BigNumber;
   updatedMessage?: string;
   fromLiteChain: boolean;
@@ -51,7 +51,7 @@ export enum FillType {
 }
 
 export interface RelayExecutionEventInfo {
-  updatedRecipient: Address;
+  updatedRecipient: string;
   updatedOutputAmount: BigNumber;
   updatedMessage?: string;
   updatedMessageHash: string;
@@ -61,7 +61,7 @@ export interface RelayExecutionEventInfo {
 export interface Fill extends Omit<RelayData, "message"> {
   messageHash: string;
   destinationChainId: number;
-  relayer: Address;
+  relayer: string;
   repaymentChainId: number;
   relayExecutionInfo: RelayExecutionEventInfo;
 }
@@ -72,18 +72,18 @@ export interface FillWithTime extends Fill, SortableEvent {
 }
 
 export interface EnabledDepositRoute {
-  originToken: Address;
+  originToken: string;
   destinationChainId: number;
   enabled: boolean;
 }
 
 export interface EnabledDepositRouteWithBlock extends EnabledDepositRoute, SortableEvent {}
 export interface SpeedUp {
-  depositor: EvmAddress;
+  depositor: string;
   depositorSignature: string;
   depositId: BigNumber;
   originChainId: number;
-  updatedRecipient: Address;
+  updatedRecipient: string;
   updatedOutputAmount: BigNumber;
   updatedMessage: string;
 }
@@ -130,7 +130,19 @@ export interface TokensBridged extends SortableEvent {
   amountToReturn: BigNumber;
   chainId: number;
   leafId: number;
-  l2TokenAddress: Address;
+  l2TokenAddress: string;
+}
+
+export interface ClaimedRelayerRefundWithBlock extends SortableEvent {
+  l2TokenAddress: string;
+  refundAddress: string;
+  amount: BigNumber;
+  caller?: string;
+}
+
+export interface BridgedToHubPoolWithBlock extends SortableEvent {
+  amount: BigNumber;
+  mint: string;
 }
 
 export interface SpokePoolClientsByChain {

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -15,8 +15,6 @@ import {
   bnZero,
   chainIsOPStack,
   fixedPointAdjustment,
-  toAddressType,
-  Address,
 } from "../../utils";
 import assert from "assert";
 import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
@@ -74,7 +72,7 @@ export class QueryBase implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
+    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -124,7 +122,7 @@ export class QueryBase implements QueryInterface {
    */
   getUnsignedTxFromDeposit(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
+    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
   }
@@ -137,10 +135,10 @@ export class QueryBase implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
+    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
   ): Promise<BigNumber> {
     const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
-    const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
+    const voidSigner = new VoidSigner(relayer, this.provider);
     return voidSigner.estimateGas(unsignedTx);
   }
 
@@ -154,7 +152,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(unsignedTx.chainId), unsignedTx.chainId),
+    relayer = getDefaultSimulatedRelayerAddress(unsignedTx.chainId),
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;
@@ -163,7 +161,7 @@ export class QueryBase implements QueryInterface {
     const { opStackL2GasUnits, opStackL1DataFeeMultiplier = toBNWei("1") } = options || {};
     const { chainId } = await this.provider.getNetwork();
     assert(isOptimismL2Provider(this.provider), `Unexpected provider for chain ID ${chainId}.`);
-    const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
+    const voidSigner = new VoidSigner(relayer, this.provider);
     const populatedTransaction = await voidSigner.populateTransaction({
       ...unsignedTx,
       gasLimit: opStackL2GasUnits, // prevents additional gas estimation call
@@ -185,7 +183,7 @@ export class QueryBase implements QueryInterface {
    */
   async estimateGas(
     unsignedTx: PopulatedTransaction,
-    senderAddress: Address,
+    senderAddress: string,
     provider: providers.Provider | L2Provider<providers.Provider>,
     options: Partial<{
       gasPrice: BigNumberish;
@@ -206,7 +204,7 @@ export class QueryBase implements QueryInterface {
     } = options || {};
 
     const { chainId } = await provider.getNetwork();
-    const voidSigner = new VoidSigner(senderAddress.toEvmAddress(), provider);
+    const voidSigner = new VoidSigner(senderAddress, provider);
 
     // Estimate the Gas units required to submit this transaction.
     const queries = [

package/src/relayFeeCalculator/chain-queries/svmQuery.ts

@@ -25,7 +25,6 @@ import {
   getRelayDataHash,
   toAddressType,
   toBN,
-  Address,
 } from "../../utils";
 import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
 import { SymbolMappingType } from "./";
@@ -75,7 +74,7 @@ export class SvmQuery implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -83,8 +82,8 @@ export class SvmQuery implements QueryInterface {
       priorityFeeMultiplier: BigNumber;
     }> = {}
   ): Promise<TransactionCostEstimate> {
-    const relayer = _relayer ? _relayer.forceSvmAddress() : this.simulatedRelayerAddress;
-    const fillRelayTx = await this.getFillRelayTx(deposit, relayer);
+    const relayer = _relayer ? toAddressType(_relayer).forceSvmAddress() : this.simulatedRelayerAddress;
+    const fillRelayTx = await this.getFillRelayTx(deposit, relayer.toBase58());
 
     const [computeUnitsConsumed, _gasPriceEstimate] = await Promise.all([
       toBN(await this.computeUnitEstimator(fillRelayTx)),
@@ -117,7 +116,7 @@ export class SvmQuery implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
   ): Promise<BigNumber> {
     const fillRelayTx = await this.getFillRelayTx(deposit, _relayer);
     return toBN(await this.computeUnitEstimator(fillRelayTx));
@@ -131,29 +130,35 @@ export class SvmQuery implements QueryInterface {
    */
   async getFillRelayTx(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
+    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     repaymentChainId = deposit.destinationChainId,
-    repaymentAddress = toAddressType(
-      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-      deposit.destinationChainId
-    )
+    repaymentAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
   ) {
-    const toSvmAddress = (address: Address) => address.toV2Address();
+    const toSvmAddress = (address: string) => toAddressType(address).forceSvmAddress().toV2Address();
+    const relayer = _relayer ? toAddressType(_relayer).forceSvmAddress() : this.simulatedRelayerAddress;
     const state = await getStatePda(this.spokePoolAddress.toV2Address());
     const _relayDataHash = getRelayDataHash(deposit, deposit.destinationChainId);
     const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
     const delegate = await getFillRelayDelegatePda(
       relayDataHash,
       BigInt(repaymentChainId),
-      repaymentAddress.toV2Address(),
+      toSvmAddress(repaymentAddress),
       this.spokePoolAddress.toV2Address()
     );
-    const mint = deposit.outputToken;
+    const mint = toAddressType(deposit.outputToken).forceSvmAddress();
     const mintInfo = await fetchMint(this.provider, mint.toV2Address());
-    const recipientAta = await getAssociatedTokenAddress(deposit.recipient, mint, mintInfo.programAddress);
-    const relayerAta = await getAssociatedTokenAddress(relayer, mint, mintInfo.programAddress);
+    const recipientAta = await getAssociatedTokenAddress(
+      toAddressType(deposit.recipient).forceSvmAddress(),
+      mint,
+      mintInfo.programAddress
+    );
+    const relayerAta = await getAssociatedTokenAddress(
+      SvmAddress.from(relayer.toBase58()),
+      mint,
+      mintInfo.programAddress
+    );
     const fillStatus = await getFillStatusPda(this.spokePoolAddress.toV2Address(), deposit, deposit.destinationChainId);
-    const eventAuthority = await getEventAuthority(this.spokePoolAddress.toV2Address());
+    const eventAuthority = await getEventAuthority();
 
     const relayData: SvmSpokeClient.FillRelayInput["relayData"] = {
       depositor: toSvmAddress(deposit.depositor),

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -9,9 +9,12 @@ import { Deposit } from "../interfaces";
 import {
   BigNumber,
   BigNumberish,
+  ConvertDecimals,
   MAX_BIG_INT,
   TransactionCostEstimate,
   bnZero,
+  chainIsSvm,
+  compareAddressesSimple,
   fixedPointAdjustment,
   getTokenInfo,
   isDefined,
@@ -22,18 +25,13 @@ import {
   percent,
   toBN,
   toBNWei,
-  compareAddressesSimple,
-  ConvertDecimals,
-  chainIsSvm,
-  toAddressType,
-  Address,
 } from "../utils";
 
 // This needs to be implemented for every chain and passed into RelayFeeCalculator
 export interface QueryInterface {
   getGasCosts: (
     deposit: Omit<Deposit, "messageHash">,
-    relayer: Address,
+    relayer: string,
     options?: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -44,7 +42,7 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: Address) => Promise<BigNumber>;
+  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: string) => Promise<BigNumber>;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -256,10 +254,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = toAddressType(
-      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-      deposit.destinationChainId
-    ),
+    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -276,14 +271,14 @@ export class RelayFeeCalculator {
     // undefined address on destination.
     const destinationChainTokenDetails = Object.values(tokenMapping).find(
       (details) =>
-        compareAddressesSimple(details.addresses[originChainId], inputToken.toAddress()) &&
+        compareAddressesSimple(details.addresses[originChainId], inputToken) &&
         isDefined(details.addresses[destinationChainId])
     );
     const outputToken = isZeroAddress(deposit.outputToken)
       ? destinationChainTokenDetails!.addresses[destinationChainId]
-      : deposit.outputToken.toAddress();
+      : deposit.outputToken;
     const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
-    const inputTokenInfo = getTokenInfo(inputToken.toAddress(), originChainId, tokenMapping);
+    const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
     if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }
@@ -498,10 +493,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = toAddressType(
-      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-      deposit.destinationChainId
-    ),
+    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,
@@ -513,8 +505,8 @@ export class RelayFeeCalculator {
     const { inputToken, originChainId, outputToken, destinationChainId } = deposit;
     // We can perform a simple lookup with `getTokenInfo` here without resolving the exact token to resolve since we only need to
     // resolve the L1 token symbol and not the L2 token decimals.
-    const inputTokenInfo = getTokenInfo(inputToken.toAddress(), originChainId);
-    const outputTokenInfo = getTokenInfo(outputToken.toAddress(), destinationChainId);
+    const inputTokenInfo = getTokenInfo(inputToken, originChainId);
+    const outputTokenInfo = getTokenInfo(outputToken, destinationChainId);
     if (!isDefined(inputTokenInfo) || !isDefined(outputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }

package/src/utils/AddressUtils.ts

@@ -1,8 +1,7 @@
 import { providers, utils } from "ethers";
-import assert from "assert";
 import bs58 from "bs58";
 import { Address as V2Address } from "@solana/kit";
-import { BigNumber, chainIsEvm, isDefined } from "./";
+import { BigNumber, chainIsEvm } from "./";
 
 /**
  * Checks if a contract is deployed at the given address
@@ -76,39 +75,20 @@ export function isValidEvmAddress(address: string): boolean {
  * Creates the proper address type given the input chain ID corresponding to the address's origin network.
  * @param address Stringified address type to convert. Can be either hex encoded or base58 encoded.
  * @param chainId Network ID corresponding to the input address, used to determine which address type to output.
- * If no chain ID is specified, then fallback to inference via the structure of the address string.
  * @returns a child `Address` type most fitting for the chain ID.
  * @todo: Change this to `toAddress` once we remove the other `toAddress` function.
  */
-export function toAddressType(address: string, chainId?: number): Address | EvmAddress | SvmAddress {
-  const parseAddress = (address: string) => {
-    try {
-      if (utils.isHexString(address)) {
-        return EvmAddress.from(address);
-      }
-      return SvmAddress.from(address);
-    } catch (e) {
-      // If we hit this block, then the validation for one of the child address classes failed. We still may want to keep this address in our state, so
-      // return an unchecked address type.
-      assert(utils.isHexString(address));
-      assert(utils.hexDataLength(address) === 32);
-      return Address.__unsafeConstruct(utils.arrayify(address));
-    }
-  };
-  // If there is no network ID, then infer the address by the string format.
-  const addressType = parseAddress(address);
-  if (!isDefined(chainId)) {
-    return addressType;
-  }
-  // Wrap this in a try/catch in case we are trying to force an invalid EVM address to an EvmAddress type.
-  if (chainIsEvm(chainId)) {
-    try {
-      return addressType.forceEvmAddress();
-    } catch {
-      return addressType;
+export function toAddressType(address: string): Address | EvmAddress | SvmAddress {
+  try {
+    if (utils.isHexString(address)) {
+      return EvmAddress.from(address);
     }
+    return SvmAddress.from(address);
+  } catch (e) {
+    // If we hit this block, then the validation for one of the child address classes failed. We still may want to keep this address in our state, so
+    // return an unchecked address type.
+    return new Address(utils.arrayify(address));
   }
-  return addressType.forceSvmAddress();
 }
 
 // The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
@@ -133,24 +113,12 @@ export class Address {
     this.rawAddress = utils.zeroPad(_rawAddress, 32);
   }
 
-  static __unsafeConstruct(_rawAddress: Uint8Array): Address {
-    return new this(_rawAddress);
-  }
-
   // Converts the address into a bytes32 string. Note that the output bytes will be lowercase so that it matches ethers event data. This function will never
   // throw since address length validation was done at construction time.
   toBytes32(): string {
     return (this.bytes32Address ??= utils.hexZeroPad(utils.hexlify(this.rawAddress), 32).toLowerCase());
   }
 
-  // Returns last 20 bytes of Address as a hex string. Truncates if necessary. This function is useful for comparing some longer addresses(e.g. Solana) to Solidity events
-  // that contain truncated `address` type as one of the fields
-  truncateToBytes20(): string {
-    // Take the last 20 bytes
-    const bytes20 = this.rawAddress.slice(-20);
-    return toAddress(utils.hexlify(bytes20));
-  }
-
   // Converts the address (can be bytes32 or bytes20) to its base58 counterpart. This conversion will always succeed, even if the input address is not valid on Solana,
   // as this address may be needed to represent an EVM address on Solana.
   toBase58(): string {
@@ -192,7 +160,7 @@ export class Address {
   // Checks if this address can be coerced into a bytes20 evm address. Returns true if it is possible and false otherwise.
   isValidEvmAddress(): boolean {
     try {
-      this.toEvmAddress();
+      this.toAddress();
       return true;
     } catch {
       return false;
@@ -223,11 +191,6 @@ export class Address {
     return utils.stripZeros(this.rawAddress).length === 0;
   }
 
-  // Small utility to convert an Address to a Solana Kit branded type.
-  toV2Address(): V2Address<string> {
-    return this.toBase58() as V2Address<string>;
-  }
-
   // Forces `rawAddress` to become an SvmAddress type. This will only throw if `rawAddress.length > 32`.
   forceSvmAddress(): SvmAddress {
     return SvmAddress.from(this.toBase58());
@@ -257,14 +220,6 @@ export class Address {
       return 0;
     }
   }
-
-  static isEvmAddress(address: Address): boolean {
-    return address instanceof EvmAddress;
-  }
-
-  static isSvmAddress(address: Address): boolean {
-    return address instanceof SvmAddress;
-  }
 }
 
 // Subclass of address which strictly deals with 20-byte addresses. These addresses are guaranteed to be valid EVM addresses, so `toAddress` will always succeed.
@@ -314,6 +269,16 @@ export class SvmAddress extends Address {
     return this.toBase58();
   }
 
+  // Small utility to convert an SvmAddress to a Solana Kit branded type.
+  toV2Address(): V2Address<string> {
+    return this.toBase58() as V2Address<string>;
+  }
+
+  // Forces an SvmAddress to an EVM address string by truncating the leading 12 bytes.
+  override toEvmAddress(): string {
+    return toAddress(`0x${this.toBytes32().slice(-40)}`);
+  }
+
   // Constructs a new SvmAddress type.
   static from(address: string, encoding: "base58" | "base16" = "base58"): SvmAddress {
     if (encoding === "base58") {

package/src/utils/SpokeUtils.ts

@@ -1,9 +1,9 @@
 import { encodeAbiParameters, Hex, keccak256 } from "viem";
 import { fixedPointAdjustment as fixedPoint } from "./common";
-import { MAX_SAFE_DEPOSIT_ID, ZERO_BYTES } from "../constants";
-import { Fill, FillType, RelayData, SlowFillLeaf } from "../interfaces";
+import { MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
+import { Deposit, Fill, FillType, RelayData, SlowFillLeaf } from "../interfaces";
+import { toBytes32 } from "./AddressUtils";
 import { BigNumber } from "./BigNumberUtils";
-import { Address } from "./AddressUtils";
 import { isMessageEmpty } from "./DepositUtils";
 import { chainIsSvm } from "./NetworkUtils";
 import { svm } from "../arch";
@@ -16,6 +16,28 @@ export function getSlowFillLeafLpFeePct(leaf: SlowFillLeaf): BigNumber {
   const { relayData, updatedOutputAmount } = leaf;
   return relayData.inputAmount.sub(updatedOutputAmount).mul(fixedPoint).div(relayData.inputAmount);
 }
+/**
+ * Produce the RelayData for a Deposit.
+ * @param deposit Deposit instance.
+ * @returns The corresponding RelayData object.
+ */
+export function getDepositRelayData(deposit: Omit<Deposit, "messageHash">): RelayData {
+  return {
+    depositor: toBytes32(deposit.depositor),
+    recipient: toBytes32(deposit.recipient),
+    exclusiveRelayer: toBytes32(deposit.exclusiveRelayer),
+    inputToken: toBytes32(deposit.inputToken),
+    outputToken: toBytes32(deposit.outputToken),
+    inputAmount: deposit.inputAmount,
+    outputAmount: deposit.outputAmount,
+    originChainId: deposit.originChainId,
+    depositId: deposit.depositId,
+    fillDeadline: deposit.fillDeadline,
+    exclusivityDeadline: deposit.exclusivityDeadline,
+    message: deposit.message,
+  };
+}
+
 /**
  * Compute the RelayData hash for a fill. This can be used to determine the fill status.
  * @param relayData RelayData information that is used to complete a fill.
@@ -46,14 +68,14 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
 
   const _relayData = {
     ...relayData,
-    depositor: relayData.depositor.toBytes32(),
-    recipient: relayData.recipient.toBytes32(),
-    inputToken: relayData.inputToken.toBytes32(),
-    outputToken: relayData.outputToken.toBytes32(),
-    exclusiveRelayer: relayData.exclusiveRelayer.toBytes32(),
+    depositor: toBytes32(relayData.depositor),
+    recipient: toBytes32(relayData.recipient),
+    inputToken: toBytes32(relayData.inputToken),
+    outputToken: toBytes32(relayData.outputToken),
+    exclusiveRelayer: toBytes32(relayData.exclusiveRelayer),
   };
   if (chainIsSvm(destinationChainId)) {
-    return svm.getRelayDataHash(relayData, destinationChainId);
+    return svm.getRelayDataHash(_relayData, destinationChainId);
   }
   return keccak256(encodeAbiParameters(abi, [_relayData, destinationChainId]));
 }
@@ -73,8 +95,8 @@ export function isUnsafeDepositId(depositId: BigNumber): boolean {
 }
 
 // Determines if the input address (either a bytes32 or bytes20) is the zero address.
-export function isZeroAddress(address: Address): boolean {
-  return address.toBytes32() === ZERO_BYTES;
+export function isZeroAddress(address: string): boolean {
+  return address === ZERO_ADDRESS || address === ZERO_BYTES;
 }
 
 export function getMessageHash(message: string): string {