@across-protocol/sdk 4.2.16-alpha.4 → 4.2.16-alpha.6

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

@@ -14,8 +14,8 @@ import {
   union,
   type,
 } from "superstruct";
-import { UNDEFINED_MESSAGE_HASH } from "../../../constants";
-import { BigNumber, toAddressType, Address } 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,8 +31,16 @@ const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (
   }
 });
 
-const AddressType = coerce(instance(Address), string(), (value) => {
-  return toAddressType(value, 1); // @todo Don't merge without fixing this!
+// 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();

package/src/clients/HubPoolClient.ts

@@ -1086,11 +1086,12 @@ export class HubPoolClient extends BaseAbstractClient {
           );
         }
         executedRootBundle.runningBalances = runningBalances.slice(0, nTokens);
-        const executedRootBundleWithL1Tokens = {
+        this.executedRootBundles.push({
           ...executedRootBundle,
-          l1Tokens: l1Tokens.map((l1Token) => EvmAddress.from(String(l1Token))),
-        };
-        this.executedRootBundles.push(executedRootBundleWithL1Tokens);
+          l1Tokens: l1Tokens.map((token: string) => {
+            return EvmAddress.from(token, "base16");
+          }),
+        });
       }
     }
 

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -588,7 +588,10 @@ export abstract class SpokePoolClient extends BaseAbstractClient {
         .map((_event) => {
           const event = _event as SpeedUpWithBlock & { depositor: string; updatedRecipient: string };
 
-          if (!EvmAddress.validate(ethersUtils.arrayify(event.updatedRecipient))) {
+          const invalid = [event.depositor, event.updatedRecipient].some(
+            (addr) => !EvmAddress.validate(ethersUtils.arrayify(addr))
+          );
+          if (invalid) {
             return;
           }
 

package/src/clients/mocks/MockSvmCpiEventsClient.ts

@@ -1,4 +1,5 @@
 import assert from "assert";
+import { utils as ethersUtils } from "ethers";
 import { createHash } from "crypto";
 import { hexlify, arrayify, hexZeroPad } from "ethers/lib/utils";
 import { random } from "lodash";
@@ -17,9 +18,11 @@ import {
   SVMProvider,
   getRandomSvmAddress,
 } from "../../arch/svm";
-import { bnZero, bnOne, bs58, getCurrentTime, randomAddress, EvmAddress } from "../../utils";
+import { bnZero, bnOne, bs58, getCurrentTime, randomAddress, EvmAddress, SvmAddress } from "../../utils";
 import { FillType } from "../../interfaces";
 
+const randomBytes = (n: number) => ethersUtils.hexlify(ethersUtils.randomBytes(n));
+
 export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
   private events: Record<EventName, EventWithData[]> = {} as Record<EventName, EventWithData[]>;
   private slotHeight: bigint = BigInt(0);
@@ -75,9 +78,9 @@ export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
 
     destinationChainId ??= BigInt(random(1, 42161, false));
     const depositor = deposit.depositor ?? getRandomSvmAddress();
-    const recipient = deposit.recipient ?? EvmAddress.from(randomAddress()).toBase58();
+    const recipient = deposit.recipient ?? SvmAddress.from(randomBytes(32), "base16").toBase58();
     const inputToken = deposit.inputToken ?? getRandomSvmAddress();
-    const outputToken = deposit.outputToken ?? EvmAddress.from(randomAddress()).toBase58();
+    const outputToken = deposit.outputToken ?? SvmAddress.from(randomBytes(32), "base16").toBase58();
     inputAmount ??= BigInt(random(1, 1000, false));
     outputAmount ??= (inputAmount * BigInt(95)) / BigInt(100);
     const message = deposit.message ?? new Uint8Array(32);
@@ -158,9 +161,9 @@ export class MockSvmCpiEventsClient extends SvmCpiEventsClient {
     let { depositId, originChainId } = slowFillRequest;
     depositId ??= Uint8Array.from([random(1, 100_000, false)]);
     originChainId ??= BigInt(random(1, 42161, false));
-    const depositor = slowFillRequest.depositor ?? EvmAddress.from(randomAddress()).toBase58();
+    const depositor = slowFillRequest.depositor ?? SvmAddress.from(randomBytes(32)).toBase58();
     const recipient = slowFillRequest.recipient ?? getRandomSvmAddress();
-    const inputToken = slowFillRequest.inputToken ?? EvmAddress.from(randomAddress()).toBase58();
+    const inputToken = slowFillRequest.inputToken ?? SvmAddress.from(randomBytes(32)).toBase58();
     const outputToken = slowFillRequest.outputToken ?? getRandomSvmAddress();
 
     const args = {

package/src/interfaces/SpokePool.ts

@@ -18,14 +18,17 @@ export interface RelayData {
   exclusivityDeadline: number;
 }
 
-export interface Deposit extends RelayData {
+export interface SpeedUpCommon {
+  updatedRecipient: Address;
+  updatedOutputAmount: BigNumber;
+  updatedMessage: string;
+}
+
+export interface Deposit extends RelayData, Partial<SpeedUpCommon> {
   messageHash: string;
   destinationChainId: number;
   quoteTimestamp: number;
   speedUpSignature?: string;
-  updatedRecipient?: Address;
-  updatedOutputAmount?: BigNumber;
-  updatedMessage?: string;
   fromLiteChain: boolean;
   toLiteChain: boolean;
 }
@@ -78,14 +81,11 @@ export interface EnabledDepositRoute {
 }
 
 export interface EnabledDepositRouteWithBlock extends EnabledDepositRoute, SortableEvent {}
-export interface SpeedUp {
+export interface SpeedUp extends SpeedUpCommon {
   depositor: EvmAddress;
   depositorSignature: string;
   depositId: BigNumber;
   originChainId: number;
-  updatedRecipient: Address;
-  updatedOutputAmount: BigNumber;
-  updatedMessage: string;
 }
 
 export interface SpeedUpWithBlock extends SpeedUp, SortableEvent {}

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

@@ -1,14 +1,14 @@
 import { L2Provider } from "@eth-optimism/sdk/dist/interfaces/l2-provider";
 import { isL2Provider as isOptimismL2Provider } from "@eth-optimism/sdk/dist/l2-provider";
-
 import { PopulatedTransaction, providers, VoidSigner } from "ethers";
 import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs } from "../../constants";
-import { Deposit } from "../../interfaces";
+import { RelayData } from "../../interfaces";
 import { SpokePool, SpokePool__factory } from "../../typechain";
 import { populateV3Relay } from "../../arch/evm";
 import {
   BigNumberish,
+  EvmAddress,
   TransactionCostEstimate,
   BigNumber,
   toBNWei,
@@ -19,7 +19,7 @@ import {
   Address,
 } from "../../utils";
 import assert from "assert";
-import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
+import { Logger, QueryInterface, getDefaultRelayer } from "../relayFeeCalculator";
 import { Transport } from "viem";
 import { getGasPriceEstimate } from "../../gasPriceOracle";
 import { EvmProvider } from "../../arch/evm/types";
@@ -64,7 +64,7 @@ export class QueryBase implements QueryInterface {
 
   /**
    * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
-   * @param deposit V3 deposit instance.
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayerAddress Relayer address to simulate with.
    * @param options
    * @param options.gasPrice Optional gas price to use for the simulation.
@@ -73,8 +73,8 @@ export class QueryBase implements QueryInterface {
    * @returns The gas estimate for this function call (multiplied with the optional buffer).
    */
   async getGasCosts(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
+    relayData: RelayData & { destinationChainId: number },
+    relayer = toAddressType(getDefaultRelayer(relayData.destinationChainId), relayData.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -93,7 +93,12 @@ export class QueryBase implements QueryInterface {
       transport,
     } = options;
 
-    const tx = await this.getUnsignedTxFromDeposit(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = relayData;
+    assert(recipient.isEVM(), `getGasCosts: recipient not an EVM address (${recipient})`);
+    assert(outputToken.isEVM(), `getGasCosts: outputToken not an EVM address (${outputToken})`);
+    assert(exclusiveRelayer.isEVM(), `getGasCosts: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+
+    const tx = await this.getUnsignedTxFromDeposit({ ...relayData, recipient, outputToken, exclusiveRelayer }, relayer);
     const {
       nativeGasCost,
       tokenGasCost,
@@ -118,28 +123,40 @@ export class QueryBase implements QueryInterface {
 
   /**
    * @notice Return ethers.PopulatedTransaction for a fill based on input deposit args
-   * @param deposit
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayer Sender of PopulatedTransaction
    * @returns PopulatedTransaction
    */
   getUnsignedTxFromDeposit(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
+    relayData: Omit<RelayData, "recipient" | "outputToken"> & {
+      destinationChainId: number;
+      recipient: EvmAddress;
+      outputToken: EvmAddress;
+    },
+    relayer = toAddressType(getDefaultRelayer(relayData.destinationChainId), relayData.destinationChainId)
   ): Promise<PopulatedTransaction> {
-    return populateV3Relay(this.spokePool, deposit, relayer);
+    return populateV3Relay(this.spokePool, relayData, relayer);
   }
 
   /**
    * @notice Return the gas cost of a simulated transaction
-   * @param deposit
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayer Sender of PopulatedTransaction
    * @returns Estimated gas cost based on ethers.VoidSigner's gas estimation
    */
   async getNativeGasCost(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
+    relayData: RelayData & { destinationChainId: number },
+    relayer = toAddressType(getDefaultRelayer(relayData.destinationChainId), relayData.destinationChainId)
   ): Promise<BigNumber> {
-    const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = relayData;
+    assert(recipient.isEVM(), `getNativeGasCost: recipient not an EVM address (${recipient})`);
+    assert(outputToken.isEVM(), `getNativeGasCost: outputToken not an EVM address (${outputToken})`);
+    assert(exclusiveRelayer.isEVM(), `getNativeGasCost: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+
+    const unsignedTx = await this.getUnsignedTxFromDeposit(
+      { ...relayData, recipient, outputToken, exclusiveRelayer },
+      relayer
+    );
     const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
     return voidSigner.estimateGas(unsignedTx);
   }
@@ -154,7 +171,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(unsignedTx.chainId), CHAIN_IDs.MAINNET),
+    relayer = toAddressType(getDefaultRelayer(unsignedTx.chainId), CHAIN_IDs.MAINNET),
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;

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

@@ -7,7 +7,7 @@ import { CUSTOM_GAS_TOKENS } from "../../constants";
 import { chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
 import { QueryBase } from "./baseQuery";
 import { SVMProvider as svmProvider } from "../../arch/svm";
-import { DEFAULT_LOGGER, getDefaultSimulatedRelayerAddress, Logger } from "../relayFeeCalculator";
+import { DEFAULT_LOGGER, getDefaultRelayer, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
 import { SvmQuery } from "./svmQuery";
 
@@ -25,7 +25,7 @@ export class QueryBase__factory {
     provider: providers.Provider | svmProvider,
     symbolMapping = TOKEN_SYMBOLS_MAP,
     spokePoolAddress = getDeployedAddress("SpokePool", chainId),
-    simulatedRelayerAddress = getDefaultSimulatedRelayerAddress(chainId),
+    simulatedRelayerAddress = getDefaultRelayer(chainId),
     coingeckoProApiKey?: string,
     logger: Logger = DEFAULT_LOGGER,
     coingeckoBaseCurrency = "eth"

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

@@ -1,3 +1,4 @@
+import assert from "assert";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
@@ -17,7 +18,7 @@ import {
 import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs } from "../../constants";
 import { getGasPriceEstimate } from "../../gasPriceOracle";
-import { Deposit } from "../../interfaces";
+import { RelayData } from "../../interfaces";
 import {
   BigNumber,
   BigNumberish,
@@ -27,7 +28,7 @@ import {
   toAddressType,
   toBN,
 } from "../../utils";
-import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
+import { Logger, QueryInterface, getDefaultRelayer } from "../relayFeeCalculator";
 import { SymbolMappingType } from "./";
 
 /**
@@ -65,7 +66,7 @@ export class SvmQuery implements QueryInterface {
 
   /**
    * Retrieves the current gas costs of performing a fillRelay contract at the referenced SpokePool.
-   * @param deposit V3 deposit instance.
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param _relayer Relayer address to simulate with.
    * @param options
    * @param options.gasPrice Optional gas price to use for the simulation.
@@ -74,8 +75,8 @@ export class SvmQuery implements QueryInterface {
    * @returns The gas estimate for this function call (multiplied with the optional buffer).
    */
   async getGasCosts(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
+    relayData: RelayData & { destinationChainId: number },
+    relayer = toAddressType(getDefaultRelayer(relayData.destinationChainId), relayData.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -83,7 +84,12 @@ export class SvmQuery implements QueryInterface {
       priorityFeeMultiplier: BigNumber;
     }> = {}
   ): Promise<TransactionCostEstimate> {
-    const fillRelayTx = await this.getFillRelayTx(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = relayData;
+    assert(recipient.isSVM(), `getGasCosts: recipient not an SVM address (${recipient})`);
+    assert(outputToken.isSVM(), `getGasCosts: outputToken not an SVM address (${outputToken})`);
+    assert(exclusiveRelayer.isSVM(), `getGasCosts: exclusiveRelayer not an SVM address (${exclusiveRelayer})`);
+
+    const fillRelayTx = await this.getFillRelayTx({ ...relayData, recipient, outputToken, exclusiveRelayer }, relayer);
 
     const [computeUnitsConsumed, gasPriceEstimate] = await Promise.all([
       toBN(await this.computeUnitEstimator(fillRelayTx)),
@@ -114,39 +120,45 @@ export class SvmQuery implements QueryInterface {
    * @returns Estimated gas cost in compute units
    */
   async getNativeGasCost(
-    deposit: Omit<Deposit, "messageHash">,
-    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
+    deposit: RelayData & { destinationChainId: number },
+    _relayer = toAddressType(getDefaultRelayer(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<BigNumber> {
-    const fillRelayTx = await this.getFillRelayTx(deposit, _relayer);
+    const { recipient, outputToken, exclusiveRelayer } = deposit;
+    assert(recipient.isSVM(), `getNativeGasCost: recipient not an SVM address (${recipient})`);
+    assert(outputToken.isSVM(), `getNativeGasCost: outputToken not an SVM address (${outputToken})`);
+    assert(exclusiveRelayer.isSVM(), `getNativeGasCost: exclusiveRelayer not an SVM address (${exclusiveRelayer})`);
+
+    const fillRelayTx = await this.getFillRelayTx({ ...deposit, recipient, outputToken, exclusiveRelayer }, _relayer);
     return toBN(await this.computeUnitEstimator(fillRelayTx));
   }
 
   /**
    * @notice Return the fillRelay transaction for a given deposit
-   * @param deposit
+   * @param relayData RelayData instance, supplemented with destinationChainId
    * @param relayer SVM address of the relayer
    * @returns FillRelay transaction
    */
   async getFillRelayTx(
-    deposit: Omit<Deposit, "messageHash">,
-    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
-    repaymentChainId = deposit.destinationChainId,
-    repaymentAddress = toAddressType(
-      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-      deposit.destinationChainId
-    )
+    relayData: Omit<RelayData, "recipent" | "outputToken"> & {
+      destinationChainId: number;
+      recipient: SvmAddress;
+      outputToken: SvmAddress;
+    },
+    relayer = toAddressType(getDefaultRelayer(relayData.destinationChainId), relayData.destinationChainId),
+    repaymentChainId = relayData.destinationChainId,
+    repaymentAddress = toAddressType(getDefaultRelayer(relayData.destinationChainId), relayData.destinationChainId)
   ) {
-    const {
-      depositor,
-      recipient: _recipient,
-      inputToken,
-      outputToken: _outputToken,
-      exclusiveRelayer,
-      destinationChainId,
-    } = deposit;
+    const { depositor, recipient, inputToken, outputToken, exclusiveRelayer, destinationChainId } = relayData;
+
+    // tsc appeasement...should be unnecessary, but isn't. @todo Identify why.
+    assert(recipient.isSVM(), `getFillRelayTx: recipient not an SVM address (${recipient})`);
+    assert(
+      repaymentAddress.isValidOn(repaymentChainId),
+      `getFillRelayTx: repayment address ${repaymentAddress} not valid on chain ${repaymentChainId})`
+    );
 
     const program = toAddress(this.spokePool);
-    const _relayDataHash = getRelayDataHash(deposit, destinationChainId);
+    const _relayDataHash = getRelayDataHash(relayData, destinationChainId);
     const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
 
     const [state, delegate] = await Promise.all([
@@ -154,30 +166,29 @@ export class SvmQuery implements QueryInterface {
       getFillRelayDelegatePda(relayDataHash, BigInt(repaymentChainId), toAddress(repaymentAddress), program),
     ]);
 
-    const [recipient, outputToken] = [_recipient.forceSvmAddress(), _outputToken.forceSvmAddress()];
     const mint = toAddress(outputToken);
     const mintInfo = await fetchMint(this.provider, mint);
 
     const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
       getAssociatedTokenAddress(recipient, outputToken, mintInfo.programAddress),
       getAssociatedTokenAddress(SvmAddress.from(relayer.toBase58()), outputToken, mintInfo.programAddress),
-      getFillStatusPda(program, deposit, destinationChainId),
+      getFillStatusPda(program, relayData, destinationChainId),
       getEventAuthority(program),
     ]);
 
-    const relayData: SvmSpokeClient.FillRelayInput["relayData"] = {
+    const svmRelayData: SvmSpokeClient.FillRelayInput["relayData"] = {
       depositor: toAddress(depositor),
       recipient: toAddress(recipient),
       exclusiveRelayer: toAddress(exclusiveRelayer),
       inputToken: toAddress(inputToken),
       outputToken: mint,
-      inputAmount: deposit.inputAmount.toBigInt(),
-      outputAmount: deposit.outputAmount.toBigInt(),
-      originChainId: deposit.originChainId,
-      depositId: new Uint8Array(intToU8Array32(deposit.depositId.toNumber())),
-      fillDeadline: deposit.fillDeadline,
-      exclusivityDeadline: deposit.exclusivityDeadline,
-      message: new Uint8Array(Buffer.from(deposit.message, "hex")),
+      inputAmount: relayData.inputAmount.toBigInt(),
+      outputAmount: relayData.outputAmount.toBigInt(),
+      originChainId: relayData.originChainId,
+      depositId: new Uint8Array(intToU8Array32(relayData.depositId.toNumber())),
+      fillDeadline: relayData.fillDeadline,
+      exclusivityDeadline: relayData.exclusivityDeadline,
+      message: new Uint8Array(Buffer.from(relayData.message, "hex")),
     };
 
     const simulatedSigner = SolanaVoidSigner(relayer.toBase58());
@@ -195,7 +206,7 @@ export class SvmQuery implements QueryInterface {
       eventAuthority,
       program,
       relayHash: relayDataHash,
-      relayData,
+      relayData: svmRelayData,
       repaymentChainId: BigInt(repaymentChainId),
       repaymentAddress: toAddress(repaymentAddress),
     };

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -114,7 +114,7 @@ export const DEFAULT_LOGGER: Logger = {
   error: (...args) => console.error(args),
 };
 
-export function getDefaultSimulatedRelayerAddress(chainId?: number) {
+export function getDefaultRelayer(chainId?: number) {
   return isDefined(chainId) && chainIsSvm(chainId)
     ? DEFAULT_SIMULATED_RELAYER_ADDRESS_SVM
     : DEFAULT_SIMULATED_RELAYER_ADDRESS;
@@ -256,10 +256,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = toAddressType(
-      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-      deposit.destinationChainId
-    ),
+    relayerAddress = toAddressType(getDefaultRelayer(deposit.destinationChainId), deposit.destinationChainId),
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -498,10 +495,7 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = toAddressType(
-      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
-      deposit.destinationChainId
-    ),
+    relayerAddress = toAddressType(getDefaultRelayer(deposit.destinationChainId), deposit.destinationChainId),
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,

package/src/utils/AddressUtils.ts

@@ -81,15 +81,15 @@ export function isValidEvmAddress(address: string): boolean {
 export function toAddressType(address: string, chainId: number): Address {
   const rawAddress = address.startsWith("0x") ? utils.arrayify(address) : bs58.decode(address);
 
-  const isEvm = chainIsEvm(chainId);
-  if (isEvm && EvmAddress.validate(rawAddress)) return new EvmAddress(rawAddress);
-  if (!isEvm && SvmAddress.validate(rawAddress)) return new SvmAddress(rawAddress);
-  return new Address(rawAddress);
+  if (chainIsEvm(chainId) && EvmAddress.validate(rawAddress)) return new EvmAddress(rawAddress);
+  else if (chainIsSvm(chainId) && SvmAddress.validate(rawAddress)) return new SvmAddress(rawAddress);
+
+  return new RawAddress(rawAddress);
 }
 
 // The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
 // which for this class, is a bytes32 hex string.
-export class Address {
+export abstract class Address {
   readonly rawAddress: Uint8Array;
 
   // Keep all address types in cache so that we may lazily evaluate them when necessary.
@@ -109,10 +109,6 @@ 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 {
@@ -167,11 +163,6 @@ export class Address {
     return false;
   }
 
-  // Checks if the object is an address by looking at whether it has an Address constructor.
-  static isAddress(obj: unknown): boolean {
-    return obj instanceof this;
-  }
-
   // Converts the input address to a 32-byte hex data string.
   toString(): string {
     return this.toNative();
@@ -193,6 +184,7 @@ export class Address {
   }
 
   // Compares Addresses by first converting them to BigNumbers.
+  // note: Intended for use when sorting like addresses.
   compare(otherAddress: Address): 1 | -1 | 0 {
     // Convert address strings to BigNumbers and then sort numerical value of the BigNumber, which sorts the addresses
     // effectively by their hex value.
@@ -207,20 +199,18 @@ export class Address {
     }
   }
 
-  static isEvmAddress(address: Address): boolean {
-    return address instanceof EvmAddress;
+  isEVM(): this is EvmAddress {
+    return false;
   }
 
-  static isSvmAddress(address: Address): boolean {
-    return address instanceof SvmAddress;
+  isSVM(): this is SvmAddress {
+    return false;
   }
 }
 
 // Subclass of address which strictly deals with 20-byte addresses. These addresses are guaranteed to be valid EVM addresses, so `toAddress` will always succeed.
 export class EvmAddress extends Address {
-  // @dev This property is required for Typescript typechecker to know to distinguish between `Address`, `SvmAddress` and `EvmAddress`.
-  // Otherwise it lets any of these to use in place where other is expected.
-  private readonly _brandEvmAddress!: void;
+  private readonly _type = "evm";
 
   // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
   constructor(rawAddress: Uint8Array) {
@@ -229,8 +219,7 @@ export class EvmAddress extends Address {
     }
 
     super(rawAddress);
-    // @dev required for TS to compile with `noUnusedLocals` rule
-    this._brandEvmAddress;
+    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
@@ -239,34 +228,24 @@ export class EvmAddress extends Address {
     );
   }
 
+  override isEVM(): this is EvmAddress {
+    return true;
+  }
+
   // Override `toAddress` to return the 20-byte representation address.
   override toNative(): string {
     return this.toEvmAddress();
   }
 
   // Constructs a new EvmAddress type.
-  static from(address: string, encoding: "base16" | "base58" = "base16"): EvmAddress {
-    if (encoding === "base16") {
-      return new this(utils.arrayify(address));
-    }
-
-    const decodedAddress = bs58.decode(address);
-    const padding = decodedAddress.subarray(0, 12);
-    const evmAddress = decodedAddress.subarray(12);
-
-    if (padding.length !== 12 || utils.stripZeros(padding).length !== 0 || evmAddress.length !== 20) {
-      throw new Error(`Not a valid base58-encoded EVM address: ${address}`);
-    }
-
-    return new this(evmAddress);
+  static from(address: string, encoding: "base58" | "base16" = "base16"): EvmAddress {
+    return encoding === "base16" ? new this(utils.arrayify(address)) : new this(bs58.decode(address));
   }
 }
 
 // Subclass of address which strictly deals SVM addresses. These addresses are guaranteed to be valid SVM addresses, so `toBase58` will always produce a valid Solana address.
 export class SvmAddress extends Address {
-  // @dev This property is required for Typescript typechecker to know to distinguish between `Address`, `SvmAddress` and `EvmAddress`.
-  // Otherwise it lets any of these to use in place where other is expected.
-  private readonly _brandSvmAddress!: void;
+  private readonly _type = "svm";
 
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
   constructor(rawAddress: Uint8Array) {
@@ -275,12 +254,21 @@ export class SvmAddress extends Address {
     }
 
     super(rawAddress);
-    // @dev required for TS to compile with `noUnusedLocals` rule
-    this._brandSvmAddress;
+    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
-    return rawAddress.length === 32;
+    // Deliberately invalidate SVM addresses w/ the upper 12 bytes zeroed. These addresses are technically valid
+    // but highly improbable and are much more likely to be a mistaken interpretation of an EVM address. Err on
+    // the side of caution for the time being. Exception: Permit the zero address (i.e. for exclusiverRelayer).
+    return (
+      rawAddress.length === 32 &&
+      (!rawAddress.slice(0, 12).every((field) => field === 0) || rawAddress.every((field) => field === 0))
+    );
+  }
+
+  override isSVM(): this is SvmAddress {
+    return true;
   }
 
   // Override the toAddress function for SVM addresses only since while they will never have a defined 20-byte representation. The base58 encoded addresses are also the encodings
@@ -291,15 +279,15 @@ export class SvmAddress extends Address {
 
   // Constructs a new SvmAddress type.
   static from(address: string, encoding: "base58" | "base16" = "base58"): SvmAddress {
-    if (encoding === "base58") {
-      return new this(bs58.decode(address));
-    }
+    return encoding === "base58" ? new this(bs58.decode(address)) : new this(utils.arrayify(address));
+  }
+}
 
-    const decodedAddress = utils.arrayify(address);
-    if (decodedAddress.length !== 32) {
-      throw new Error(`Not a valid base16-encoded SVM address: ${address}`);
-    }
+export class RawAddress extends Address {
+  private readonly _type = "raw";
 
-    return new this(decodedAddress);
+  constructor(rawAddress: Uint8Array) {
+    super(rawAddress);
+    this._type; // tsc noUnusedLocals appeasement.
   }
 }