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

package/src/arch/svm/SpokeUtils.ts

@@ -24,20 +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 {
-  Deposit,
-  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,
@@ -53,7 +46,6 @@ import {
   toAddress,
   unwrapEventData,
 } from "./";
-import { CHAIN_IDs } from "../../constants";
 import { SVMEventNames, SVMProvider } from "./types";
 
 /**
@@ -153,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;
 }
 
@@ -342,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;
   }
 
@@ -385,14 +350,7 @@ export async function findFillEvent(
  */
 export async function fillRelayInstruction(
   spokePool: SvmAddress,
-  deposit: Omit<
-    Deposit,
-    "recipient" | "outputToken" | "exclusiveRelayer" | "messageHash" | "fromLiteChain" | "toLiteChain"
-  > & {
-    recipient: SvmAddress;
-    outputToken: SvmAddress;
-    exclusiveRelayer: SvmAddress;
-  },
+  deposit: Omit<Deposit, "messageHash" | "fromLiteChain" | "toLiteChain">,
   signer: TransactionSigner<string>,
   recipientTokenAccount: Address<string>,
   repaymentAddress: EvmAddress | SvmAddress = SvmAddress.from(signer.address),
@@ -409,16 +367,19 @@ export async function fillRelayInstruction(
   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, deposit.outputToken);
+  const relayerTokenAccount = await getAssociatedTokenAddress(relayer, outputTokenAddress);
 
   const [statePda, fillStatusPda, eventAuthority] = await Promise.all([
     getStatePda(program),
     getFillStatusPda(program, deposit, deposit.destinationChainId),
-    getEventAuthority(program),
+    getEventAuthority(),
   ]);
-
   const depositIdBuffer = new Uint8Array(32);
   const shortenedBuffer = new Uint8Array(Buffer.from(deposit.depositId.toHexString().slice(2), "hex"));
   depositIdBuffer.set(shortenedBuffer, 32 - shortenedBuffer.length);
@@ -430,14 +391,26 @@ export async function fillRelayInstruction(
     program
   );
 
-  const [recipient, outputToken, exclusiveRelayer, depositor, inputToken] = [
-    deposit.recipient,
-    deposit.outputToken,
-    deposit.exclusiveRelayer,
-    deposit.depositor,
-    deposit.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,
@@ -643,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.

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

@@ -5,7 +5,6 @@ import winston from "winston";
 import { isError } from "../../typeguards";
 import {
   EventSearchConfig,
-  EvmAddress,
   MakeOptional,
   isArrayOf,
   isDefined,
@@ -108,7 +107,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
   }
 
   getRateModelForBlockNumber(
-    l1Token: EvmAddress,
+    l1Token: string,
     originChainId: number | string,
     destinationChainId: number | string,
     blockNumber: number | undefined = undefined
@@ -122,9 +121,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
 
     const defaultRateModelUpdate = sortEventsDescending(this.cumulativeRateModelUpdates).find(
       (config) =>
-        config.blockNumber <= (blockNumber ?? 0) &&
-        config.l1Token === l1Token.toEvmAddress() &&
-        config.rateModel !== undefined
+        config.blockNumber <= (blockNumber ?? 0) && config.l1Token === l1Token && config.rateModel !== undefined
     );
     if (!defaultRateModelUpdate) {
       throw new Error(`Could not find TokenConfig update for ${l1Token} at block ${blockNumber}`);
@@ -133,12 +130,12 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
   }
 
   getRouteRateModelForBlockNumber(
-    l1Token: EvmAddress,
+    l1Token: string,
     route: string,
     blockNumber: number | undefined = undefined
   ): RateModel | undefined {
     const config = (sortEventsDescending(this.cumulativeRouteRateModelUpdates) as RouteRateModelUpdate[]).find(
-      (config) => config.blockNumber <= (blockNumber ?? 0) && config.l1Token === l1Token.toEvmAddress()
+      (config) => config.blockNumber <= (blockNumber ?? 0) && config.l1Token === l1Token
     );
     if (config?.routeRateModel[route] === undefined) {
       return undefined;