@across-protocol/sdk 4.3.40 → 4.3.42

package/src/arch/svm/SpokeUtils.ts

@@ -89,21 +89,21 @@ type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> & {
   outputToken: SvmAddress;
 };
 
-export function getSlot(provider: SVMProvider, commitment: Commitment, logger: winston.Logger): Promise<bigint> {
+export function getSlot(provider: SVMProvider, commitment: Commitment, logger?: winston.Logger): Promise<bigint> {
   return _callGetSlotWithRetry(provider, commitment, logger);
 }
 
 async function _callGetSlotWithRetry(
   provider: SVMProvider,
   commitment: Commitment,
-  logger: winston.Logger
+  logger?: winston.Logger
 ): Promise<bigint> {
   try {
     return await provider.getSlot({ commitment }).send();
   } catch (err) {
     if (isSolanaError(err)) {
       const { __code: code } = err.context;
-      logger.debug({
+      logger?.debug({
         at: "_getSlotWithRetry",
         message: "Caught error from getSlot()",
         code,
@@ -122,8 +122,8 @@ async function _callGetSlotWithRetry(
 export function getTimestampForSlot(
   provider: SVMProvider,
   slotNumber: bigint,
-  logger: winston.Logger,
-  maxRetries = 2
+  maxRetries = 2,
+  logger?: winston.Logger
 ): Promise<number | undefined> {
   return _callGetTimestampForSlotWithRetry(provider, slotNumber, 0, maxRetries, logger);
 }
@@ -133,7 +133,7 @@ async function _callGetTimestampForSlotWithRetry(
   slotNumber: bigint,
   retryAttempt: number,
   maxRetries: number,
-  logger: winston.Logger
+  logger?: winston.Logger
 ): Promise<number | undefined> {
   // @note: getBlockTime receives a slot number, not a block number.
   let _timestamp: bigint;
@@ -159,7 +159,7 @@ async function _callGetTimestampForSlotWithRetry(
         if (retryAttempt >= maxRetries) {
           throw new Error(`Timeout on SVM getBlockTime() for slot ${slot} after ${retryAttempt} retry attempts`);
         }
-        logger.debug({
+        logger?.debug({
           at: "getTimestampForSlot",
           message: `Retrying getBlockTime() after ${delaySeconds} seconds for retry attempt #${retryAttempt}`,
           slot,
@@ -172,7 +172,7 @@ async function _callGetTimestampForSlotWithRetry(
       }
 
       default:
-        logger.debug({
+        logger?.debug({
           at: "getTimestampForSlot",
           message: "Caught error from getBlockTime()",
           errorCode: code,
@@ -253,7 +253,8 @@ export async function findDeposit(
   }
 
   const provider = eventClient.getRpc();
-  const { slot: currentSlot } = await getNearestSlotTime(provider, logger);
+  const opts = undefined;
+  const { slot: currentSlot } = await getNearestSlotTime(provider, opts, logger);
 
   // If no slot is provided, use the current slot
   // If a slot is provided, ensure it's not in the future
@@ -325,7 +326,7 @@ export async function relayFillStatus(
     const commitment = "confirmed";
     const [fillStatusAccount, { slot: currentSlot, timestamp }] = await Promise.all([
       fetchEncodedAccount(provider, fillStatusPda, { commitment }),
-      getNearestSlotTime(provider, logger, { commitment }),
+      getNearestSlotTime(provider, { commitment }, logger),
     ]);
     toSlot = currentSlot;
 
@@ -407,7 +408,8 @@ export async function fillStatusArray(
   const missingResults: { index: number; fillStatus: FillStatus }[] = [];
 
   // Determine the toSlot to use for event reconstruction
-  const toSlot = atHeight ? BigInt(atHeight) : (await getNearestSlotTime(provider, logger)).slot;
+  const opts = undefined;
+  const toSlot = atHeight ? BigInt(atHeight) : (await getNearestSlotTime(provider, opts, logger)).slot;
 
   // @note: This path is mostly used for deposits past their fill deadline.
   // If it becomes a bottleneck, consider returning an "Unknown" status that can be handled downstream.
@@ -445,12 +447,13 @@ export async function findFillEvent(
   relayData: RelayData,
   destinationChainId: number,
   svmEventsClient: SvmCpiEventsClient,
-  logger: winston.Logger,
   fromSlot: number,
-  toSlot?: number
+  toSlot?: number,
+  logger?: winston.Logger
 ): Promise<FillWithBlock | undefined> {
   assert(chainIsSvm(destinationChainId), "Destination chain must be an SVM chain");
-  toSlot ??= Number((await getNearestSlotTime(svmEventsClient.getRpc(), logger)).slot);
+  const opts = undefined;
+  toSlot ??= Number((await getNearestSlotTime(svmEventsClient.getRpc(), opts, logger)).slot);
 
   // Get fillStatus PDA using relayData
   const programId = svmEventsClient.getProgramAddress();
@@ -931,7 +934,7 @@ async function fetchBatchFillStatusFromPdaAccounts(
 
   const [pdaAccounts, { timestamp }] = await Promise.all([
     Promise.all(chunk(fillStatusPdas, chunkSize).map((chunk) => fetchEncodedAccounts(provider, chunk, { commitment }))),
-    getNearestSlotTime(provider, logger, { commitment }),
+    getNearestSlotTime(provider, { commitment }, logger),
   ]);
 
   const fillStatuses = pdaAccounts.flat().map((account, index) => {

package/src/arch/svm/utils.ts

@@ -68,14 +68,15 @@ export function toAddress(address: SdkAddress): Address<string> {
  */
 export async function getNearestSlotTime(
   provider: SVMProvider,
-  logger: winston.Logger,
-  opts: { slot: bigint } | { commitment: Commitment } = { commitment: "confirmed" }
+  opts: { slot: bigint } | { commitment: Commitment } = { commitment: "confirmed" },
+  logger?: winston.Logger
 ): Promise<{ slot: bigint; timestamp: number }> {
   let timestamp: number | undefined;
   let slot = "slot" in opts ? opts.slot : await getSlot(provider, opts.commitment, logger);
+  const maxRetries = undefined; // Inherit defaults
 
   do {
-    timestamp = await getTimestampForSlot(provider, slot, logger);
+    timestamp = await getTimestampForSlot(provider, slot, maxRetries, logger);
   } while (!isDefined(timestamp) && --slot);
   assert(isDefined(timestamp), `Unable to resolve block time for SVM slot ${slot}`);
 
@@ -94,7 +95,7 @@ export async function getLatestFinalizedSlotWithBlock(
   maxLookback = 1000
 ): Promise<number> {
   const opts = { maxSupportedTransactionVersion: 0, transactionDetails: "none", rewards: false } as const;
-  const { slot: finalizedSlot } = await getNearestSlotTime(provider, logger, { commitment: "finalized" });
+  const { slot: finalizedSlot } = await getNearestSlotTime(provider, { commitment: "finalized" }, logger);
   const endSlot = biMin(maxSlot, finalizedSlot);
 
   let slot = endSlot;

package/src/clients/BaseAbstractClient.ts

@@ -89,7 +89,8 @@ export abstract class BaseAbstractClient {
         throw new Error(`Invalid event search config from (${from}) > to (${to})`);
       }
     } else {
-      const { slot } = await getNearestSlotTime(provider, logger);
+      const opts = undefined; // Inherit defaults
+      const { slot } = await getNearestSlotTime(provider, opts, logger);
       to = Number(slot);
       if (to < from) {
         return UpdateFailureReason.AlreadyUpdated;

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -1651,9 +1651,9 @@ export class BundleDataClient {
         deposit,
         spokePoolClient.chainId,
         spokePoolClient.svmEventsClient,
-        spokePoolClient.logger,
         spokePoolClient.deploymentBlock,
-        spokePoolClient.latestHeightSearched
+        spokePoolClient.latestHeightSearched,
+        spokePoolClient.logger
       );
     } else if (isEVMSpokePoolClient(spokePoolClient)) {
       return await findEvmFillEvent(

package/src/clients/SpokePoolClient/SVMSpokePoolClient.ts

@@ -194,8 +194,9 @@ export class SVMSpokePoolClient extends SpokePoolClient {
    */
   public override async getTimestampForBlock(slot: number): Promise<number> {
     let _slot = BigInt(slot);
+    const maxRetries = undefined; // Inherit defaults
     do {
-      const timestamp = await getTimestampForSlot(this.svmEventsClient.getRpc(), _slot, this.logger);
+      const timestamp = await getTimestampForSlot(this.svmEventsClient.getRpc(), _slot, maxRetries, this.logger);
       if (isDefined(timestamp)) {
         return timestamp;
       }