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

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

@@ -1,8 +1,13 @@
-import { Fill, RelayData, SlowFillLeaf } from "../interfaces";
+import { Deposit, Fill, RelayData, SlowFillLeaf } from "../interfaces";
 import { BigNumber } from "./BigNumberUtils";
-import { Address } from "./AddressUtils";
 export declare function isSlowFill(fill: Fill): boolean;
 export declare function getSlowFillLeafLpFeePct(leaf: SlowFillLeaf): BigNumber;
+/**
+ * Produce the RelayData for a Deposit.
+ * @param deposit Deposit instance.
+ * @returns The corresponding RelayData object.
+ */
+export declare function getDepositRelayData(deposit: Omit<Deposit, "messageHash">): RelayData;
 /**
  * Compute the RelayData hash for a fill. This can be used to determine the fill status.
  * @param relayData RelayData information that is used to complete a fill.
@@ -14,6 +19,6 @@ export declare function getRelayHashFromEvent(e: RelayData & {
     destinationChainId: number;
 }): string;
 export declare function isUnsafeDepositId(depositId: BigNumber): boolean;
-export declare function isZeroAddress(address: Address): boolean;
+export declare function isZeroAddress(address: string): boolean;
 export declare function getMessageHash(message: string): string;
 //# sourceMappingURL=SpokeUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SpokeUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/SpokeUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAY,SAAS,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAKzC,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE9C;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,CAGrE;AACD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAkCzF;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,SAAS,GAAG;IAAE,kBAAkB,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE3F;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAQ/D;AAGD,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEvD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD"}
+{"version":3,"file":"SpokeUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/SpokeUtils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAY,SAAS,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEjF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE9C;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,CAGrE;AACD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,GAAG,SAAS,CAepF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAkCzF;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,SAAS,GAAG;IAAE,kBAAkB,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE3F;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAQ/D;AAGD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD"}

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

@@ -1,9 +1,9 @@
 import { BlockTag } from "@ethersproject/abstract-provider";
 import { providers, Signer } from "ethers";
-import { TokenInfo } from "../interfaces";
+import { L1Token } from "../interfaces";
 import { BigNumber } from "./BigNumberUtils";
 type SignerOrProvider = providers.Provider | Signer;
-export declare function fetchTokenInfo(address: string, signerOrProvider: SignerOrProvider): Promise<TokenInfo>;
+export declare function fetchTokenInfo(address: string, signerOrProvider: SignerOrProvider): Promise<L1Token>;
 export declare const getL2TokenAddresses: (l1TokenAddress: string, l1ChainId?: number) => {
     [chainId: number]: string;
 } | undefined;
@@ -14,7 +14,7 @@ export declare const getL2TokenAddresses: (l1TokenAddress: string, l1ChainId?: n
  * @param chainId Chain ID to query on.
  * @returns Symbol, decimals and contract address on the requested chain.
  */
