@across-protocol/sdk 4.1.63-beta.0 → 4.1.63-beta.1

package/src/arch/svm/SpokeUtils.ts

@@ -1,38 +1,41 @@
-import {
-  SvmAddress,
-  getTokenInfo,
-  BigNumber,
-  isDefined,
-  isUnsafeDepositId,
-  toAddressType,
-  toBN,
-  getMessageHash,
-  keccak256,
-  chainIsSvm,
-  chunk,
-} from "../../utils";
 import { SvmSpokeClient } from "@across-protocol/contracts";
-import { getStatePda, SvmCpiEventsClient, getFillStatusPda, unwrapEventData, getEventAuthority } from "./";
-import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import { decodeFillStatusAccount, fetchState } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
+import { hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import {
-  TOKEN_PROGRAM_ADDRESS,
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  TOKEN_PROGRAM_ADDRESS,
   getApproveCheckedInstruction,
 } from "@solana-program/token";
 import {
   Address,
-  some,
   address,
-  getProgramDerivedAddress,
-  fetchEncodedAccounts,
   fetchEncodedAccount,
+  fetchEncodedAccounts,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  getU32Encoder,
+  getU64Encoder,
+  some,
   type TransactionSigner,
 } from "@solana/kit";
 import assert from "assert";
+import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
-import { fetchState, decodeFillStatusAccount } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
-import { SVMEventNames, SVMProvider } from "./types";
 import { CHAIN_IDs } from "../../constants";
+import { Deposit, FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import {
+  BigNumber,
+  SvmAddress,
+  chainIsSvm,
+  chunk,
+  getTokenInfo,
+  isDefined,
+  isUnsafeDepositId,
+  keccak256,
+  toAddressType,
+} from "../../utils";
+import { SvmCpiEventsClient, getEventAuthority, getFillStatusPda, getStatePda, unwrapEventData } from "./";
+import { SVMEventNames, SVMProvider } from "./types";
 
 /**
  * @param spokePool SpokePool Contract instance.
@@ -412,29 +415,26 @@ export async function getAssociatedTokenAddress(
 }
 
 export function getRelayDataHash(relayData: RelayData, destinationChainId: number): string {
-  const toBuffer = (hex: string, byteLength: number, littleEndian: boolean = true) => {
-    const buffer = Buffer.from(hex.slice(2), "hex");
-    if (buffer.length < byteLength) {
-      const zeroPad = Buffer.alloc(byteLength);
-      buffer.copy(zeroPad, byteLength - buffer.length);
-      return littleEndian ? zeroPad.reverse() : zeroPad;
-    }
-    return littleEndian ? buffer.slice(0, byteLength).reverse() : buffer.slice(0, byteLength);
-  };
+  const addressEncoder = getAddressEncoder();
+  const uint64Encoder = getU64Encoder();
+  const uint32Encoder = getU32Encoder();
+
+  assert(relayData.message.startsWith("0x"), "Message must be a hex string");
+
   const contentToHash = Buffer.concat([
-    toBuffer(relayData.depositor, 32, false),
-    toBuffer(relayData.recipient, 32, false),
-    toBuffer(relayData.exclusiveRelayer, 32, false),
-    toBuffer(relayData.inputToken, 32, false),
-    toBuffer(relayData.outputToken, 32, false),
-    toBuffer(relayData.inputAmount.toHexString(), 8),
-    toBuffer(relayData.outputAmount.toHexString(), 8),
-    toBuffer(toBN(relayData.originChainId).toHexString(), 8),
-    toBuffer(relayData.depositId.toHexString(), 32, false),
-    toBuffer(toBN(relayData.fillDeadline).toHexString(), 4),
-    toBuffer(toBN(relayData.exclusivityDeadline).toHexString(), 4),
-    toBuffer(getMessageHash(relayData.message), 32, false),
-    toBuffer(toBN(destinationChainId).toHexString(), 8),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.depositor, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.recipient, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.exclusiveRelayer, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.inputToken, "base16").toV2Address())),
+    Uint8Array.from(addressEncoder.encode(SvmAddress.from(relayData.outputToken, "base16").toV2Address())),
+    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.inputAmount.toString()))),
+    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.outputAmount.toString()))),
+    Uint8Array.from(uint64Encoder.encode(BigInt(relayData.originChainId.toString()))),
+    arrayify(hexZeroPad(hexlify(relayData.depositId), 32)),
+    Uint8Array.from(uint32Encoder.encode(relayData.fillDeadline)),
+    Uint8Array.from(uint32Encoder.encode(relayData.exclusivityDeadline)),
+    hashNonEmptyMessage(Buffer.from(arrayify(relayData.message))),
+    Uint8Array.from(uint64Encoder.encode(BigInt(destinationChainId))),
   ]);
   return keccak256(contentToHash);
 }

package/src/arch/svm/constants.ts

@@ -1 +1,2 @@
+export { SYSTEM_PROGRAM_ADDRESS as SVM_DEFAULT_ADDRESS } from "@solana-program/system";
 export const SVM_SPOKE_SEED = BigInt(0);

package/src/arch/svm/eventsClient.ts

@@ -2,9 +2,16 @@ import { Idl } from "@coral-xyz/anchor";
 import { getDeployedAddress, SvmSpokeIdl } from "@across-protocol/contracts";
 import { getSolanaChainId } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import web3, { Address, Commitment, GetSignaturesForAddressApi, GetTransactionApi, Signature } from "@solana/kit";
-import { bs58 } from "../../utils";
+import { bs58, chainIsSvm, getMessageHash } from "../../utils";
 import { EventName, EventWithData, SVMProvider } from "./types";
 import { decodeEvent, isDevnet } from "./utils";
+import { DepositWithTime, FillWithTime } from "../../interfaces";
+import { unwrapEventData } from "./";
+import assert from "assert";
+import {
+  FundsDepositedEventObject,
+  FilledRelayEventObject,
+} from "@across-protocol/contracts/dist/typechain/contracts/SpokePool";
 
 // Utility type to extract the return type for the JSON encoding overload. We only care about the overload where the
 // configuration parameter (C) has the optional property 'encoding' set to 'json'.
@@ -19,6 +26,9 @@ type GetSignaturesForAddressConfig = Parameters<GetSignaturesForAddressApi["getS
 type GetSignaturesForAddressTransaction = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>[number];
 type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
 
+export type DepositEventFromSignature = Omit<DepositWithTime, "fromLiteChain" | "toLiteChain">;
+export type FillEventFromSignature = FillWithTime;
+
 export class SvmCpiEventsClient {
   private rpc: SVMProvider;
   private programAddress: Address;
@@ -211,6 +221,109 @@ export class SvmCpiEventsClient {
     return events;
   }
 
+  /**
+   * Finds all FundsDeposited events for a given transaction signature.
+   *
+   * @param originChainId - The chain ID where the deposit originated.
+   * @param txSignature - The transaction signature to search for events.
+   * @param commitment - Optional commitment level for the transaction query.
+   * @returns A promise that resolves to an array of deposit events for the transaction, or undefined if none found.
+   */
+  public async getDepositEventsFromSignature(
+    originChainId: number,
+    txSignature: Signature,
+    commitment: Commitment = "confirmed"
+  ): Promise<DepositEventFromSignature[] | undefined> {
+    assert(chainIsSvm(originChainId), `Origin chain ${originChainId} is not an SVM chain`);
+
+    const [events, txDetails] = await Promise.all([
+      this.readEventsFromSignature(txSignature, commitment),
+      this.rpc
+        .getTransaction(txSignature, {
+          commitment,
+          maxSupportedTransactionVersion: 0,
+        })
+        .send(),
+    ]);
+
+    // Filter for FundsDeposited events only
+    const depositEvents = events?.filter((event) => event?.name === "FundsDeposited");
+
+    if (!txDetails || !depositEvents?.length) {
+      return;
+    }
+
+    return events.map((event) => {
+      const unwrappedEventArgs = unwrapEventData(event as Record<string, unknown>, ["depositId"]) as Record<
+        "data",
+        FundsDepositedEventObject
+      >;
+
+      return {
+        ...unwrappedEventArgs.data,
+        depositTimestamp: Number(txDetails.blockTime),
+        originChainId,
+        messageHash: getMessageHash(unwrappedEventArgs.data.message),
+        blockNumber: Number(txDetails.slot),
+        txnIndex: 0,
+        txnRef: txSignature,
+        logIndex: 0,
+        destinationChainId: unwrappedEventArgs.data.destinationChainId.toNumber(),
+      } satisfies DepositEventFromSignature;
+    });
+  }
+
+  /**
+   * Finds all FilledRelay events for a given transaction signature.
+   *
+   * @param destinationChainId - The destination chain ID (must be an SVM chain).
+   * @param txSignature - The transaction signature to search for events.
+   * @returns A promise that resolves to an array of fill events for the transaction, or undefined if none found.
+   */
+  public async getFillEventsFromSignature(
+    destinationChainId: number,
+    txSignature: Signature,
+    commitment: Commitment = "confirmed"
+  ): Promise<FillEventFromSignature[] | undefined> {
+    assert(chainIsSvm(destinationChainId), `Destination chain ${destinationChainId} is not an SVM chain`);
+
+    // Find all events from the transaction signature and get transaction details
+    const [events, txDetails] = await Promise.all([
+      this.readEventsFromSignature(txSignature, commitment),
+      this.rpc
+        .getTransaction(txSignature, {
+          commitment,
+          maxSupportedTransactionVersion: 0,
+        })
+        .send(),
+    ]);
+
+    // Filter for FilledRelay events only
+    const fillEvents = events?.filter((event) => event?.name === "FilledRelay");
+
+    if (!txDetails || !fillEvents?.length) {
+      return;
+    }
+
+    return fillEvents.map((event) => {
+      const unwrappedEventData = unwrapEventData(event as Record<string, unknown>) as Record<
+        "data",
+        FilledRelayEventObject
+      >;
+      return {
+        ...unwrappedEventData.data,
+        fillTimestamp: Number(txDetails.blockTime),
+        blockNumber: Number(txDetails.slot),
+        txnRef: txSignature,
+        txnIndex: 0,
+        logIndex: 0,
+        destinationChainId,
+        repaymentChainId: unwrappedEventData.data.repaymentChainId.toNumber(),
+        originChainId: unwrappedEventData.data.originChainId.toNumber(),
+      } satisfies FillEventFromSignature;
+    });
+  }
+
   public getProgramAddress(): Address {
     return this.programAddress;
   }

package/src/arch/svm/utils.ts

@@ -1,16 +1,16 @@
+import { SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
+  Address,
   address,
+  getAddressEncoder,
   getProgramDerivedAddress,
   getU64Encoder,
-  getAddressEncoder,
-  Address,
   isAddress,
   type TransactionSigner,
 } from "@solana/kit";
-import { BigNumber, getRelayDataHash, isUint8Array, SvmAddress } from "../../utils";
-import { SvmSpokeClient } from "@across-protocol/contracts";
 import { FillType, RelayData } from "../../interfaces";
+import { BigNumber, SvmAddress, getRelayDataHash, isUint8Array } from "../../utils";
 import { EventName, SVMEventNames, SVMProvider } from "./types";
 
 /**

package/src/interfaces/SpokePool.ts

@@ -37,6 +37,10 @@ export interface DepositWithBlock extends Deposit, SortableEvent {
   quoteBlockNumber: number;
 }
 
+export interface DepositWithTime extends Deposit, SortableEvent {
+  depositTimestamp: number;
+}
+
 export enum FillStatus {
   Unfilled = 0,
   RequestedSlowFill,
@@ -66,6 +70,9 @@ export interface Fill extends Omit<RelayData, "message"> {
 }
 
 export interface FillWithBlock extends Fill, SortableEvent {}
+export interface FillWithTime extends Fill, SortableEvent {
+  fillTimestamp: number;
+}
 
 export interface EnabledDepositRoute {
   originToken: string;

package/src/utils/SpokeUtils.ts

@@ -1,4 +1,4 @@
-import { encodeAbiParameters, keccak256 } from "viem";
+import { encodeAbiParameters, Hex, keccak256 } from "viem";
 import { MAX_SAFE_DEPOSIT_ID, ZERO_ADDRESS, ZERO_BYTES } from "../constants";
 import { Deposit, RelayData } from "../interfaces";
 import { toBytes32 } from "./AddressUtils";
@@ -91,5 +91,5 @@ export function isZeroAddress(address: string): boolean {
 }
 
 export function getMessageHash(message: string): string {
-  return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as "0x{string}");
+  return isMessageEmpty(message) ? ZERO_BYTES : keccak256(message as Hex);
 }