@across-protocol/sdk 4.3.19 → 4.3.22

package/src/providers/solana/retryRpcFactory.ts

@@ -0,0 +1,97 @@
+import { RpcTransport } from "@solana/kit";
+import { SolanaClusterRpcFactory } from "./baseRpcFactories";
+import { RateLimitedSolanaRpcFactory } from "./rateLimitedRpcFactory";
+import { delay } from "../../utils";
+import { getOriginFromURL } from "../../utils/NetworkUtils";
+import { Logger } from "winston";
+
+// This factory adds retry logic on top of the RateLimitedSolanaRpcFactory.
+// It follows the same composition pattern as other factories in this module.
+export class RetrySolanaRpcFactory extends SolanaClusterRpcFactory {
+  // Holds the underlying transport that the retry wrapper wraps.
+  protected rateLimitedTransport: RpcTransport;
+
+  protected logger: Logger;
+
+  constructor(
+    readonly retries: number,
+    readonly retryDelaySeconds: number,
+    ...rateLimitedConstructorParams: ConstructorParameters<typeof RateLimitedSolanaRpcFactory>
+  ) {
+    // SolanaClusterRpcFactory shares the last two constructor parameters with RateLimitedSolanaRpcFactory.
+    const superParams = rateLimitedConstructorParams.slice(-2) as [
+      ConstructorParameters<typeof SolanaClusterRpcFactory>[0], // clusterUrl: ClusterUrl
+      ConstructorParameters<typeof SolanaClusterRpcFactory>[1], // chainId: number
+    ];
+    super(...superParams);
+
+    // Validate retry configuration
+    if (this.retries < 0 || !Number.isInteger(this.retries)) {
+      throw new Error(`retries cannot be < 0 and must be an integer. Currently set to ${this.retries}`);
+    }
+    if (this.retryDelaySeconds < 0) {
+      throw new Error(`retryDelaySeconds cannot be < 0. Currently set to ${this.retryDelaySeconds}`);
+    }
+
+    // Create the rate limited transport.
+    const rateLimitedRpcFactory = new RateLimitedSolanaRpcFactory(...rateLimitedConstructorParams);
+    this.rateLimitedTransport = rateLimitedRpcFactory.createTransport();
+    this.logger = rateLimitedRpcFactory.logger;
+  }
+
+  public createTransport(): RpcTransport {
+    return <TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> => {
+      return this._tryCall(() => this.rateLimitedTransport<TResponse>(...args), args);
+    };
+  }
+
+  /**
+   * Retry wrapper for transport calls with Solana-specific error handling.
+   * @param transportCall Function that makes the transport call
+   * @param args Original transport arguments for logging
+   * @returns Promise that resolves to the transport response
+   */
+  private async _tryCall<TResponse>(
+    transportCall: () => Promise<TResponse>,
+    args: Parameters<RpcTransport>
+  ): Promise<TResponse> {
+    const { method } = args[0].payload as { method: string; params?: unknown[] };
+    let retries = this.retries;
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        return await transportCall();
+      } catch (error) {
+        if (retries-- <= 0 || this.shouldFailImmediate(method, error)) {
+          throw error;
+        }
+
+        // Log retry attempt if logger is available
+        this.logger.debug({
+          at: "RetryRpcFactory",
+          message: "Retrying Solana RPC call",
+          provider: getOriginFromURL(this.clusterUrl),
+          method,
+          retryAttempt: this.retries - retries,
+          retryDelaySeconds: this.retryDelaySeconds,
+          error: error?.toString(),
+        });
+
+        await delay(this.retryDelaySeconds);
+      }
+    }
+  }
+
+  /**
+   * Determine whether a Solana RPC error indicates an unrecoverable error that should not be retried.
+   * @param method RPC method name
+   * @param error Error object from the RPC call
+   * @returns True if the request should be aborted immediately, otherwise false
+   */
+  private shouldFailImmediate(_method: string, _error: unknown): boolean {
+    // TODO: Decide which Solana RPC errors should be considered non-transitory and should not be retried.
+    // For now, retry all errors.
+    return false;
+  }
+}

package/src/providers/utils.ts

