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

package/dist/types/utils/AddressUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AddressUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/AddressUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAS,MAAM,QAAQ,CAAC;AAE1C,OAAO,EAAE,SAAS,EAA0B,MAAM,IAAI,CAAC;AAEvD;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CASjH;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAY/E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAKpF;AAKD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjD;AAID,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAItD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAc1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAOvE;AAID,qBAAa,OAAO;IAClB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAGhC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAa;IAC3C,cAAc,EAAE,MAAM,GAAG,SAAS,CAAa;IAC/C,UAAU,EAAE,MAAM,GAAG,SAAS,CAAa;IAC3C,SAAS,EAAE,SAAS,GAAG,SAAS,CAAa;gBAEjC,WAAW,EAAE,UAAU;IAWnC,MAAM,CAAC,iBAAiB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO;IAM1D,SAAS,IAAI,MAAM;IAMnB,iBAAiB,IAAI,MAAM;IAQ3B,QAAQ,IAAI,MAAM;IAKlB,OAAO,CAAC,WAAW;IAMnB,YAAY,IAAI,MAAM;IAWtB,QAAQ,IAAI,MAAM;IAKlB,WAAW,IAAI,MAAM;IAKrB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAOnC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAKvC,QAAQ,IAAI,MAAM;IAKlB,aAAa,IAAI,OAAO;IAKxB,eAAe,IAAI,UAAU;IAK7B,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAK3B,OAAO,CAAC,YAAY,EAAE,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;IAc1C,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAI9C,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;CAG/C;AAGD,qBAAa,UAAW,SAAQ,OAAO;IAGrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;gBAG7B,UAAU,EAAE,UAAU;IAUlC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAOvC,QAAQ,IAAI,MAAM;IAK3B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,QAAQ,GAAG,QAAmB,GAAG,UAAU;CAenF;AAGD,qBAAa,UAAW,SAAQ,OAAO;IAGrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;gBAG7B,UAAU,EAAE,UAAU;IAUlC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAMvC,QAAQ,IAAI,MAAM;IAK3B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,QAAQ,GAAG,QAAmB,GAAG,UAAU;CAYnF"}
+{"version":3,"file":"AddressUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/AddressUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAS,MAAM,QAAQ,CAAC;AAE1C,OAAO,EAAE,SAAS,EAA0B,MAAM,IAAI,CAAC;AAEvD;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CASjH;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAY/E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAKpF;AAKD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjD;AAID,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAItD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAc1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAOvE;AAID,8BAAsB,OAAO;IAC3B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAGhC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAa;IAC3C,cAAc,EAAE,MAAM,GAAG,SAAS,CAAa;IAC/C,UAAU,EAAE,MAAM,GAAG,SAAS,CAAa;IAC3C,SAAS,EAAE,SAAS,GAAG,SAAS,CAAa;gBAEjC,WAAW,EAAE,UAAU;IAanC,SAAS,IAAI,MAAM;IAMnB,iBAAiB,IAAI,MAAM;IAQ3B,QAAQ,IAAI,MAAM;IAKlB,OAAO,CAAC,WAAW;IAMnB,YAAY,IAAI,MAAM;IAWtB,QAAQ,IAAI,MAAM;IAKlB,WAAW,IAAI,MAAM;IAKrB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAOnC,QAAQ,IAAI,MAAM;IAKlB,aAAa,IAAI,OAAO;IAKxB,eAAe,IAAI,UAAU;IAK7B,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAM3B,OAAO,CAAC,YAAY,EAAE,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;IAc1C,KAAK,IAAI,IAAI,IAAI,UAAU;IAI3B,KAAK,IAAI,IAAI,IAAI,UAAU;CAG5B;AAGD,qBAAa,UAAW,SAAQ,OAAO;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAGnB,UAAU,EAAE,UAAU;IASlC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAMvC,KAAK,IAAI,IAAI,IAAI,UAAU;IAK3B,QAAQ,IAAI,MAAM;IAK3B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,QAAQ,GAAG,QAAmB,GAAG,UAAU;CAGnF;AAGD,qBAAa,UAAW,SAAQ,OAAO;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAGnB,UAAU,EAAE,UAAU;IASlC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAUvC,KAAK,IAAI,IAAI,IAAI,UAAU;IAM3B,QAAQ,IAAI,MAAM;IAK3B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,QAAQ,GAAG,QAAmB,GAAG,UAAU;CAGnF;AAED,qBAAa,UAAW,SAAQ,OAAO;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,UAAU,EAAE,UAAU;CAInC"}