-export declare function resolveSymbolOnChain(chainId: number, symbol: string): TokenInfo;
+export declare function resolveSymbolOnChain(chainId: number, symbol: string): L1Token;
 /**
  * Returns the contract address for a given token symbol and chainId.
  * @param symbol A case-insensitive token symbol.
@@ -124,7 +124,13 @@ export declare const resolveContractFromSymbol: (symbol: string, chainId: string
     };
     GHO: {
         name: string;
-        symbol: string;
+        symbol: string; /**
+         * Returns the contract address for a given token symbol and chainId.
+         * @param symbol A case-insensitive token symbol.
+         * @param chainId The chainId to resolve the contract address for.
+         * @param tokenMapping A parameter to determine where to source token information. Defaults to the constants variant.
+         * @returns The contract address for the given token symbol and chainId, or undefined if the token symbol is not supported.
+         */
         decimals: number;
         addresses: {
             [x: number]: string;
@@ -185,14 +191,6 @@ 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;
@@ -547,7 +545,13 @@ export declare function getTokenInfo(l2TokenAddress: string, chainId: number, to
     };
     GHO: {
         name: string;
-        symbol: string;
+        symbol: string; /**
+         * Returns the contract address for a given token symbol and chainId.
+         * @param symbol A case-insensitive token symbol.
+         * @param chainId The chainId to resolve the contract address for.
+         * @param tokenMapping A parameter to determine where to source token information. Defaults to the constants variant.
+         * @returns The contract address for the given token symbol and chainId, or undefined if the token symbol is not supported.
+         */
         decimals: number;
         addresses: {
             [x: number]: string;
@@ -608,14 +612,6 @@ 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;
@@ -846,7 +842,7 @@ export declare function getTokenInfo(l2TokenAddress: string, chainId: number, to
         };
         coingeckoId: string;
     };
-}): TokenInfo;
+}): L1Token;
 /**
  * Get the USDC symbol for the given token address and chain ID.
  * @param l2Token A Web3 token address (not case sensitive)

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

@@ -1 +1 @@
-{"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"}
+{"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,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,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,OAAO,CAAC,CAI1G;AAED,eAAO,MAAM,mBAAmB,mBACd,MAAM;;aAMvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAY7E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,WAC5B,MAAM,WACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBATjB;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAhElF;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DmG,GAAG,OAAO,CAoB/G;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.6",
+  "version": "4.2.16",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -111,6 +111,7 @@
     "@ethersproject/bignumber": "^5.7.0",
     "@pinata/sdk": "^2.1.0",
     "@solana-program/system": "^0.7.0",
+    "@solana-program/token": "^0.5.1",
     "@solana-program/token-2022": "^0.4.0",
     "@solana/kit": "^2.1.0",
     "@solana/web3.js": "^1.31.0",

package/src/arch/evm/SpokeUtils.ts

@@ -1,18 +1,10 @@
 import assert from "assert";
 import { BytesLike, Contract, PopulatedTransaction, providers } from "ethers";
 import { CHAIN_IDs } from "../../constants";
-import {
-  Deposit,
-  FillStatus,
-  FillWithBlock,
-  RelayData,
-  RelayExecutionEventInfo,
-  SpeedUpCommon,
-} from "../../interfaces";
+import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
 import {
   bnUint32Max,
   BigNumber,
-  EvmAddress,
   toBN,
   bnZero,
   chunk,
@@ -20,70 +12,47 @@ import {
   getRelayDataHash,
   isDefined,
   isUnsafeDepositId,
+  isZeroAddress,
+  getDepositRelayData,
   getNetworkName,
   paginatedEventQuery,
   spreadEventWithBlockNumber,
-  Address,
-  toAddressType,
+  toBytes32,
 } from "../../utils";
 
 type BlockTag = providers.BlockTag;
 
-type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> &
-  Pick<Deposit, "speedUpSignature"> &
-  Partial<SpeedUpCommon> & {
-    destinationChainId: number;
-    recipient: EvmAddress;
-    outputToken: EvmAddress;
-  };
-
 /**
  * @param spokePool SpokePool Contract instance.
- * @param relayData RelayData instance, supplemented with destinationChainId
+ * @param deposit V3Deopsit instance.
  * @param repaymentChainId Optional repaymentChainId (defaults to destinationChainId).
  * @returns An Ethers UnsignedTransaction instance.
  */
 export function populateV3Relay(
   spokePool: Contract,
-  relayData: ProtoFill,
-  repaymentAddress: Address,
-  repaymentChainId = relayData.destinationChainId
+  deposit: Omit<Deposit, "messageHash">,
+  relayer: string,
+  repaymentChainId = deposit.destinationChainId
 ): Promise<PopulatedTransaction> {
-  assert(
-    repaymentAddress.isValidOn(repaymentChainId),
-    `Invalid repayment address for chain ${repaymentChainId}: ${repaymentAddress.toNative()}.`
-  );
-  const evmRelayData = {
-    depositor: relayData.depositor.toBytes32(),
-    recipient: relayData.recipient.toBytes32(),
-    inputToken: relayData.inputToken.toBytes32(),
-    outputToken: relayData.outputToken.toBytes32(),
-    inputAmount: relayData.inputAmount,
-    outputAmount: relayData.outputAmount,
-    originChainId: relayData.originChainId,
-    depositId: relayData.depositId,
-    fillDeadline: relayData.fillDeadline,
-    exclusivityDeadline: relayData.exclusivityDeadline,
-    message: relayData.message,
-    exclusiveRelayer: relayData.exclusiveRelayer.toBytes32(),
-  };
-
-  if (isDefined(relayData.speedUpSignature)) {
-    assert(isDefined(relayData.updatedRecipient) && !relayData.updatedRecipient.isZeroAddress());
-    assert(isDefined(relayData.updatedOutputAmount));
-    assert(isDefined(relayData.updatedMessage));
+  const relayData = getDepositRelayData(deposit);
+
+  if (isDefined(deposit.speedUpSignature)) {
+    assert(isDefined(deposit.updatedRecipient) && !isZeroAddress(deposit.updatedRecipient));
+    assert(isDefined(deposit.updatedOutputAmount));
+    assert(isDefined(deposit.updatedMessage));
     return spokePool.populateTransaction.fillRelayWithUpdatedDeposit(
       relayData,
       repaymentChainId,
-      repaymentAddress.toBytes32(),
-      relayData.updatedOutputAmount,
-      relayData.updatedRecipient.toBytes32(),
-      relayData.updatedMessage,
-      relayData.speedUpSignature
+      toBytes32(relayer),
+      deposit.updatedOutputAmount,
+      toBytes32(deposit.updatedRecipient),
+      deposit.updatedMessage,
+      deposit.speedUpSignature,
+      { from: relayer }
     );
   }
 
-  return spokePool.populateTransaction.fillRelay(evmRelayData, repaymentChainId, repaymentAddress.toBytes32());
+  return spokePool.populateTransaction.fillRelay(relayData, repaymentChainId, toBytes32(relayer), { from: relayer });
 }
 
 /**
@@ -346,27 +315,8 @@ export async function findFillEvent(
   const destinationChainId = Object.values(CHAIN_IDs).includes(relayData.originChainId)
     ? (await spokePool.provider.getNetwork()).chainId
     : Number(await spokePool.chainId());
-  const fillEvent = spreadEventWithBlockNumber(event) as FillWithBlock & {
-    depositor: string;
-    recipient: string;
-    inputToken: string;
-    outputToken: string;
-    exclusiveRelayer: string;
-    relayer: string;
-    relayExecutionInfo: RelayExecutionEventInfo & { updatedRecipient: string };
-  };
   const fill = {
-    ...fillEvent,
-    inputToken: toAddressType(fillEvent.inputToken, relayData.originChainId),
-    outputToken: toAddressType(fillEvent.outputToken, destinationChainId),
-    depositor: toAddressType(fillEvent.depositor, relayData.originChainId),
-    recipient: toAddressType(fillEvent.recipient, destinationChainId),
-    exclusiveRelayer: toAddressType(fillEvent.exclusiveRelayer, destinationChainId),
-    relayer: toAddressType(fillEvent.relayer, destinationChainId),
-    relayExecutionInfo: {
-      ...fillEvent.relayExecutionInfo,
-      updatedRecipient: toAddressType(fillEvent.relayExecutionInfo.updatedRecipient, destinationChainId),
-    },
+    ...spreadEventWithBlockNumber(event),
     destinationChainId,
     messageHash: getMessageHash(event.args.message),
   } as FillWithBlock;

package/src/arch/svm/SpokeUtils.ts

@@ -24,13 +24,13 @@ import {
 import assert from "assert";
 import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
+
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
-import { DepositWithBlock, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
+import { Deposit, DepositWithBlock, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
 import {
   BigNumber,
   EvmAddress,
   SvmAddress,
-  Address as SdkAddress,
   chainIsSvm,
   chunk,
   isUnsafeDepositId,
@@ -46,7 +46,6 @@ import {
   toAddress,
   unwrapEventData,
 } from "./";
-import { CHAIN_IDs } from "../../constants";
 import { SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -55,12 +54,6 @@ import { SVMEventNames, SVMProvider } from "./types";
  */
 export const SLOT_DURATION_MS = 400;
 
-type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> & {
-  destinationChainId: number;
-  recipient: SvmAddress;
-  outputToken: SvmAddress;
-};
-
 /**
  * Retrieves the chain time at a particular slot.
  */
@@ -152,20 +145,13 @@ export async function findDeposit(
     return undefined;
   }
 
-  const unwrappedDepositEvent = unwrapEventData(depositEvent.data) as Record<string, unknown>;
-  const destinationChainId = unwrappedDepositEvent.destinationChainId as number;
   // Return the deposit event with block info
   return {
     txnRef: depositEvent.signature.toString(),
     blockNumber: Number(depositEvent.slot),
     txnIndex: 0,
     logIndex: 0,
-    ...unwrappedDepositEvent,
-    depositor: toAddressType(unwrappedDepositEvent.depositor as string, CHAIN_IDs.SOLANA),
-    recipient: toAddressType(unwrappedDepositEvent.recipient as string, destinationChainId),
-    inputToken: toAddressType(unwrappedDepositEvent.inputToken as string, CHAIN_IDs.SOLANA),
-    outputToken: toAddressType(unwrappedDepositEvent.outputToken as string, destinationChainId),
-    exclusiveRelayer: toAddressType(unwrappedDepositEvent.exclusiveRelayer as string, destinationChainId),
+    ...(unwrapEventData(depositEvent.data) as Record<string, unknown>),
   } as DepositWithBlock;
 }
 