@@ -96,14 +96,17 @@ const IGNORED_FIELDS = {
   // 2023-08-31 Added blockHash because of upstream zkSync provider disagreements. Consider removing later.
   // 2024-05-07 Added l1BatchNumber and logType due to Alchemy. Consider removing later.
   // 2024-07-11 Added blockTimestamp after zkSync rolled out a new node release.
+  // 2025-07-24 Added additional fields returned by Chainstack on (at least) Polygon.
   eth_getBlockByNumber: [
     "miner", // polygon (sometimes)
     "l1BatchNumber", // zkSync
     "l1BatchTimestamp", // zkSync
+    "requestsHash", // Chainstack (Polygon)
     "size", // Alchemy/Arbitrum (temporary)
     "totalDifficulty", // Quicknode/Alchemy (sometimes)
     "logsBloom", // zkSync (third-party providers return 0x0..0)
     "transactions", // Polygon yParity field in transactions[]
+    "withdrawals", // Chainstack (Polygon)
   ],
   eth_getLogs: ["blockTimestamp", "transactionLogIndex", "l1BatchNumber", "logType"],
 };

package/src/utils/BigNumberUtils.ts

@@ -19,6 +19,12 @@ export const bnOne = BigNumber.from("1");
 export const bnUint32Max = BigNumber.from("0xffffffff");
 export const bnUint256Max = BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 
+/**
+ * BigInt min/max helpers.
+ */
+export const biMin = (a: bigint, b: bigint) => (a > b ? b : a);
+export const biMax = (a: bigint, b: bigint) => (a > b ? a : b);
+
 /**
  * Converts a stringified number into a BigNumber with 18 decimal places.
  * @param num The number to parse.

package/src/utils/DepositUtils.ts

@@ -265,7 +265,7 @@ export function resolveDepositMessage(deposit: Deposit): string {
  * Converts a RelayData object with `Address` types as address fields to a `RelayData`-like object with
  * strings as address fields.
  * @param relayData RelayData type.
- * @returns a RelayData-like type which has strings as fields.
+ * @returns a RelayData-like type which has hex 32 byte strings as fields.
  */
 export function convertRelayDataParamsToBytes32(relayData: RelayData): ConvertedRelayData {
   return {
@@ -282,7 +282,7 @@ export function convertRelayDataParamsToBytes32(relayData: RelayData): Converted
  * Converts a Fill object with `Address` types as address fields to a `RelayData`-like object with
  * strings as address fields.
  * @param relayData RelayData type.
- * @returns a RelayData-like type which has strings as fields.
+ * @returns a RelayData-like type which has hex 32 byte strings as fields.
  */
 export function convertFillParamsToBytes32(fill: Fill): ConvertedFill {
   return {
@@ -299,3 +299,42 @@ export function convertFillParamsToBytes32(fill: Fill): ConvertedFill {
     },
   };
 }
+
+/**
+ * Converts a RelayData object with `Address` types as address fields to a `RelayData`-like object with
+ * strings as address fields.
+ * @param relayData RelayData type.
+ * @returns a RelayData-like type which has native address representation strings as fields.
+ */
+export function convertRelayDataParamsToNative(relayData: RelayData): ConvertedRelayData {
+  return {
+    ...relayData,
+    depositor: relayData.depositor.toNative(),
+    recipient: relayData.recipient.toNative(),
+    inputToken: relayData.inputToken.toNative(),
+    outputToken: relayData.outputToken.toNative(),
+    exclusiveRelayer: relayData.exclusiveRelayer.toNative(),
+  };
+}
+
+/**
+ * Converts a Fill object with `Address` types as address fields to a `RelayData`-like object with
+ * strings as address fields.
+ * @param relayData RelayData type.
+ * @returns a RelayData-like type which has native address representation strings as fields.
+ */
+export function convertFillParamsToNative(fill: Fill): ConvertedFill {
+  return {
+    ...fill,
+    depositor: fill.depositor.toNative(),
+    recipient: fill.recipient.toNative(),
+    inputToken: fill.inputToken.toNative(),
+    outputToken: fill.outputToken.toNative(),
+    exclusiveRelayer: fill.exclusiveRelayer.toNative(),
+    relayer: fill.relayer.toNative(),
+    relayExecutionInfo: {
+      ...fill.relayExecutionInfo,
+      updatedRecipient: fill.relayExecutionInfo.updatedRecipient.toNative(),
+    },
+  };
+}

package/src/utils/TokenUtils.ts

@@ -58,12 +58,12 @@ export function resolveSymbolOnChain(chainId: number, symbol: string): TokenInfo
  */
 export const resolveContractFromSymbol = (
   symbol: string,
-  chainId: string,
+  chainId: number,
   tokenMapping = TOKEN_SYMBOLS_MAP
 ): string | undefined => {
   return Object.values(tokenMapping).find((details) => {
     return details.symbol.toLowerCase() === symbol.toLowerCase();
-  })?.addresses[Number(chainId)];
+  })?.addresses[chainId];
 };
 
 export function getCoingeckoTokenIdByAddress(address: string, chainId: number): string {