package/dist/types/utils/TokenUtils.d.ts

@@ -185,6 +185,14 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
         };
         coingeckoId: string;
     };
+    /**
+     * Retrieves the ERC20 balance for a given address and token address.
+     * @param address The address to retrieve the balance for.
+     * @param tokenAddress The token address
+     * @param signerOrProvider A valid ethers.js Signer or Provider object.
+     * @param blockTag The block tag to retrieve the balance at.
+     * @returns The balance of the given address for the given token address.
+     */
     SOL: {
         name: string;
         symbol: string;
@@ -600,6 +608,14 @@ export declare function getTokenInfo(l2TokenAddress: string, chainId: number, to
         };
         coingeckoId: string;
     };
+    /**
+     * Retrieves the ERC20 balance for a given address and token address.
+     * @param address The address to retrieve the balance for.
+     * @param tokenAddress The token address
+     * @param signerOrProvider A valid ethers.js Signer or Provider object.
+     * @param blockTag The block tag to retrieve the balance at.
+     * @returns The balance of the given address for the given token address.
+     */
     SOL: {
         name: string;
         symbol: string;

package/dist/types/utils/TokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAI5G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAY/E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM7F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,GAAG,SAAS,CAoBjH;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjF"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAC5D,OAAO,EAAY,SAAS,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAM7C,KAAK,gBAAgB,GAAG,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC;AAEpD,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAI5G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAa/E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBjB;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MArBA,MAAM,GAAG,SAIX,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM7F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAvClF;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCmG,GAAG,SAAS,CAoBjH;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.2.16-alpha.4",
+  "version": "4.2.16-alpha.5",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [

package/src/arch/svm/SpokeUtils.ts

@@ -385,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;

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, SvmAddress, getRelayDataHash, isUint8Array, Address as SdkAddress } from "../../utils";
+import { BigNumber, getRelayDataHash, isUint8Array, Address as SdkAddress } from "../../utils";
 import { EventName, SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -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

@@ -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/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(
@@ -136,14 +151,14 @@ export class SvmQuery implements QueryInterface {
       deposit.destinationChainId
     )
   ) {
-    const {
-      depositor,
-      recipient: _recipient,
-      inputToken,
-      outputToken: _outputToken,
-      exclusiveRelayer,
-      destinationChainId,
-    } = deposit;
+    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);
@@ -154,7 +169,6 @@ 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);
 

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.
   }
 }

package/src/utils/TokenUtils.ts

@@ -1,3 +1,4 @@
+import assert from "assert";
 import { BlockTag } from "@ethersproject/abstract-provider";
 import { Contract, providers, Signer } from "ethers";
 import * as constants from "../constants";
@@ -6,7 +7,7 @@ import { ERC20__factory } from "../typechain";
 import { BigNumber } from "./BigNumberUtils";
 import { getNetworkName, chainIsL1, chainIsProd } from "./NetworkUtils";
 import { isDefined } from "./TypeGuards";
-import { compareAddressesSimple, toAddressType } from "./AddressUtils";
+import { compareAddressesSimple, EvmAddress, toAddressType } from "./AddressUtils";
 const { TOKEN_SYMBOLS_MAP, CHAIN_IDs, TOKEN_EQUIVALENCE_REMAPPING } = constants;
 
 type SignerOrProvider = providers.Provider | Signer;
@@ -14,7 +15,7 @@ type SignerOrProvider = providers.Provider | Signer;
 export async function fetchTokenInfo(address: string, signerOrProvider: SignerOrProvider): Promise<TokenInfo> {
   const token = new Contract(address, ERC20__factory.abi, signerOrProvider);
   const [symbol, decimals] = await Promise.all([token.symbol(), token.decimals()]);
-  return { address: toAddressType(address, CHAIN_IDs.MAINNET), symbol, decimals };
+  return { address: EvmAddress.from(address), symbol, decimals };
 }
 
 export const getL2TokenAddresses = (
@@ -42,9 +43,10 @@ export function resolveSymbolOnChain(chainId: number, symbol: string): TokenInfo
   }
 
   const { decimals, addresses } = token;
-  const address = addresses[chainId];
+  const address = toAddressType(addresses[chainId], chainId);
+  assert(address.isEVM() || address.isSVM());
 
-  return { symbol, decimals, address: toAddressType(address, chainId) };
+  return { symbol, decimals, address };
 }
 
 /**