@across-protocol/sdk 4.3.18 → 4.3.19-alpha.1

package/dist/types/clients/BundleDataClient/utils/SuperstructUtils.d.ts

@@ -11,68 +11,68 @@ export declare const SortableEventSS: {
 export declare const BundleDataSS: import("superstruct").Struct<{
     bundleDepositsV3: Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>;
     bundleFillsV3: Record<string, Record<string, {
         fills: {
-            depositId: BigNumber;
-            outputAmount: BigNumber;
-            inputAmount: BigNumber;
+            recipient: SvmAddress | EvmAddress | RawAddress;
+            outputToken: SvmAddress | EvmAddress | RawAddress;
             originChainId: number;
-            destinationChainId: number;
-            repaymentChainId: number;
-            messageHash: string;
-            quoteTimestamp: number;
             depositor: SvmAddress | EvmAddress | RawAddress;
-            recipient: SvmAddress | EvmAddress | RawAddress;
+            depositId: BigNumber;
             inputToken: SvmAddress | EvmAddress | RawAddress;
-            outputToken: SvmAddress | EvmAddress | RawAddress;
+            inputAmount: BigNumber;
+            outputAmount: BigNumber;
             fillDeadline: number;
             exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
             exclusivityDeadline: number;
+            destinationChainId: number;
+            repaymentChainId: number;
+            quoteTimestamp: number;
+            messageHash: string;
             blockNumber: number;
             logIndex: number;
             lpFeePct: BigNumber;
             relayer: SvmAddress | EvmAddress | RawAddress;
             relayExecutionInfo: {
-                fillType: number;
                 updatedRecipient: SvmAddress | EvmAddress | RawAddress;
                 updatedOutputAmount: BigNumber;
+                fillType: number;
                 updatedMessageHash: string;
                 updatedMessage?: string | undefined;
             };
             message?: string | undefined;
-            txnIndex?: number | undefined;
-            txnRef?: string | undefined;
             transactionHash?: string | undefined;
             transactionIndex?: number | undefined;
+            txnIndex?: number | undefined;
+            txnRef?: string | undefined;
         }[];
         refunds: Record<string, BigNumber>;
         realizedLpFees: BigNumber;
@@ -80,22 +80,22 @@ export declare const BundleDataSS: import("superstruct").Struct<{
     }>>;
     bundleSlowFillsV3: Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
@@ -103,62 +103,62 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>;
     expiredDepositsToRefundV3: Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>;
     unexecutableSlowFills: Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
@@ -166,94 +166,94 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>;
 }, {
     bundleDepositsV3: import("superstruct").Struct<Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>, null>;
     expiredDepositsToRefundV3: import("superstruct").Struct<Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>, null>;
     unexecutableSlowFills: import("superstruct").Struct<Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
@@ -261,31 +261,31 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>, null>;
     bundleSlowFillsV3: import("superstruct").Struct<Record<string, Record<string, {
         message: string;
-        depositId: BigNumber;
-        outputAmount: BigNumber;
-        inputAmount: BigNumber;
+        recipient: SvmAddress | EvmAddress | RawAddress;
+        outputToken: SvmAddress | EvmAddress | RawAddress;
         originChainId: number;
-        destinationChainId: number;
-        fromLiteChain: boolean;
-        toLiteChain: boolean;
-        messageHash: string;
-        quoteTimestamp: number;
         depositor: SvmAddress | EvmAddress | RawAddress;
-        recipient: SvmAddress | EvmAddress | RawAddress;
+        depositId: BigNumber;
         inputToken: SvmAddress | EvmAddress | RawAddress;
-        outputToken: SvmAddress | EvmAddress | RawAddress;
+        inputAmount: BigNumber;
+        outputAmount: BigNumber;
         fillDeadline: number;
         exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
         exclusivityDeadline: number;
+        destinationChainId: number;
+        quoteTimestamp: number;
+        fromLiteChain: boolean;
+        toLiteChain: boolean;
+        messageHash: string;
         blockNumber: number;
         logIndex: number;
         quoteBlockNumber: number;
@@ -293,46 +293,46 @@ export declare const BundleDataSS: import("superstruct").Struct<{
         updatedRecipient?: SvmAddress | EvmAddress | RawAddress | undefined;
         updatedOutputAmount?: BigNumber | undefined;
         updatedMessage?: string | undefined;
+        transactionHash?: string | undefined;
+        transactionIndex?: number | undefined;
         speedUpSignature?: string | undefined;
         txnIndex?: number | undefined;
         txnRef?: string | undefined;
-        transactionHash?: string | undefined;
-        transactionIndex?: number | undefined;
         relayerFeePct?: BigNumber | undefined;
     }[]>>, null>;
     bundleFillsV3: import("superstruct").Struct<Record<string, Record<string, {
         fills: {
-            depositId: BigNumber;
-            outputAmount: BigNumber;
-            inputAmount: BigNumber;
+            recipient: SvmAddress | EvmAddress | RawAddress;
+            outputToken: SvmAddress | EvmAddress | RawAddress;
             originChainId: number;
-            destinationChainId: number;
-            repaymentChainId: number;
-            messageHash: string;
-            quoteTimestamp: number;
             depositor: SvmAddress | EvmAddress | RawAddress;
-            recipient: SvmAddress | EvmAddress | RawAddress;
+            depositId: BigNumber;
             inputToken: SvmAddress | EvmAddress | RawAddress;
-            outputToken: SvmAddress | EvmAddress | RawAddress;
+            inputAmount: BigNumber;
+            outputAmount: BigNumber;
             fillDeadline: number;
             exclusiveRelayer: SvmAddress | EvmAddress | RawAddress;
             exclusivityDeadline: number;
+            destinationChainId: number;
+            repaymentChainId: number;
+            quoteTimestamp: number;
+            messageHash: string;
             blockNumber: number;
             logIndex: number;
             lpFeePct: BigNumber;
             relayer: SvmAddress | EvmAddress | RawAddress;
             relayExecutionInfo: {
-                fillType: number;
                 updatedRecipient: SvmAddress | EvmAddress | RawAddress;
                 updatedOutputAmount: BigNumber;
+                fillType: number;
                 updatedMessageHash: string;
                 updatedMessage?: string | undefined;
             };
             message?: string | undefined;
-            txnIndex?: number | undefined;
-            txnRef?: string | undefined;
             transactionHash?: string | undefined;
             transactionIndex?: number | undefined;
+            txnIndex?: number | undefined;
+            txnRef?: string | undefined;
         }[];
         refunds: Record<string, BigNumber>;
         realizedLpFees: BigNumber;

package/dist/types/relayFeeCalculator/chain-queries/svmQuery.d.ts

@@ -74,7 +74,7 @@ export declare class SvmQuery implements QueryInterface {
         recipient: SvmAddress;
         outputToken: SvmAddress;
     }, signer: TransactionSigner, repaymentChainId: number, repaymentAddress: Address): Promise<import("@solana/kit").TransactionMessageWithBlockhashLifetime & import("@solana/kit").ITransactionMessageWithFeePayerSigner<string, TransactionSigner<string>> & Omit<Readonly<{
-        instructions: readonly import("@solana/kit").IInstruction<string, readonly (import("@solana/kit").IAccountLookupMeta<string, string> | import("@solana/kit").IAccountMeta<string>)[]>[];
+        instructions: readonly import("@solana/kit").IInstruction<string, readonly (import("@solana/kit").IAccountMeta<string> | import("@solana/kit").IAccountLookupMeta<string, string>)[]>[];
         version: 0;
     }>, "feePayer">>;
     /**

package/package.json

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

package/src/arch/svm/BlockUtils.ts

@@ -5,7 +5,7 @@ import { isDefined } from "../../utils/TypeGuards";
 import { getCurrentTime } from "../../utils/TimeUtils";
 import { CHAIN_IDs } from "../../constants";
 import { SVMProvider } from "./";
-import { getTimestampForSlot } from "./SpokeUtils";
+import { getNearestSlotTime } from "./utils";
 
 interface SVMBlock extends Block {}
 
@@ -95,17 +95,9 @@ export class SVMBlockFinder extends BlockFinder<SVMBlock> {
    * immediate preceding block timestamp will be used. Note that this may return an eventually-incorrect timestamp for
    * future slots.
    */
-  private async getBlockTime(_slot?: bigint): Promise<{ slot: bigint; timestamp: number }> {
-    let timestamp: number | undefined;
-    let slot = _slot ?? (await this.provider.getSlot({ commitment: "finalized" }).send());
-
-    do {
-      timestamp = await getTimestampForSlot(this.provider, slot);
-    } while (!isDefined(timestamp) && --slot);
-    assert(isDefined(timestamp), `Unable to resolve block time for SVM slot ${_slot ?? "latest"}`);
-    assert(BigInt(Number(timestamp) === timestamp), `Unexpected SVM block timestamp: ${timestamp}`);
-
-    return { slot, timestamp: Number(timestamp) };
+  private getBlockTime(slot?: bigint): Promise<{ slot: bigint; timestamp: number }> {
+    const opts = isDefined(slot) ? { slot } : undefined;
+    return getNearestSlotTime(this.provider, opts);
   }
 
   // Grabs the most recent slot and caches it.

package/src/arch/svm/SpokeUtils.ts

@@ -65,6 +65,7 @@ import {
 import { SvmCpiEventsClient } from "./eventsClient";
 import { SVM_NO_BLOCK_AT_SLOT, isSolanaError } from "./provider";
 import { AttestedCCTPMessage, SVMEventNames, SVMProvider } from "./types";
+import { getNearestSlotTime } from "./utils";
 
 /**
  * @note: Average Solana slot duration is about 400-500ms. We can be conservative
@@ -83,9 +84,10 @@ type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> & {
  */
 export async function getTimestampForSlot(provider: SVMProvider, slotNumber: bigint): Promise<number | undefined> {
   // @note: getBlockTime receives a slot number, not a block number.
+  let _timestamp: bigint;
+
   try {
-    const blockTime = await provider.getBlockTime(slotNumber).send();
-    return Number(blockTime);
+    _timestamp = await provider.getBlockTime(slotNumber).send();
   } catch (err) {
     if (!isSolanaError(err)) {
       throw err;
@@ -98,6 +100,11 @@ export async function getTimestampForSlot(provider: SVMProvider, slotNumber: big
 
     throw err; // Unhandled Solana error.
   }
+
+  const timestamp = Number(_timestamp);
+  assert(BigInt(timestamp) === _timestamp, `Unexpected SVM block timestamp: ${_timestamp}`); // No truncation.
+
+  return timestamp;
 }
 
 /**
@@ -226,14 +233,17 @@ export async function relayFillStatus(
   const provider = svmEventsClient.getRpc();
   // Get fill status PDA using relayData
   const fillStatusPda = await getFillStatusPda(programId, relayData, destinationChainId);
-  const currentSlot = await provider.getSlot({ commitment: "confirmed" }).send();
+  let toSlot = BigInt(atHeight ?? 0);
 
   // If no specific slot is requested, try fetching the current status from the PDA
   if (atHeight === undefined) {
-    const [fillStatusAccount, currentSlotTimestamp] = await Promise.all([
-      fetchEncodedAccount(provider, fillStatusPda, { commitment: "confirmed" }),
-      getTimestampForSlot(provider, currentSlot),
+    const commitment = "confirmed";
+    const [fillStatusAccount, { slot: currentSlot, timestamp }] = await Promise.all([
+      fetchEncodedAccount(provider, fillStatusPda, { commitment }),
+      getNearestSlotTime(provider, { commitment }),
     ]);
+    toSlot = currentSlot;
+
     // If the PDA exists, return the stored fill status
     if (fillStatusAccount.exists) {
       const decodedAccountData = decodeFillStatusAccount(fillStatusAccount);
@@ -241,14 +251,12 @@ export async function relayFillStatus(
     }
     // If the PDA doesn't exist and the deadline hasn't passed yet, the deposit must be unfilled,
     // since PDAs can't be closed before the fill deadline.
-    else if (Number(currentSlotTimestamp) < relayData.fillDeadline) {
+    else if (timestamp < relayData.fillDeadline) {
       return FillStatus.Unfilled;
     }
   }
 
-  // If status couldn't be determined from the PDA, or if a specific slot was requested, reconstruct the status from events
-  const toSlot = atHeight ? BigInt(atHeight) : currentSlot;
-
+  // If status couldn't be determined from the PDA, or if a specific slot was requested, reconstruct from events.
   return resolveFillStatusFromPdaEvents(fillStatusPda, toSlot, svmEventsClient);
 }
 
@@ -816,7 +824,7 @@ export const createReceiveMessageInstruction = async (
   input: MessageTransmitterClient.ReceiveMessageInput,
   remainingAccounts: IAccountMeta<string>[]
 ) => {
-  const receiveMessageIx = await MessageTransmitterClient.getReceiveMessageInstruction(input);
+  const receiveMessageIx = MessageTransmitterClient.getReceiveMessageInstruction(input);
   (receiveMessageIx.accounts as IAccountMeta<string>[]).push(...remainingAccounts);
   return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
     appendTransactionMessageInstruction(receiveMessageIx, tx)
@@ -919,15 +927,11 @@ async function fetchBatchFillStatusFromPdaAccounts(
   relayDataArray: RelayData[]
 ): Promise<(FillStatus | undefined)[]> {
   const chunkSize = 100; // SVM method getMultipleAccounts allows a max of 100 addresses per request
-  const currentSlot = await provider.getSlot({ commitment: "confirmed" }).send();
+  const commitment = "confirmed";
 
-  const [pdaAccounts, currentSlotTimestamp] = await Promise.all([
-    Promise.all(
-      chunk(fillStatusPdas, chunkSize).map((chunk) =>
-        fetchEncodedAccounts(provider, chunk, { commitment: "confirmed" })
-      )
-    ),
-    getTimestampForSlot(provider, currentSlot),
+  const [pdaAccounts, { timestamp }] = await Promise.all([
+    Promise.all(chunk(fillStatusPdas, chunkSize).map((chunk) => fetchEncodedAccounts(provider, chunk, { commitment }))),
+    getNearestSlotTime(provider, { commitment }),
   ]);
 
   const fillStatuses = pdaAccounts.flat().map((account, index) => {
@@ -939,7 +943,7 @@ async function fetchBatchFillStatusFromPdaAccounts(
 
     // If the PDA doesn't exist and the deadline hasn't passed yet, the deposit must be unfilled,
     // since PDAs can't be closed before the fill deadline.
-    if (Number(currentSlotTimestamp) < relayDataArray[index].fillDeadline) {
+    if (timestamp < relayDataArray[index].fillDeadline) {
       return FillStatus.Unfilled;
     }
 

package/src/arch/svm/utils.ts

@@ -1,7 +1,9 @@
+import assert from "assert";
 import { MessageTransmitterClient, SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
   Address,
+  type Commitment,
   IInstruction,
   KeyPairSigner,
   address,
@@ -24,6 +26,7 @@ import { ethers } from "ethers";
 import { FillType, RelayData } from "../../interfaces";
 import { BigNumber, Address as SdkAddress, getRelayDataHash, isDefined, isUint8Array } from "../../utils";
 import { AttestedCCTPMessage, EventName, SVMEventNames, SVMProvider } from "./types";
+import { getTimestampForSlot } from "./SpokeUtils";
 
 export { isSolanaError } from "@solana/kit";
 
@@ -56,6 +59,27 @@ export function toAddress(address: SdkAddress): Address<string> {
   return address.toBase58() as Address<string>;
 }
 
+/**
+ * For a given slot (or implicit head of chain), find the immediate preceding slot that contained a block.
+ * @param provider SVM Provider instance.
+ * @param opts An object containing a specific slot number, or a Solana commitment, defaulting to "confirmed".
+ * @returns An object containing the slot number and the relevant timestamp for the block.
+ */
+export async function getNearestSlotTime(
+  provider: SVMProvider,
+  opts: { slot: bigint } | { commitment: Commitment } = { commitment: "confirmed" }
+): Promise<{ slot: bigint; timestamp: number }> {
+  let timestamp: number | undefined;
+  let slot = "slot" in opts ? opts.slot : await provider.getSlot(opts).send();
+
+  do {
+    timestamp = await getTimestampForSlot(provider, slot);
+  } while (!isDefined(timestamp) && --slot);
+  assert(isDefined(timestamp), `Unable to resolve block time for SVM slot ${slot}`);
+
+  return { slot, timestamp };
+}
+
 /**
  * Resolve the latest finalized slot, and then work backwards to find the nearest slot containing a block.
  * In most cases the first-resolved slot should also have a block. Avoid making arbitrary decisions about