@across-protocol/sdk 4.2.15 → 4.2.16-alpha.2

package/src/interfaces/SpokePool.ts

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

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

@@ -15,11 +15,13 @@ import {
   bnZero,
   chainIsOPStack,
   fixedPointAdjustment,
+  toAddressType,
+  Address,
 } from "../../utils";
 import assert from "assert";
 import { Logger, QueryInterface, getDefaultSimulatedRelayerAddress } from "../relayFeeCalculator";
 import { Transport } from "viem";
-import { getGasPriceEstimate, EvmGasPriceEstimate } from "../../gasPriceOracle";
+import { getGasPriceEstimate } from "../../gasPriceOracle";
 import { EvmProvider } from "../../arch/evm/types";
 
 export type SymbolMappingType = Record<
@@ -72,7 +74,7 @@ export class QueryBase implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -122,7 +124,7 @@ export class QueryBase implements QueryInterface {
    */
   getUnsignedTxFromDeposit(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
   }
@@ -135,10 +137,10 @@ export class QueryBase implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<BigNumber> {
     const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
-    const voidSigner = new VoidSigner(relayer, this.provider);
+    const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
     return voidSigner.estimateGas(unsignedTx);
   }
 
@@ -152,7 +154,7 @@ export class QueryBase implements QueryInterface {
    */
   async getOpStackL1DataFee(
     unsignedTx: PopulatedTransaction,
-    relayer = getDefaultSimulatedRelayerAddress(unsignedTx.chainId),
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(unsignedTx.chainId), CHAIN_IDs.MAINNET),
     options: Partial<{
       opStackL2GasUnits: BigNumberish;
       opStackL1DataFeeMultiplier: BigNumber;
@@ -161,7 +163,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, this.provider);
+    const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
     const populatedTransaction = await voidSigner.populateTransaction({
       ...unsignedTx,
       gasLimit: opStackL2GasUnits, // prevents additional gas estimation call
@@ -183,7 +185,7 @@ export class QueryBase implements QueryInterface {
    */
   async estimateGas(
     unsignedTx: PopulatedTransaction,
-    senderAddress: string,
+    senderAddress: Address,
     provider: providers.Provider | L2Provider<providers.Provider>,
     options: Partial<{
       gasPrice: BigNumberish;
@@ -204,7 +206,7 @@ export class QueryBase implements QueryInterface {
     } = options || {};
 
     const { chainId } = await provider.getNetwork();
-    const voidSigner = new VoidSigner(senderAddress, provider);
+    const voidSigner = new VoidSigner(senderAddress.toEvmAddress(), provider);
 
     // Estimate the Gas units required to submit this transaction.
     const queries = [
@@ -213,9 +215,9 @@ export class QueryBase implements QueryInterface {
         ? Promise.resolve({ maxFeePerGas: _gasPrice })
         : getGasPriceEstimate(provider, { chainId, baseFeeMultiplier, priorityFeeMultiplier, transport, unsignedTx }),
     ] as const;
-    const [nativeGasCost, _gasPriceEstimate] = await Promise.all(queries);
-    // It should be safe to cast to an EvmGasPriceEstimate here since QueryBase is only used for EVM chains.
-    const gasPrice = (_gasPriceEstimate as EvmGasPriceEstimate).maxFeePerGas;
+    const [nativeGasCost, gasPriceEstimate] = await Promise.all(queries);
+
+    const gasPrice = gasPriceEstimate.maxFeePerGas;
     assert(nativeGasCost.gt(bnZero), "Gas cost should not be 0");
     let tokenGasCost: BigNumber;
 

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

@@ -12,10 +12,11 @@ import {
   getFillRelayDelegatePda,
   getFillStatusPda,
   getStatePda,
+  toAddress,
 } from "../../arch/svm";
 import { Coingecko } from "../../coingecko";
 import { CHAIN_IDs } from "../../constants";
-import { SvmGasPriceEstimate, getGasPriceEstimate } from "../../gasPriceOracle";
+import { getGasPriceEstimate } from "../../gasPriceOracle";
 import { Deposit } from "../../interfaces";
 import {
   BigNumber,
@@ -40,7 +41,7 @@ export class SvmQuery implements QueryInterface {
    * Instantiates a SvmQuery instance
    * @param provider A valid solana/kit rpc client.
    * @param symbolMapping A mapping to valid ERC20 tokens and their respective characteristics
-   * @param spokePoolAddress The valid address of the Spoke Pool deployment
+   * @param spokePool The valid address of the Spoke Pool deployment
    * @param simulatedRelayerAddress The address that these queries will reference as the sender. Note: This address must be approved for USDC
    * @param logger A logging utility to report logs
    * @param coingeckoProApiKey An optional CoinGecko API key that links to a PRO account
@@ -50,7 +51,7 @@ export class SvmQuery implements QueryInterface {
   constructor(
     readonly provider: SVMProvider,
     readonly symbolMapping: SymbolMappingType,
-    readonly spokePoolAddress: SvmAddress,
+    readonly spokePool: SvmAddress,
     readonly simulatedRelayerAddress: SvmAddress,
     readonly logger: Logger,
     readonly coingeckoProApiKey?: string,
@@ -74,7 +75,7 @@ export class SvmQuery implements QueryInterface {
    */
   async getGasCosts(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
     options: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -82,10 +83,9 @@ export class SvmQuery implements QueryInterface {
       priorityFeeMultiplier: BigNumber;
     }> = {}
   ): Promise<TransactionCostEstimate> {
-    const relayer = _relayer ? toAddressType(_relayer).forceSvmAddress() : this.simulatedRelayerAddress;
-    const fillRelayTx = await this.getFillRelayTx(deposit, relayer.toBase58());
+    const fillRelayTx = await this.getFillRelayTx(deposit, relayer);
 
-    const [computeUnitsConsumed, _gasPriceEstimate] = await Promise.all([
+    const [computeUnitsConsumed, gasPriceEstimate] = await Promise.all([
       toBN(await this.computeUnitEstimator(fillRelayTx)),
       getGasPriceEstimate(this.provider, {
         unsignedTx: fillRelayTx,
@@ -96,7 +96,6 @@ export class SvmQuery implements QueryInterface {
 
     // We can cast the gas price estimate to an SvmGasPriceEstimate here since the oracle should always
     // query the Solana adapter.
-    const gasPriceEstimate = _gasPriceEstimate as SvmGasPriceEstimate;
     const gasPrice = gasPriceEstimate.baseFee.add(
       gasPriceEstimate.microLamportsPerComputeUnit.mul(computeUnitsConsumed).div(toBN(1_000_000)) // 1_000_000 microLamports/lamport.
     );
@@ -116,7 +115,7 @@ export class SvmQuery implements QueryInterface {
    */
   async getNativeGasCost(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    _relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<BigNumber> {
     const fillRelayTx = await this.getFillRelayTx(deposit, _relayer);
     return toBN(await this.computeUnitEstimator(fillRelayTx));
@@ -130,42 +129,40 @@ export class SvmQuery implements QueryInterface {
    */
   async getFillRelayTx(
     deposit: Omit<Deposit, "messageHash">,
-    _relayer = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
     repaymentChainId = deposit.destinationChainId,
-    repaymentAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId)
+    repaymentAddress = toAddressType(
+      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+      deposit.destinationChainId
+    )
   ) {
-    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 { depositor, recipient, inputToken, outputToken, exclusiveRelayer, destinationChainId } = deposit;
+
+    const program = toAddress(this.spokePool);
+    const _relayDataHash = getRelayDataHash(deposit, destinationChainId);
     const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
-    const delegate = await getFillRelayDelegatePda(
-      relayDataHash,
-      BigInt(repaymentChainId),
-      toSvmAddress(repaymentAddress),
-      this.spokePoolAddress.toV2Address()
-    );
-    const mint = toAddressType(deposit.outputToken).forceSvmAddress();
-    const mintInfo = await fetchMint(this.provider, mint.toV2Address());
-    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();
+
+    const [state, delegate] = await Promise.all([
+      getStatePda(program),
+      getFillRelayDelegatePda(relayDataHash, BigInt(repaymentChainId), toAddress(repaymentAddress), program),
+    ]);
+
+    const mint = toAddress(outputToken);
+    const mintInfo = await fetchMint(this.provider, mint);
+
+    const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
+      getAssociatedTokenAddress(deposit.recipient, outputToken, mintInfo.programAddress),
+      getAssociatedTokenAddress(SvmAddress.from(relayer.toBase58()), outputToken, mintInfo.programAddress),
+      getFillStatusPda(program, deposit, destinationChainId),
+      getEventAuthority(program),
+    ]);
 
     const relayData: SvmSpokeClient.FillRelayInput["relayData"] = {
-      depositor: toSvmAddress(deposit.depositor),
-      recipient: toSvmAddress(deposit.recipient),
-      exclusiveRelayer: toSvmAddress(deposit.exclusiveRelayer),
-      inputToken: toSvmAddress(deposit.inputToken),
-      outputToken: mint.toV2Address(),
+      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,
@@ -180,19 +177,19 @@ export class SvmQuery implements QueryInterface {
       signer: simulatedSigner,
       state,
       delegate,
-      mint: mint.toV2Address(),
+      mint,
       relayerTokenAccount: relayerAta,
       recipientTokenAccount: recipientAta,
       fillStatus,
       tokenProgram: mintInfo.programAddress,
       associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
       systemProgram: SYSTEM_PROGRAM_ADDRESS,
-      eventAuthority: eventAuthority,
-      program: this.spokePoolAddress.toV2Address(),
+      eventAuthority,
+      program,
       relayHash: relayDataHash,
       relayData,
       repaymentChainId: BigInt(repaymentChainId),
-      repaymentAddress: toSvmAddress(repaymentAddress),
+      repaymentAddress: toAddress(repaymentAddress),
     };
     // Pass createRecipientAtaIfNeeded =true to the createFillInstruction function to create the recipient token account
     // if it doesn't exist.

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -9,12 +9,9 @@ import { Deposit } from "../interfaces";
 import {
   BigNumber,
   BigNumberish,
-  ConvertDecimals,
   MAX_BIG_INT,
   TransactionCostEstimate,
   bnZero,
-  chainIsSvm,
-  compareAddressesSimple,
   fixedPointAdjustment,
   getTokenInfo,
   isDefined,
@@ -25,13 +22,18 @@ 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: string,
+    relayer: Address,
     options?: Partial<{
       gasPrice: BigNumberish;
       gasUnits: BigNumberish;
@@ -42,7 +44,7 @@ export interface QueryInterface {
     }>
   ) => Promise<TransactionCostEstimate>;
   getTokenPrice: (tokenSymbol: string) => Promise<number>;
-  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: string) => Promise<BigNumber>;
+  getNativeGasCost: (deposit: Omit<Deposit, "messageHash">, relayer: Address) => Promise<BigNumber>;
 }
 
 export const expectedCapitalCostsKeys = ["lowerBound", "upperBound", "cutoff", "decimals"];
@@ -254,7 +256,10 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayerAddress = toAddressType(
+      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+      deposit.destinationChainId
+    ),
     _tokenPrice?: number,
     tokenMapping = TOKEN_SYMBOLS_MAP,
     gasPrice?: BigNumberish,
@@ -271,14 +276,14 @@ export class RelayFeeCalculator {
     // undefined address on destination.
     const destinationChainTokenDetails = Object.values(tokenMapping).find(
       (details) =>
-        compareAddressesSimple(details.addresses[originChainId], inputToken) &&
+        compareAddressesSimple(details.addresses[originChainId], inputToken.toNative()) &&
         isDefined(details.addresses[destinationChainId])
     );
     const outputToken = isZeroAddress(deposit.outputToken)
       ? destinationChainTokenDetails!.addresses[destinationChainId]
-      : deposit.outputToken;
+      : deposit.outputToken.toNative();
     const outputTokenInfo = getTokenInfo(outputToken, destinationChainId, tokenMapping);
-    const inputTokenInfo = getTokenInfo(inputToken, originChainId, tokenMapping);
+    const inputTokenInfo = getTokenInfo(inputToken.toNative(), originChainId, tokenMapping);
     if (!isDefined(outputTokenInfo) || !isDefined(inputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }
@@ -493,7 +498,10 @@ export class RelayFeeCalculator {
     deposit: Deposit,
     outputAmount?: BigNumberish,
     simulateZeroFill = false,
-    relayerAddress = getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+    relayerAddress = toAddressType(
+      getDefaultSimulatedRelayerAddress(deposit.destinationChainId),
+      deposit.destinationChainId
+    ),
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
     gasUnits?: BigNumberish,
@@ -505,8 +513,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, originChainId);
-    const outputTokenInfo = getTokenInfo(outputToken, destinationChainId);
+    const inputTokenInfo = getTokenInfo(inputToken.toNative(), originChainId);
+    const outputTokenInfo = getTokenInfo(outputToken.toNative(), destinationChainId);
     if (!isDefined(inputTokenInfo) || !isDefined(outputTokenInfo)) {
       throw new Error(`Could not find token information for ${inputToken} or ${outputToken}`);
     }

package/src/utils/AddressUtils.ts

@@ -1,7 +1,6 @@
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
-import { Address as V2Address } from "@solana/kit";
-import { BigNumber, chainIsEvm } from "./";
+import { BigNumber, chainIsEvm, chainIsSvm } from "./";
 
 /**
  * Checks if a contract is deployed at the given address
@@ -48,8 +47,9 @@ export function toBytes32(address: string): string {
   return utils.hexZeroPad(address, 32).toLowerCase();
 }
 
-// Checks if the input string can be coerced into a bytes20 evm address. Returns true if it is possible, and false otherwise.
-export function toAddress(hexString: string): string {
+// Constructs a 20-byte checksummed EVM address from a hex string input.
+// Throws an error if the underlying address length is longer than 20 bytes or incorrectly checksummed.
+export function toEvmAddress(hexString: string): string {
   // rawAddress is the address which is not properly checksummed.
   const rawAddress = utils.hexZeroPad(utils.hexStripZeros(hexString), 20);
   return utils.getAddress(rawAddress);
@@ -74,21 +74,17 @@ 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.
+ * @param chainId Chain ID for the intended use of the address.
  * @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): 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));
-  }
+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);
 }
 
 // The Address class can contain any address type. It is up to the subclasses to determine how to format the address's internal representation,
@@ -113,12 +109,24 @@ 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 toEvmAddress(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 {
@@ -126,7 +134,7 @@ export class Address {
   }
 
   // Converts the address to a BigNumber type.
-  toBigNumber(): BigNumber {
+  private toBigNumber(): BigNumber {
     return (this.bnAddress ??= BigNumber.from(this.toBytes32()));
   }
 
@@ -143,37 +151,20 @@ export class Address {
 
   // Converts the address to a hex string. This method should be overriden by subclasses to obtain more meaningful
   // address representations for the target chain ID.
-  toAddress(): string {
+  toNative(): string {
     return this.toBytes32();
   }
 
-  // Converts the address to a Buffer type.
-  toBuffer(): Buffer {
-    return Buffer.from(this.rawAddress);
-  }
-
   // Implements `Hexable` for `Address`. Needed for encoding purposes. This class is treated by default as a bytes32 primitive type, but can change for subclasses.
   toHexString(): string {
     return this.toBytes32();
   }
 
-  // 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.toAddress();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
   // Checks if the address is valid on the given chain ID.
   isValidOn(chainId: number): boolean {
-    if (chainIsEvm(chainId)) {
-      return this.isValidEvmAddress();
-    }
-    // Assume the address is always valid on Solana.
-    return true;
+    if (chainIsEvm(chainId)) return EvmAddress.validate(this.rawAddress);
+    if (chainIsSvm(chainId)) return SvmAddress.validate(this.rawAddress);
+    return false;
   }
 
   // Checks if the object is an address by looking at whether it has an Address constructor.
@@ -183,7 +174,7 @@ export class Address {
 
   // Converts the input address to a 32-byte hex data string.
   toString(): string {
-    return this.toHexString();
+    return this.toNative();
   }
 
   // Checks if the address is the zero address.
@@ -196,11 +187,6 @@ export class Address {
     return SvmAddress.from(this.toBase58());
   }
 
-  // Forces `rawAddress` to become an EvmAddress type. This will throw if `rawAddress.length > 20`.
-  forceEvmAddress(): EvmAddress {
-    return EvmAddress.from(this.toEvmAddress());
-  }
-
   // Checks if the other address is equivalent to this address.
   eq(other: Address): boolean {
     return this.toString() === other.toString();
@@ -220,21 +206,35 @@ 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.
 export class EvmAddress extends Address {
   // On construction, validate that the address can indeed be coerced into an EVM address. Throw immediately if it cannot.
   constructor(rawAddress: Uint8Array) {
-    super(rawAddress);
-    const hexString = utils.hexlify(rawAddress);
-    if (!this.isValidEvmAddress()) {
-      throw new Error(`${hexString} is not a valid EVM address`);
+    if (!EvmAddress.validate(rawAddress)) {
+      throw new Error(`${utils.hexlify(rawAddress)} is not a valid EVM address`);
     }
+
+    super(rawAddress);
+  }
+
+  static validate(rawAddress: Uint8Array): boolean {
+    return (
+      rawAddress.length == 20 || (rawAddress.length === 32 && rawAddress.slice(0, 12).every((field) => field === 0))
+    );
   }
 
   // Override `toAddress` to return the 20-byte representation address.
-  override toAddress(): string {
+  override toNative(): string {
     return this.toEvmAddress();
   }
 
@@ -260,25 +260,23 @@ export class EvmAddress extends Address {
 export class SvmAddress extends Address {
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
   constructor(rawAddress: Uint8Array) {
+    if (!SvmAddress.validate(rawAddress)) {
+      throw new Error(`${utils.hexlify(rawAddress)} is not a valid SVM address`); // @todo: Display as Base58?
+    }
+
     super(rawAddress);
   }
 
+  static validate(rawAddress: Uint8Array): boolean {
+    return rawAddress.length === 32;
+  }
+
   // 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
   // used in TOKEN_SYMBOLS_MAP.
-  override toAddress(): string {
+  override toNative(): string {
     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/EventUtils.ts

@@ -3,7 +3,7 @@ import { Result } from "@ethersproject/abi";
 import { Contract, Event, EventFilter } from "ethers";
 import { Log, SortableEvent } from "../interfaces";
 import { delay } from "./common";
-import { isDefined, toBN, BigNumberish, toAddress } from "./";
+import { isDefined, toBN, BigNumberish, toEvmAddress } from "./";
 
 const maxRetries = 3;
 const retrySleepTime = 10;
@@ -88,7 +88,7 @@ export function spreadEvent(args: Result | Record<string, unknown>): { [key: str
     if (isDefined(returnedObject[field])) {
       let address = String(returnedObject[field]);
       try {
-        address = toAddress(address);
+        address = toEvmAddress(address);
         // eslint-disable-next-line no-empty
       } catch (_) {}
       returnedObject[field] = address;