@@ -341,34 +327,14 @@ export async function findFillEvent(
 
   if (fillEvents.length > 0) {
     const rawFillEvent = fillEvents[0];
-    const eventData = unwrapEventData(rawFillEvent.data) as FillWithBlock & {
-      depositor: string;
-      recipient: string;
-      inputToken: string;
-      outputToken: string;
-      exclusiveRelayer: string;
-      relayer: string;
-      relayExecutionInfo: RelayExecutionEventInfo & { updatedRecipient: string };
-    };
-    const originChainId = eventData.originChainId;
     const parsedFillEvent = {
-      ...eventData,
       transactionHash: rawFillEvent.signature,
       blockNumber: Number(rawFillEvent.slot),
       transactionIndex: 0,
       logIndex: 0,
       destinationChainId,
-      inputToken: toAddressType(eventData.inputToken, originChainId),
-      outputToken: toAddressType(eventData.outputToken, destinationChainId),
-      relayer: toAddressType(eventData.relayer, destinationChainId),
-      exclusiveRelayer: toAddressType(eventData.exclusiveRelayer, destinationChainId),
-      depositor: toAddressType(eventData.depositor, originChainId),
-      recipient: toAddressType(eventData.recipient, destinationChainId),
-      relayExecutionInfo: {
-        ...eventData.relayExecutionInfo,
-        updatedRecipient: eventData.relayExecutionInfo.updatedRecipient,
-      },
-    } as FillWithBlock;
+      ...(unwrapEventData(rawFillEvent.data) as Record<string, unknown>),
+    } as unknown as FillWithBlock;
     return parsedFillEvent;
   }
 
