@across-protocol/sdk 3.1.31 → 3.1.33

package/package.json

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

package/src/caching/Arweave/ArweaveClient.ts

@@ -175,13 +175,21 @@ export class ArweaveClient {
     });
     const results = await Promise.all(
       entries.map(async (edge) => {
-        const data = await this.get<T>(edge.node.id, validator);
-        return isDefined(data)
-          ? {
-              data,
-              hash: edge.node.id,
-            }
-          : null;
+        try {
+          const data = await this.get<T>(edge.node.id, validator);
+          return isDefined(data)
+            ? {
+                data,
+                hash: edge.node.id,
+              }
+            : null;
+        } catch (e) {
+          this.logger.warn({
+            at: "ArweaveClient:getByTopic",
+            message: `Bad request for Arweave topic ${edge.node.id}: ${e}`,
+          });
+          return null;
+        }
       })
     );
     return results.filter(isDefined);

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -29,7 +29,6 @@ import {
   getImpliedBundleBlockRanges,
   isSlowFill,
   mapAsync,
-  relayFillStatus,
   bnUint32Max,
 } from "../../utils";
 import { BigNumber } from "ethers";
@@ -1125,8 +1124,7 @@ export class BundleDataClient {
       ) {
         // If we haven't seen a fill matching this deposit, then we need to rule out that it was filled a long time ago
         // by checkings its on-chain fill status.
-        const fillStatus = await relayFillStatus(
-          spokePoolClients[destinationChainId].spokePool,
+        const fillStatus = await spokePoolClients[destinationChainId].relayFillStatus(
           deposit,
           // We can assume that in production
           // the block ranges passed into this function would never contain blocks where the spoke pool client
@@ -1313,8 +1311,8 @@ export class BundleDataClient {
           const startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
           const endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
           const [startTime, endTime] = [
-            Number((await spokePoolClient.spokePool.provider.getBlock(startBlockForChain)).timestamp),
-            Number((await spokePoolClient.spokePool.provider.getBlock(endBlockForChain)).timestamp),
+            await spokePoolClient.getTimestampForBlock(startBlockForChain),
+            await spokePoolClient.getTimestampForBlock(endBlockForChain),
           ];
           // Sanity checks:
           assert(endTime >= startTime, "End time should be greater than start time.");

package/src/clients/SpokePoolClient.ts

@@ -25,6 +25,7 @@ import {
   Deposit,
   DepositWithBlock,
   Fill,
+  FillStatus,
   FillWithBlock,
   FilledV3RelayEvent,
   RealizedLpFee,
@@ -38,7 +39,7 @@ import {
 } from "../interfaces";
 import { SpokePool } from "../typechain";
 import { getNetworkName } from "../utils/NetworkUtils";
-import { getBlockRangeForDepositId, getDepositIdAtBlock } from "../utils/SpokeUtils";
+import { getBlockRangeForDepositId, getDepositIdAtBlock, relayFillStatus } from "../utils/SpokeUtils";
 import { BaseAbstractClient, isUpdateFailureReason, UpdateFailureReason } from "./BaseAbstractClient";
 import { HubPoolClient } from "./HubPoolClient";
 import { AcrossConfigStoreClient } from "./AcrossConfigStoreClient";
@@ -883,4 +884,23 @@ export class SpokePoolClient extends BaseAbstractClient {
       this.configStoreClient?.isChainLiteChainAtTimestamp(deposit.destinationChainId, deposit.quoteTimestamp) ?? false
     );
   }
+
+  public async getTimestampForBlock(blockTag: number): Promise<number> {
+    const block = await this.spokePool.provider.getBlock(blockTag);
+    return Number(block.timestamp);
+  }
+
+  /**
+   * Find the amount filled for a deposit at a particular block.
+   * @param relayData Deposit information that is used to complete a fill.
+   * @param blockTag Block tag (numeric or "latest") to query at.
+   * @returns The amount filled for the specified deposit at the requested block (or latest).
+   */
+  public relayFillStatus(
+    relayData: RelayData,
+    blockTag?: number | "latest",
+    destinationChainId?: number
+  ): Promise<FillStatus> {
+    return relayFillStatus(this.spokePool, relayData, blockTag, destinationChainId);
+  }
 }

package/src/providers/constants.ts

@@ -4,8 +4,3 @@ export const BLOCK_NUMBER_TTL = 60;
 // This is the TTL for the provider cache.
 export const PROVIDER_CACHE_TTL = 3600;
 export const PROVIDER_CACHE_TTL_MODIFIER = 0.15;
-
-/**
- * A default timeout for requests of 60 seconds.
- */
-export const defaultTimeout = 60 * 1000;

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/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/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.