@across-protocol/sdk 3.1.30 → 3.1.32

package/src/providers/index.ts

@@ -1,6 +1,7 @@
 export * from "./rateLimitedProvider";
 export * from "./cachedProvider";
 export * from "./retryProvider";
+export * from "./speedProvider";
 export * from "./constants";
 export * from "./types";
 export * from "./utils";

package/src/providers/retryProvider.ts

@@ -41,6 +41,18 @@ export class RetryProvider extends ethers.providers.StaticJsonRpcProvider {
           ...inputs
         )
     );
+
+    // This is added for interim testing to see whether relayer fill performance improves.
+    this.providers.forEach((provider) => {
+      const url = getOriginFromURL(provider.connection.url);
+      const { pollingInterval } = provider;
+      provider.pollingInterval = 1000;
+      logger?.debug({
+        at: "RetryProvider",
+        message: `Dropped ${url} pollingInterval ${pollingInterval} -> ${provider.pollingInterval}.`,
+      });
+    });
+
     if (this.nodeQuorumThreshold < 1 || !Number.isInteger(this.nodeQuorumThreshold)) {
       throw new Error(
         `nodeQuorum,Threshold cannot be < 1 and must be an integer. Currently set to ${this.nodeQuorumThreshold}`

package/src/providers/speedProvider.ts

@@ -0,0 +1,63 @@
+import { ethers } from "ethers";
+import { CachingMechanismInterface } from "../interfaces";
+import { CacheProvider } from "./cachedProvider";
+import { formatProviderError } from "./utils";
+import { PROVIDER_CACHE_TTL } from "./constants";
+import { Logger } from "winston";
+
+/**
+ * RPC provider that sends requests to multiple providers in parallel and returns the fastest response.
+ */
+export class SpeedProvider extends ethers.providers.StaticJsonRpcProvider {
+  readonly providers: ethers.providers.StaticJsonRpcProvider[];
+
+  constructor(
+    params: ConstructorParameters<typeof ethers.providers.StaticJsonRpcProvider>[],
+    chainId: number,
+    readonly maxConcurrencySpeed: number,
+    readonly maxConcurrencyRateLimit: number,
+    providerCacheNamespace: string,
+    pctRpcCallsLogged: number,
+    redisClient?: CachingMechanismInterface,
+    standardTtlBlockDistance?: number,
+    noTtlBlockDistance?: number,
+    providerCacheTtl = PROVIDER_CACHE_TTL,
+    logger?: Logger
+  ) {
+    // Initialize the super just with the chainId, which stops it from trying to immediately send out a .send before
+    // this derived class is initialized.
+    super(undefined, chainId);
+    this.providers = params.map(
+      (inputs) =>
+        new CacheProvider(
+          providerCacheNamespace,
+          redisClient,
+          standardTtlBlockDistance,
+          noTtlBlockDistance,
+          providerCacheTtl,
+          maxConcurrencyRateLimit,
+          pctRpcCallsLogged,
+          logger,
+          ...inputs
+        )
+    );
+  }
+
+  override async send(method: string, params: Array<unknown>): Promise<unknown> {
+    try {
+      const providersToUse = this.providers.slice(0, this.maxConcurrencySpeed);
+      const result = await Promise.any(providersToUse.map((provider) => provider.send(method, params)));
+      return result;
+    } catch (error) {
+      // Only thrown if all providers failed to respond
+      if (error instanceof AggregateError) {
+        const errors = error.errors.map((error, index) => {
+          const provider = this.providers[index];
+          return formatProviderError(provider, error.message);
+        });
+        throw new Error("All providers errored:\n" + errors.join("\n"));
+      }
+      throw error;
+    }
+  }
+}

package/src/providers/utils.ts

@@ -102,6 +102,8 @@ const IGNORED_FIELDS = {
     "l1BatchTimestamp", // zkSync
     "size", // Alchemy/Arbitrum (temporary)
     "totalDifficulty", // Quicknode/Alchemy (sometimes)
+    "logsBloom", // zkSync (third-party providers return 0x0..0)
+    "transactions", // Polygon yParity field in transactions[]
   ],
   eth_getLogs: ["blockTimestamp", "transactionLogIndex", "l1BatchNumber", "logType"],
 };

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -59,14 +59,14 @@ export class QueryBase implements QueryInterface {
    * @param deposit V3 deposit instance.
    * @param relayerAddress Relayer address to simulate with.
    * @param gasPrice Optional gas price to use for the simulation.
-   * @param gasLimit Optional gas limit to use for the simulation.
+   * @param gasUnits Optional gas units to use for the simulation.
    * @returns The gas estimate for this function call (multiplied with the optional buffer).
    */
   async getGasCosts(
     deposit: Deposit,
     relayer = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     gasPrice = this.fixedGasPrice,
-    gasLimit?: BigNumberish
+    gasUnits?: BigNumberish
   ): Promise<TransactionCostEstimate> {
     const tx = await populateV3Relay(this.spokePool, deposit, relayer);
     return estimateTotalGasRequiredByUnsignedTransaction(
@@ -75,7 +75,7 @@ export class QueryBase implements QueryInterface {
       this.provider,
       this.gasMarkup,
       gasPrice,
-      gasLimit
+      gasUnits
     );
   }
 

package/src/relayFeeCalculator/relayFeeCalculator.ts

@@ -342,6 +342,8 @@ export class RelayFeeCalculator {
    *       the relayer.
    * @param relayerAddress The relayer that will be used for the gas cost simulation
    * @param _tokenPrice The token price for normalizing fees
+   * @param gasPrice Optional gas price to use for the simulation
+   * @param gasUnits Optional gas units to use for the simulation
    * @returns A resulting `RelayerFeeDetails` object
    */
   async relayerFeeDetails(
@@ -351,7 +353,7 @@ export class RelayFeeCalculator {
     relayerAddress = DEFAULT_SIMULATED_RELAYER_ADDRESS,
     _tokenPrice?: number,
     gasPrice?: BigNumberish,
-    gasLimit?: BigNumberish
+    gasUnits?: BigNumberish
   ): Promise<RelayerFeeDetails> {
     // If the amount to relay is not provided, then we
     // should use the full deposit amount.
@@ -370,7 +372,7 @@ export class RelayFeeCalculator {
       _tokenPrice,
       undefined,
       gasPrice,
-      gasLimit
+      gasUnits
     );
     const gasFeeTotal = gasFeePercent.mul(amountToRelay).div(fixedPointAdjustment);
     const capitalFeePercent = this.capitalFeePercent(

package/src/utils/common.ts

@@ -242,7 +242,7 @@ export type TransactionCostEstimate = {
  * @param provider A valid ethers provider - will be used to reason the gas price.
  * @param gasMarkup Markup on the estimated gas cost. For example, 0.2 will increase this resulting value 1.2x.
  * @param gasPrice A manually provided gas price - if set, this function will not resolve the current gas price.
- * @param gasLimit A manually provided gas limit - if set, this function will not estimate the gas limit.
+ * @param gasUnits A manually provided gas units - if set, this function will not estimate the gas units.
  * @returns Estimated cost in units of gas and the underlying gas token (gasPrice * estimatedGasUnits).
  */
 export async function estimateTotalGasRequiredByUnsignedTransaction(
@@ -251,7 +251,7 @@ export async function estimateTotalGasRequiredByUnsignedTransaction(
   provider: providers.Provider | L2Provider<providers.Provider>,
   gasMarkup: number,
   gasPrice?: BigNumberish,
-  gasLimit?: BigNumberish
+  gasUnits?: BigNumberish
 ): Promise<TransactionCostEstimate> {
   assert(
     gasMarkup > -1 && gasMarkup <= 4,
@@ -262,11 +262,12 @@ export async function estimateTotalGasRequiredByUnsignedTransaction(
   const voidSigner = new VoidSigner(senderAddress, provider);
 
   // Estimate the Gas units required to submit this transaction.
-  let nativeGasCost = await voidSigner.estimateGas({
-    ...unsignedTx,
-    gasPrice,
-    gasLimit,
-  });
+  let nativeGasCost = gasUnits
+    ? BigNumber.from(gasUnits)
+    : await voidSigner.estimateGas({
+        ...unsignedTx,
+        gasPrice,
+      });
   let tokenGasCost: BigNumber;
 
   // OP stack is a special case; gas cost is computed by the SDK, without having to query price.