@across-protocol/sdk 4.2.16-alpha.3 → 4.2.16-alpha.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.2.16-alpha.3",
+  "version": "4.2.16-alpha.5",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -10,7 +10,7 @@
     "src"
   ],
   "engines": {
-    "node": ">=20.18.0"
+    "node": ">=20.19.2"
   },
   "scripts": {
     "build-bigint-buffer": "node scripts/build-bigint-buffer.js",

package/src/arch/evm/SpokeUtils.ts

@@ -3,7 +3,6 @@ import { BytesLike, Contract, PopulatedTransaction, providers } from "ethers";
 import { CHAIN_IDs } from "../../constants";
 import { Deposit, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
 import {
-  EvmAddress,
   bnUint32Max,
   BigNumber,
   toBN,
@@ -31,11 +30,7 @@ type BlockTag = providers.BlockTag;
  */
 export function populateV3Relay(
   spokePool: Contract,
-  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain"> & {
-    recipient: EvmAddress;
-    outputToken: EvmAddress;
-    exclusiveRelayer: EvmAddress;
-  },
+  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain">,
   repaymentAddress: Address,
   repaymentChainId = deposit.destinationChainId
 ): Promise<PopulatedTransaction> {

package/src/arch/svm/SpokeUtils.ts

@@ -37,6 +37,7 @@ import {
   BigNumber,
   EvmAddress,
   SvmAddress,
+  Address as SdkAddress,
   chainIsSvm,
   chunk,
   isUnsafeDepositId,
@@ -384,7 +385,10 @@ export async function findFillEvent(
  */
 export async function fillRelayInstruction(
   spokePool: SvmAddress,
-  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain"> & {
+  deposit: Omit<
+    Deposit,
+    "recipient" | "outputToken" | "exclusiveRelayer" | "messageHash" | "fromLiteChain" | "toLiteChain"
+  > & {
     recipient: SvmAddress;
     outputToken: SvmAddress;
     exclusiveRelayer: SvmAddress;
@@ -405,6 +409,7 @@ export async function fillRelayInstruction(
   const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
 
   const relayer = SvmAddress.from(signer.address);
+
   // Create ATA for the relayer and recipient token accounts
   const relayerTokenAccount = await getAssociatedTokenAddress(relayer, deposit.outputToken);
 
@@ -425,13 +430,12 @@ export async function fillRelayInstruction(
     program
   );
 
-  // @todo we need to convert the deposit's relayData to svm-like since the interface assumes the data originates
-  // from an EVM Spoke pool. Once we migrate to `Address` types, this can be modified/removed.
-  const [depositor, inputToken] = [deposit.depositor, deposit.inputToken].map(toAddress);
-  const [recipient, outputToken, exclusiveRelayer] = [
+  const [recipient, outputToken, exclusiveRelayer, depositor, inputToken] = [
     deposit.recipient,
     deposit.outputToken,
     deposit.exclusiveRelayer,
+    deposit.depositor,
+    deposit.inputToken,
   ].map(toAddress);
 
   return SvmSpokeClient.getFillRelayInstruction({
@@ -639,7 +643,7 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
   const uint32Encoder = getU32Encoder();
 
   assert(relayData.message.startsWith("0x"), "Message must be a hex string");
-  const encodeAddress = (data: SvmAddress) => Uint8Array.from(addressEncoder.encode(toAddress(data)));
+  const encodeAddress = (data: SdkAddress) => Uint8Array.from(addressEncoder.encode(toAddress(data)));
 
   const contentToHash = Buffer.concat([
     encodeAddress(relayData.depositor),

package/src/arch/svm/eventsClient.ts

@@ -10,7 +10,7 @@ import {
   GetTransactionApi,
   Signature,
 } from "@solana/kit";
-import { bs58, chainIsSvm, getMessageHash } from "../../utils";
+import { bs58, chainIsSvm, getMessageHash, toAddressType } from "../../utils";
 import { EventName, EventWithData, SVMProvider } from "./types";
 import { decodeEvent, isDevnet } from "./utils";
 import { Deposit, DepositWithTime, Fill, FillWithTime } from "../../interfaces";
@@ -252,7 +252,6 @@ export class SvmCpiEventsClient {
 
     // Filter for FundsDeposited events only
     const depositEvents = events?.filter((event) => event?.name === "FundsDeposited");
-
     if (!txDetails || !depositEvents?.length) {
       return;
     }
@@ -261,13 +260,29 @@ export class SvmCpiEventsClient {
       const unwrappedEventArgs = unwrapEventData(event as Record<string, unknown>, ["depositId"]) as Record<
         "data",
         Deposit
-      >;
-
+      > &
+        Record<
+          "data",
+          {
+            depositor: string;
+            recipient: string;
+            exclusiveRelayer: string;
+            inputToken: string;
+            outputToken: string;
+          }
+        >;
+
+      const { data } = unwrappedEventArgs;
       return {
-        ...unwrappedEventArgs.data,
+        ...data,
+        depositor: toAddressType(data.depositor, data.originChainId),
+        recipient: toAddressType(data.recipient, data.destinationChainId),
+        exclusiveRelayer: toAddressType(data.exclusiveRelayer, data.destinationChainId),
+        inputToken: toAddressType(data.inputToken, data.originChainId),
+        outputToken: toAddressType(data.outputToken, data.destinationChainId),
         depositTimestamp: Number(txDetails.blockTime),
         originChainId,
-        messageHash: getMessageHash(unwrappedEventArgs.data.message),
+        messageHash: getMessageHash(data.message),
         blockNumber: Number(txDetails.slot),
         txnIndex: 0,
         txnRef: txSignature,
@@ -309,9 +324,26 @@ export class SvmCpiEventsClient {
     }
 
     return fillEvents.map((event) => {
-      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<"data", Fill>;
+      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<"data", Fill> &
+        Record<
+          "data",
+          {
+            depositor: string;
+            recipient: string;
+            exclusiveRelayer: string;
+            inputToken: string;
+            outputToken: string;
+          }
+        >;
+
+      const { data } = unwrappedEventData;
       return {
-        ...unwrappedEventData.data,
+        ...data,
+        depositor: toAddressType(data.depositor, data.originChainId),
+        recipient: toAddressType(data.recipient, data.destinationChainId),
+        exclusiveRelayer: toAddressType(data.exclusiveRelayer, data.destinationChainId),
+        inputToken: toAddressType(data.inputToken, data.originChainId),
+        outputToken: toAddressType(data.outputToken, data.destinationChainId),
         fillTimestamp: Number(txDetails.blockTime),
         blockNumber: Number(txDetails.slot),
         txnRef: txSignature,

package/src/arch/svm/utils.ts

@@ -17,7 +17,7 @@ import {
 } from "@solana/kit";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { FillType, RelayData } from "../../interfaces";
-import { BigNumber, EvmAddress, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
+import { BigNumber, getRelayDataHash, isUint8Array, Address as SdkAddress } from "../../utils";
 import { EventName, SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -45,7 +45,7 @@ export async function isDevnet(rpc: SVMProvider): Promise<boolean> {
 /**
  * Small utility to convert an Address to a Solana Kit branded type.
  */
-export function toAddress(address: EvmAddress | SvmAddress): Address<string> {
+export function toAddress(address: SdkAddress): Address<string> {
   return address.toBase58() as Address<string>;
 }
 
@@ -144,7 +144,7 @@ export function unwrapEventData(
   }
   // Handle strings (potential addresses)
   if (typeof data === "string" && isAddress(data)) {
-    return SvmAddress.from(data).toBytes32();
+    return ethers.utils.hexlify(bs58.decode(data));
   }
   // Handle objects
   if (typeof data === "object") {

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

@@ -1010,7 +1010,7 @@ export class HubPoolClient extends BaseAbstractClient {
       const [tokenInfo, lpTokenInfo] = await Promise.all([
         Promise.all(
           uniqueL1Tokens.map(async (l1Token: string) => {
-            const tokenInfo: L1TokenInfo = await fetchTokenInfo(l1Token, this.hubPool.provider);
+            const tokenInfo = await fetchTokenInfo(l1Token, this.hubPool.provider);
             return {
               ...tokenInfo,
               address: EvmAddress.from(l1Token),
@@ -1049,7 +1049,7 @@ export class HubPoolClient extends BaseAbstractClient {
             const args = spreadEventWithBlockNumber(_event) as ProposedRootBundle & { proposer: string };
             return {
               ...args,
-              proposer: toAddressType(args.proposer, this.chainId),
+              proposer: EvmAddress.from(args.proposer),
             };
           })
       );
@@ -1086,11 +1086,12 @@ export class HubPoolClient extends BaseAbstractClient {
           );
         }
         executedRootBundle.runningBalances = runningBalances.slice(0, nTokens);
-        const executedRootBundleWithL1Tokens = {
+        this.executedRootBundles.push({
           ...executedRootBundle,
-          l1Tokens: executedRootBundle.l1Tokens.map(toAddressType, this.chainId),
-        };
-        this.executedRootBundles.push(executedRootBundleWithL1Tokens);
+          l1Tokens: l1Tokens.map((token: string) => {
+            return EvmAddress.from(token, "base16");
+          }),
+        });
       }
     }
 

package/src/clients/SpokePoolClient/SpokePoolClient.ts

@@ -588,13 +588,16 @@ 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;
           }
 
           return {
             ...event,
-            depositor: toAddressType(event.depositor, this.chainId),
+            depositor: EvmAddress.from(event.depositor),
             updatedRecipient: EvmAddress.from(event.updatedRecipient),
           } as SpeedUpWithBlock;
         })

package/src/clients/mocks/MockHubPoolClient.ts

@@ -1,7 +1,7 @@
 import winston from "winston";
 import { Contract } from "ethers";
 import { BigNumber, randomAddress, assign, bnZero, toAddressType, EvmAddress, Address, isDefined } from "../../utils";
-import { TokenInfo, Log, PendingRootBundle, RealizedLpFee, L1TokenInfo } from "../../interfaces";
+import { Log, PendingRootBundle, RealizedLpFee, L1TokenInfo } from "../../interfaces";
 import { AcrossConfigStoreClient as ConfigStoreClient } from "../AcrossConfigStoreClient";
 import { HubPoolClient, HubPoolUpdate, LpFeeRequest } from "../HubPoolClient";
 import { EventManager, EventOverrides, getEventManager } from "./MockEvents";
@@ -83,7 +83,7 @@ export class MockHubPoolClient extends HubPoolClient {
     this.latestHeightSearched = blockNumber;
   }
 
-  addL1Token(l1Token: TokenInfo) {
+  addL1Token(l1Token: L1TokenInfo) {
     this.l1TokensMock.push(l1Token);
   }
 
@@ -132,7 +132,7 @@ export class MockHubPoolClient extends HubPoolClient {
     return l2Token ?? super.getL2TokenForL1TokenAtBlock(l1Token, chainId, blockNumber);
   }
 
-  getTokenInfoForL1Token(l1Token: EvmAddress): TokenInfo | undefined {
+  getTokenInfoForL1Token(l1Token: EvmAddress): L1TokenInfo | undefined {
     return this.l1TokensMock.find((token) => token.address.eq(l1Token));
   }
 

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/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -9,6 +9,7 @@ import { SpokePool, SpokePool__factory } from "../../typechain";
 import { populateV3Relay } from "../../arch/evm";
 import {
   BigNumberish,
+  EvmAddress,
   TransactionCostEstimate,
   BigNumber,
   toBNWei,
@@ -93,7 +94,12 @@ export class QueryBase implements QueryInterface {
       transport,
     } = options;
 
-    const tx = await this.getUnsignedTxFromDeposit(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = deposit;
+    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({ ...deposit, recipient, outputToken, exclusiveRelayer }, relayer);
     const {
       nativeGasCost,
       tokenGasCost,
@@ -123,7 +129,11 @@ export class QueryBase implements QueryInterface {
    * @returns PopulatedTransaction
    */
   getUnsignedTxFromDeposit(
-    deposit: Omit<Deposit, "messageHash">,
+    deposit: Omit<Deposit, "messageHash"> & {
+      recipient: EvmAddress;
+      outputToken: EvmAddress;
+      exclusiveRelayer: EvmAddress;
+    },
     relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<PopulatedTransaction> {
     return populateV3Relay(this.spokePool, deposit, relayer);
@@ -139,7 +149,15 @@ export class QueryBase implements QueryInterface {
     deposit: Omit<Deposit, "messageHash">,
     relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId)
   ): Promise<BigNumber> {
-    const unsignedTx = await this.getUnsignedTxFromDeposit(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = deposit;
+    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(
+      { ...deposit, recipient, outputToken, exclusiveRelayer },
+      relayer
+    );
     const voidSigner = new VoidSigner(relayer.toEvmAddress(), this.provider);
     return voidSigner.estimateGas(unsignedTx);
   }

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";
@@ -83,7 +84,12 @@ export class SvmQuery implements QueryInterface {
       priorityFeeMultiplier: BigNumber;
     }> = {}
   ): Promise<TransactionCostEstimate> {
-    const fillRelayTx = await this.getFillRelayTx(deposit, relayer);
+    const { recipient, outputToken, exclusiveRelayer } = deposit;
+    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({ ...deposit, recipient, outputToken, exclusiveRelayer }, relayer);
 
     const [computeUnitsConsumed, gasPriceEstimate] = await Promise.all([
       toBN(await this.computeUnitEstimator(fillRelayTx)),
@@ -114,10 +120,15 @@ export class SvmQuery implements QueryInterface {
    * @returns Estimated gas cost in compute units
    */
   async getNativeGasCost(
-    deposit: Omit<Deposit, "messageHash">,
+    deposit: Omit<Deposit, "messageHash">, // @todo Update interface to permit EvmAddress | SvmAddress
     _relayer = toAddressType(getDefaultSimulatedRelayerAddress(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));
   }
 
@@ -128,7 +139,11 @@ export class SvmQuery implements QueryInterface {
    * @returns FillRelay transaction
    */
   async getFillRelayTx(
-    deposit: Omit<Deposit, "messageHash">,
+    deposit: Omit<Deposit, "recipent" | "outputToken" | "exclusiveRelayer" | "messageHash"> & {
+      recipient: SvmAddress;
+      outputToken: SvmAddress;
+      exclusiveRelayer: SvmAddress;
+    },
     relayer = toAddressType(getDefaultSimulatedRelayerAddress(deposit.destinationChainId), deposit.destinationChainId),
     repaymentChainId = deposit.destinationChainId,
     repaymentAddress = toAddressType(
@@ -138,6 +153,13 @@ export class SvmQuery implements QueryInterface {
   ) {
     const { depositor, recipient, inputToken, outputToken, exclusiveRelayer, destinationChainId } = deposit;
 
+    // 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 = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
@@ -151,7 +173,7 @@ export class SvmQuery implements QueryInterface {
     const mintInfo = await fetchMint(this.provider, mint);
 
     const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
-      getAssociatedTokenAddress(deposit.recipient, outputToken, mintInfo.programAddress),
+      getAssociatedTokenAddress(recipient, outputToken, mintInfo.programAddress),
       getAssociatedTokenAddress(SvmAddress.from(relayer.toBase58()), outputToken, mintInfo.programAddress),
       getFillStatusPda(program, deposit, destinationChainId),
       getEventAuthority(program),

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,17 +199,19 @@ 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 {
+  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) {
     if (!EvmAddress.validate(rawAddress)) {
@@ -225,6 +219,7 @@ export class EvmAddress extends Address {
     }
 
     super(rawAddress);
+    this._type; // tsc noUnusedLocals appeasement.
   }
 
   static validate(rawAddress: Uint8Array): boolean {
@@ -233,31 +228,25 @@ 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 {
+  private readonly _type = "svm";
+
   // On construction, validate that the address is a point on Curve25519. Throw immediately if it is not.
   constructor(rawAddress: Uint8Array) {
     if (!SvmAddress.validate(rawAddress)) {
@@ -265,10 +254,21 @@ export class SvmAddress extends Address {
     }
 
     super(rawAddress);
+    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
@@ -279,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.
   }
 }