@@ -377,18 +343,18 @@ export async function findFillEvent(
 
 /**
  * @param spokePool Address (program ID) of the SvmSpoke.
- * @param relayData RelayData instance, supplemented with destinationChainId
+ * @param deposit V3Deopsit instance.
  * @param relayer Address of the relayer filling the deposit.
  * @param repaymentChainId Optional repaymentChainId (defaults to destinationChainId).
  * @returns An Ethers UnsignedTransaction instance.
  */
 export async function fillRelayInstruction(
   spokePool: SvmAddress,
-  relayData: ProtoFill,
+  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain">,
   signer: TransactionSigner<string>,
   recipientTokenAccount: Address<string>,
   repaymentAddress: EvmAddress | SvmAddress = SvmAddress.from(signer.address),
-  repaymentChainId = relayData.destinationChainId
+  repaymentChainId = deposit.destinationChainId
 ) {
   const program = toAddress(spokePool);
 
@@ -397,22 +363,25 @@ export async function fillRelayInstruction(
     `Invalid repayment address for chain ${repaymentChainId}: ${repaymentAddress.toNative()}.`
   );
 
-  const _relayDataHash = getRelayDataHash(relayData, relayData.destinationChainId);
+  const _relayDataHash = getRelayDataHash(deposit, deposit.destinationChainId);
   const relayDataHash = new Uint8Array(Buffer.from(_relayDataHash.slice(2), "hex"));
 
   const relayer = SvmAddress.from(signer.address);
+  const outputTokenAddress = toAddressType(deposit.outputToken, deposit.destinationChainId);
+  if (!(outputTokenAddress instanceof SvmAddress)) {
+    return undefined;
+  }
 
   // Create ATA for the relayer and recipient token accounts
-  const relayerTokenAccount = await getAssociatedTokenAddress(relayer, relayData.outputToken);
+  const relayerTokenAccount = await getAssociatedTokenAddress(relayer, outputTokenAddress);
 
   const [statePda, fillStatusPda, eventAuthority] = await Promise.all([
     getStatePda(program),
-    getFillStatusPda(program, relayData, relayData.destinationChainId),
-    getEventAuthority(program),
+    getFillStatusPda(program, deposit, deposit.destinationChainId),
+    getEventAuthority(),
   ]);
-
   const depositIdBuffer = new Uint8Array(32);
-  const shortenedBuffer = new Uint8Array(Buffer.from(relayData.depositId.toHexString().slice(2), "hex"));
+  const shortenedBuffer = new Uint8Array(Buffer.from(deposit.depositId.toHexString().slice(2), "hex"));
   depositIdBuffer.set(shortenedBuffer, 32 - shortenedBuffer.length);
 
   const delegatePda = await getFillRelayDelegatePda(
@@ -422,14 +391,26 @@ export async function fillRelayInstruction(
     program
   );
 
-  const [recipient, outputToken, exclusiveRelayer, depositor, inputToken] = [
-    relayData.recipient,
-    relayData.outputToken,
-    relayData.exclusiveRelayer,
-    relayData.depositor,
-    relayData.inputToken,
-  ].map(toAddress);
+  // @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((addr: string) => {
+    const addressObj = toAddressType(addr, deposit.originChainId);
+    // @dev we don't really care for correctness of format of depositor / inputToken, so we're fine converting to Solana
+    // SDK `Address<string>` type even if our `toAddressType` function returned a raw address.
+    return addressObj.toBase58() as Address<string>;
+  });
+
+  const [recipient, exclusiveRelayer] = [deposit.recipient, deposit.exclusiveRelayer].map((addr) => {
+    const addressObj = toAddressType(addr, deposit.originChainId);
+    if (!(addressObj instanceof SvmAddress)) {
+      return undefined;
+    }
+    return toAddress(addressObj);
+  });
+
+  if (!recipient || !exclusiveRelayer) return undefined;
 
+  const outputToken = toAddress(outputTokenAddress);
   return SvmSpokeClient.getFillRelayInstruction({
     signer,
     state: statePda,
@@ -447,13 +428,13 @@ export async function fillRelayInstruction(
       exclusiveRelayer,
       inputToken,
       outputToken,
-      inputAmount: relayData.inputAmount.toBigInt(),
-      outputAmount: relayData.outputAmount.toBigInt(),
-      originChainId: BigInt(relayData.originChainId),
-      fillDeadline: relayData.fillDeadline,
-      exclusivityDeadline: relayData.exclusivityDeadline,
+      inputAmount: deposit.inputAmount.toBigInt(),
+      outputAmount: deposit.outputAmount.toBigInt(),
+      originChainId: BigInt(deposit.originChainId),
+      fillDeadline: deposit.fillDeadline,
+      exclusivityDeadline: deposit.exclusivityDeadline,
       depositId: depositIdBuffer,
-      message: new Uint8Array(Buffer.from(relayData.message.slice(2), "hex")),
+      message: new Uint8Array(Buffer.from(deposit.message.slice(2), "hex")),
     }),
     repaymentChainId: some(BigInt(repaymentChainId)),
     repaymentAddress: toAddress(repaymentAddress),
@@ -635,14 +616,19 @@ export function getRelayDataHash(relayData: RelayData, destinationChainId: numbe
   const uint32Encoder = getU32Encoder();
 
   assert(relayData.message.startsWith("0x"), "Message must be a hex string");
-  const encodeAddress = (data: SdkAddress) => Uint8Array.from(addressEncoder.encode(toAddress(data)));
+  const encodeAddress = (addr: string, chainId: number) => {
+    const addrObj = toAddressType(addr, chainId);
+    // @dev even if `addrObj` is of type `Address` here, we still want to calculate the relayHash
+    // based on `base58` representation of the `Address`
+    return Uint8Array.from(addressEncoder.encode(addrObj.toBase58() as Address<string>));
+  };
 
   const contentToHash = Buffer.concat([
-    encodeAddress(relayData.depositor),
-    encodeAddress(relayData.recipient),
-    encodeAddress(relayData.exclusiveRelayer),
-    encodeAddress(relayData.inputToken),
-    encodeAddress(relayData.outputToken),
+    encodeAddress(relayData.depositor, relayData.originChainId),
+    encodeAddress(relayData.recipient, destinationChainId),
+    encodeAddress(relayData.exclusiveRelayer, destinationChainId),
+    encodeAddress(relayData.inputToken, relayData.originChainId),
+    encodeAddress(relayData.outputToken, destinationChainId),
     Uint8Array.from(uint64Encoder.encode(BigInt(relayData.inputAmount.toString()))),
     Uint8Array.from(uint64Encoder.encode(BigInt(relayData.outputAmount.toString()))),
     Uint8Array.from(uint64Encoder.encode(BigInt(relayData.originChainId.toString()))),

package/src/arch/svm/eventsClient.ts

@@ -10,7 +10,7 @@ import {
   GetTransactionApi,
   Signature,
 } from "@solana/kit";
-import { bs58, chainIsSvm, getMessageHash, toAddressType } from "../../utils";
+import { bs58, chainIsSvm, getMessageHash } from "../../utils";
 import { EventName, EventWithData, SVMProvider } from "./types";
 import { decodeEvent, isDevnet } from "./utils";
 import { Deposit, DepositWithTime, Fill, FillWithTime } from "../../interfaces";
@@ -252,6 +252,7 @@ export class SvmCpiEventsClient {
 
     // Filter for FundsDeposited events only
     const depositEvents = events?.filter((event) => event?.name === "FundsDeposited");
+
     if (!txDetails || !depositEvents?.length) {
       return;
     }
@@ -260,29 +261,13 @@ 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 {
-        ...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),
+        ...unwrappedEventArgs.data,
         depositTimestamp: Number(txDetails.blockTime),
         originChainId,
-        messageHash: getMessageHash(data.message),
+        messageHash: getMessageHash(unwrappedEventArgs.data.message),
         blockNumber: Number(txDetails.slot),
         txnIndex: 0,
         txnRef: txSignature,
@@ -324,26 +309,9 @@ export class SvmCpiEventsClient {
     }
 
     return fillEvents.map((event) => {
-      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;
+      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<"data", Fill>;
       return {
-        ...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),
+        ...unwrappedEventData.data,
         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, getRelayDataHash, isUint8Array, Address as SdkAddress } from "../../utils";
+import { BigNumber, EvmAddress, SvmAddress, getRelayDataHash, isUint8Array } 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: SdkAddress): Address<string> {
+export function toAddress(address: EvmAddress | SvmAddress): 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 ethers.utils.hexlify(bs58.decode(data));
+    return SvmAddress.from(data).toBytes32();
   }
   // Handle objects
   if (typeof data === "object") {
@@ -280,13 +280,13 @@ export async function getInstructionParamsPda(programId: Address, signer: Addres
  * Returns the PDA for the Event Authority.
  * @returns The PDA for the Event Authority.
  */
-export async function getEventAuthority(programId: Address): Promise<Address> {
+export const getEventAuthority = async () => {
   const [eventAuthority] = await getProgramDerivedAddress({
-    programAddress: programId,
+    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
     seeds: ["__event_authority"],
   });
   return eventAuthority;
-}
+};
 
 /**
  * Returns a random SVM address.