@across-protocol/sdk 3.1.17 → 3.1.19

package/dist/types/providers/rateLimitedProvider.d.ts

@@ -0,0 +1,11 @@
+import { ethers } from "ethers";
+import { Logger } from "winston";
+export declare class RateLimitedProvider extends ethers.providers.StaticJsonRpcProvider {
+    readonly pctRpcCallsLogged: number;
+    readonly logger: Logger;
+    private queue;
+    constructor(maxConcurrency: number, pctRpcCallsLogged: number, logger?: Logger, ...cacheConstructorParams: ConstructorParameters<typeof ethers.providers.StaticJsonRpcProvider>);
+    wrapSendWithLog(method: string, params: Array<unknown>): Promise<any>;
+    send(method: string, params: Array<unknown>): Promise<unknown>;
+}
+//# sourceMappingURL=rateLimitedProvider.d.ts.map

package/dist/types/providers/rateLimitedProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimitedProvider.d.ts","sourceRoot":"","sources":["../../../src/providers/rateLimitedProvider.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAKjC,qBAAa,mBAAoB,SAAQ,MAAM,CAAC,SAAS,CAAC,qBAAqB;IAQ3E,QAAQ,CAAC,iBAAiB,EAAE,MAAM;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM;IAPzB,OAAO,CAAC,KAAK,CAA6B;gBAKxC,cAAc,EAAE,MAAM,EACb,iBAAiB,EAAE,MAAM,EACzB,MAAM,GAAE,MAAkB,EACnC,GAAG,sBAAsB,EAAE,qBAAqB,CAAC,OAAO,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC;IAiB3F,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;IAwCnD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;CAaxE"}

package/dist/types/providers/retryProvider.d.ts

@@ -0,0 +1,17 @@
+import { ethers } from "ethers";
+import { CachingMechanismInterface } from "../interfaces";
+import { AugmentedLogger } from "@uma/logger";
+export declare class RetryProvider extends ethers.providers.StaticJsonRpcProvider {
+    readonly nodeQuorumThreshold: number;
+    readonly retries: number;
+    readonly delay: number;
+    readonly maxConcurrency: number;
+    readonly providers: ethers.providers.StaticJsonRpcProvider[];
+    constructor(params: ConstructorParameters<typeof ethers.providers.StaticJsonRpcProvider>[], chainId: number, nodeQuorumThreshold: number, retries: number, delay: number, maxConcurrency: number, providerCacheNamespace: string, pctRpcCallsLogged: number, redisClient?: CachingMechanismInterface, standardTtlBlockDistance?: number, noTtlBlockDistance?: number, providerCacheTtl?: number, logger?: AugmentedLogger);
+    send(method: string, params: Array<unknown>): Promise<unknown>;
+    _validateResponse(method: string, _: Array<unknown>, response: unknown): boolean;
+    _sendAndValidate(provider: ethers.providers.StaticJsonRpcProvider, method: string, params: Array<unknown>): Promise<unknown>;
+    _trySend(provider: ethers.providers.StaticJsonRpcProvider, method: string, params: Array<unknown>): Promise<unknown>;
+    _getQuorum(method: string, params: Array<unknown>): number;
+}
+//# sourceMappingURL=retryProvider.d.ts.map

package/dist/types/providers/retryProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryProvider.d.ts","sourceRoot":"","sources":["../../../src/providers/retryProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAK1D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C,qBAAa,aAAc,SAAQ,MAAM,CAAC,SAAS,CAAC,qBAAqB;IAKrE,QAAQ,CAAC,mBAAmB,EAAE,MAAM;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM;IAPjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,qBAAqB,EAAE,CAAC;gBAE3D,MAAM,EAAE,qBAAqB,CAAC,OAAO,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC,EAAE,EAC9E,OAAO,EAAE,MAAM,EACN,mBAAmB,EAAE,MAAM,EAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EAC/B,sBAAsB,EAAE,MAAM,EAC9B,iBAAiB,EAAE,MAAM,EACzB,WAAW,CAAC,EAAE,yBAAyB,EACvC,wBAAwB,CAAC,EAAE,MAAM,EACjC,kBAAkB,CAAC,EAAE,MAAM,EAC3B,gBAAgB,SAAqB,EACrC,MAAM,CAAC,EAAE,eAAe;IAqCX,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IA+I7E,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO;IAO1E,gBAAgB,CACpB,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,qBAAqB,EAChD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GACrB,OAAO,CAAC,OAAO,CAAC;IAiBnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,qBAAqB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAQpH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM;CAqB3D"}

package/dist/types/providers/utils.d.ts

@@ -0,0 +1,40 @@
+import { providers } from "ethers";
+export declare function compareResultsAndFilterIgnoredKeys(ignoredKeys: string[], _objA: Record<string, unknown>, _objB: Record<string, unknown>): boolean;
+export declare function compareArrayResultsWithIgnoredKeys(ignoredKeys: string[], objA: unknown[], objB: unknown[]): boolean;
+/**
+ * This is the type we pass to define a request "task".
+ */
+export interface RateLimitTask {
+    sendArgs: [string, Array<unknown>];
+    resolve: (result: unknown) => void;
+    reject: (err: unknown) => void;
+}
+/**
+ * A helper function to format an error message for a provider.
+ * @param provider The provider that failed.
+ * @param rawErrorText The raw error text.
+ * @returns The formatted error message.
+ */
+export declare function formatProviderError(provider: providers.StaticJsonRpcProvider, rawErrorText: string): string;
+export declare function createSendErrorWithMessage(message: string, sendError: Record<string, unknown>): {
+    name: string;
+    message: string;
+    stack?: string | undefined;
+    cause?: unknown;
+};
+/**
+ * Compares two RPC results, filtering out fields that are known to differ between providers.
+ * Note: this function references `IGNORED_ERROR_CODES` which is a record of error codes that correspond to fields
+ *       that should be ignored when comparing RPC results.
+ * @param method The method that was called - conditionally filters out fields based on the method.
+ * @param rpcResultA The first RPC result.
+ * @param rpcResultB The second RPC result.
+ * @returns True if the results are equal, false otherwise.
+ */
+export declare function compareRpcResults(method: string, rpcResultA: unknown, rpcResultB: unknown): boolean;
+export declare enum CacheType {
+    NONE = 0,
+    WITH_TTL = 1,
+    NO_TTL = 2
+}
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/providers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/providers/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAqBnC,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,MAAM,EAAE,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAOT;AAED,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAOnH;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAE5B,QAAQ,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IAInC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,SAAS,CAAC,qBAAqB,EAAE,YAAY,EAAE,MAAM,UAElG;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;EAG7F;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CA8BnG;AAED,oBAAY,SAAS;IACnB,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,MAAM,IAAA;CACP"}

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

@@ -201,6 +201,6 @@ export declare class QueryBase__factory {
             };
             coingeckoId: string;
         };
-    }, spokePoolAddress?: string, simulatedRelayerAddress?: string, coingeckoProApiKey?: string, logger?: Logger, gasMarkup?: number, coingeckoBaseCurrency?: string): QueryBase;
+    }, spokePoolAddress?: string | undefined, simulatedRelayerAddress?: string, coingeckoProApiKey?: string, logger?: Logger, gasMarkup?: number, coingeckoBaseCurrency?: string): QueryBase;
 }
 //# sourceMappingURL=factory.d.ts.map

package/dist/types/relayFeeCalculator/chain-queries/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/relayFeeCalculator/chain-queries/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAkB,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAU/D,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAC5B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoB,EACjC,gBAAgB,SAA2C,EAC3D,uBAAuB,SAAoC,EAC3D,kBAAkB,CAAC,EAAE,MAAM,EAC3B,MAAM,GAAE,MAAuB,EAC/B,SAAS,SAAI,EACb,qBAAqB,SAAQ,GAC5B,SAAS;CA4Bb"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/relayFeeCalculator/chain-queries/factory.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAkB,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAU/D,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAC5B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoB,EACjC,gBAAgB,qBAA2C,EAC3D,uBAAuB,SAAoC,EAC3D,kBAAkB,CAAC,EAAE,MAAM,EAC3B,MAAM,GAAE,MAAuB,EAC/B,SAAS,SAAI,EACb,qBAAqB,SAAQ,GAC5B,SAAS;CA8Bb"}

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

@@ -201,7 +201,7 @@ export declare class PolygonQueries extends QueryBase {
             };
             coingeckoId: string;
         };
-    }, spokePoolAddress?: string, simulatedRelayerAddress?: string, coingeckoProApiKey?: string, logger?: Logger, gasMarkup?: number);
+    }, spokePoolAddress?: string | undefined, simulatedRelayerAddress?: string, coingeckoProApiKey?: string, logger?: Logger, gasMarkup?: number);
     getTokenPrice(tokenSymbol: string): Promise<number>;
 }
 //# sourceMappingURL=polygon.d.ts.map

package/dist/types/relayFeeCalculator/chain-queries/polygon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../../src/relayFeeCalculator/chain-queries/polygon.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,cAAe,SAAQ,SAAS;gBAEzC,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAC5B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoB,EACjC,gBAAgB,SAAqD,EACrE,uBAAuB,SAAoC,EAC3D,kBAAkB,CAAC,EAAE,MAAM,EAC3B,MAAM,GAAE,MAAuB,EAC/B,SAAS,SAAI;IAeA,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAcnE"}
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../../src/relayFeeCalculator/chain-queries/polygon.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAInC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,cAAe,SAAQ,SAAS;gBAEzC,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAC5B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoB,EACjC,gBAAgB,qBAAqD,EACrE,uBAAuB,SAAoC,EAC3D,kBAAkB,CAAC,EAAE,MAAM,EAC3B,MAAM,GAAE,MAAuB,EAC/B,SAAS,SAAI;IAgBA,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAcnE"}

package/dist/types/utils/NetworkUtils.d.ts

@@ -64,4 +64,10 @@ export declare function chainIsCCTPEnabled(chainId: number): boolean;
  * @returns True if chainId requires manual L1 -> L2 finalization, otherwise false.
  */
 export declare function chainRequiresL1ToL2Finalization(chainId: number): boolean;
+/**
+ * Returns the origin of a URL.
+ * @param url A URL.
+ * @returns The origin of the URL, or "UNKNOWN" if the URL is invalid.
+ */
+export declare function getOriginFromURL(url: string): string;
 //# sourceMappingURL=NetworkUtils.d.ts.map

package/dist/types/utils/NetworkUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtils.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE"}
+{"version":3,"file":"NetworkUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/NetworkUtils.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAGjE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMpD"}

package/dist/types/utils/ObjectUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/ObjectUtils.ts"],"names":[],"mappings":"AAKA,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAyBjE;AAGD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,GAAG,CASL;AACD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACrC,GAAG,CAOL;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,GAAG,CAM1F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAEvG"}
+{"version":3,"file":"ObjectUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/ObjectUtils.ts"],"names":[],"mappings":"AAMA,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAyBjE;AAGD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,GAAG,CASL;AACD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,GAAG,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACrC,GAAG,CAOL;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,GAAG,CAM1F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAEvG"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "3.1.17",
+  "version": "3.1.19",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -58,6 +58,7 @@
     "@size-limit/preset-small-lib": "^7.0.8",
     "@typechain/ethers-v5": "^11.1.1",
     "@typechain/hardhat": "^6.1.6",
+    "@types/async": "^3.2.24",
     "@types/chai": "^4.3.6",
     "@types/dotenv": "^8.2.0",
     "@types/lodash": "^4.14.199",
@@ -100,16 +101,19 @@
   "dependencies": {
     "@across-protocol/across-token": "^1.0.0",
     "@across-protocol/constants": "^3.1.13",
-    "@across-protocol/contracts": "^3.0.8",
+    "@across-protocol/contracts": "^3.0.9",
     "@eth-optimism/sdk": "^3.3.1",
     "@pinata/sdk": "^2.1.0",
     "@types/mocha": "^10.0.1",
+    "@uma/logger": "^1.3.0",
     "@uma/sdk": "^0.34.1",
     "arweave": "^1.14.4",
+    "async": "^3.2.5",
     "axios": "^0.27.2",
     "big-number": "^2.0.0",
     "decimal.js": "^10.3.1",
     "ethers": "^5.7.2",
+    "lodash": "^4.17.21",
     "lodash.get": "^4.4.2",
     "superstruct": "^0.15.4",
     "tslib": "^2.6.2"

package/src/index.ts

@@ -13,3 +13,4 @@ export * as typeguards from "./typeguards";
 export * as clients from "./clients";
 export * as typechain from "./typechain";
 export * as caching from "./caching";
+export * as providers from "./providers";

package/src/providers/cachedProvider.ts

@@ -0,0 +1,155 @@
+import { random } from "lodash";
+import { CachingMechanismInterface } from "../interfaces";
+import { BLOCK_NUMBER_TTL, PROVIDER_CACHE_TTL, PROVIDER_CACHE_TTL_MODIFIER as ttl_modifier } from "./constants";
+import { RateLimitedProvider } from "./rateLimitedProvider";
+import { CacheType } from "./utils";
+
+export class CacheProvider extends RateLimitedProvider {
+  public readonly getBlockByNumberPrefix: string;
+  public readonly getLogsCachePrefix: string;
+  public readonly callCachePrefix: string;
+  public readonly baseTTL: number;
+
+  constructor(
+    providerCacheNamespace: string,
+    readonly redisClient?: CachingMechanismInterface,
+    // Note: if not provided, this is set to POSITIVE_INFINITY, meaning no cache entries are set with the standard TTL.
+    readonly standardTtlBlockDistance = Number.POSITIVE_INFINITY,
+    // Note: if not provided, this is set to POSITIVE_INFINITY, meaning no cache entries are set with no TTL.
+    readonly noTtlBlockDistance = Number.POSITIVE_INFINITY,
+    readonly providerCacheTtl = PROVIDER_CACHE_TTL,
+    ...jsonRpcConstructorParams: ConstructorParameters<typeof RateLimitedProvider>
+  ) {
+    super(...jsonRpcConstructorParams);
+
+    const { chainId } = this.network;
+
+    // Pre-compute as much of the redis key as possible.
+    const cachePrefix = `${providerCacheNamespace},${new URL(this.connection.url).hostname},${chainId}`;
+    this.getBlockByNumberPrefix = `${cachePrefix}:getBlockByNumber,`;
+    this.getLogsCachePrefix = `${cachePrefix}:eth_getLogs,`;
+    this.callCachePrefix = `${cachePrefix}:eth_call,`;
+
+    const _ttlVar = providerCacheTtl;
+    const _ttl = Number(_ttlVar);
+    if (isNaN(_ttl) || _ttl <= 0) {
+      throw new Error(`PROVIDER_CACHE_TTL (${_ttlVar}) must be numeric and > 0`);
+    }
+    this.baseTTL = _ttl;
+  }
+  override async send(method: string, params: Array<unknown>): Promise<unknown> {
+    const cacheType = this.redisClient ? await this.cacheType(method, params) : CacheType.NONE;
+
+    if (cacheType !== CacheType.NONE) {
+      const redisKey = this.buildRedisKey(method, params);
+
+      // Attempt to pull the result from the cache.
+      const redisResult = await this.redisClient?.get<string>(redisKey);
+
+      // If cache has the result, parse the json and return it.
+      if (redisResult) {
+        return JSON.parse(redisResult);
+      }
+
+      // Cache does not have the result. Query it directly and cache.
+      const result = await super.send(method, params);
+
+      // Note: use swtich to ensure all enum cases are handled.
+      switch (cacheType) {
+        case CacheType.WITH_TTL:
+          {
+            // Apply a random margin to spread expiry over a larger time window.
+            const ttl = this.baseTTL + Math.ceil(random(-ttl_modifier, ttl_modifier, true) * this.baseTTL);
+            await this.redisClient?.set(redisKey, JSON.stringify(result), ttl);
+          }
+          break;
+        case CacheType.NO_TTL:
+          await this.redisClient?.set(redisKey, JSON.stringify(result), Number.POSITIVE_INFINITY);
+          break;
+        default:
+          throw new Error(`Unexpected Cache type: ${cacheType}`);
+      }
+
+      // Return the cached result.
+      return result;
+    }
+
+    return await super.send(method, params);
+  }
+
+  private buildRedisKey(method: string, params: Array<unknown>) {
+    // Only handles eth_getLogs and eth_call right now.
+    switch (method) {
+      case "eth_getBlockByNumber":
+        return this.getBlockByNumberPrefix + JSON.stringify(params);
+      case "eth_getLogs":
+        return this.getLogsCachePrefix + JSON.stringify(params);
+      case "eth_call":
+        return this.callCachePrefix + JSON.stringify(params);
+      default:
+        throw new Error(`CacheProvider::buildRedisKey: invalid JSON-RPC method ${method}`);
+    }
+  }
+
+  private cacheType(method: string, params: Array<unknown>): Promise<CacheType> {
+    // Today, we only cache eth_getLogs and eth_call.
+    if (method === "eth_getLogs") {
+      const [{ fromBlock, toBlock }] = params as { toBlock: number; fromBlock: number }[];
+
+      // Handle odd cases where the ordering is flipped, etc.
+      // toBlock/fromBlock is in hex, so it must be parsed before being compared to the first unsafe block.
+      const fromBlockNumber = parseInt(String(fromBlock), 16);
+      const toBlockNumber = parseInt(String(toBlock), 16);
+
+      // Handle cases where the input block numbers are not hex values ("latest", "pending", etc).
+      // This would result in the result of the above being NaN.
+      if (Number.isNaN(fromBlockNumber) || Number.isNaN(toBlockNumber)) {
+        return Promise.resolve(CacheType.NONE);
+      }
+
+      if (toBlockNumber < fromBlockNumber) {
+        throw new Error("CacheProvider::shouldCache toBlock cannot be smaller than fromBlock.");
+      }
+
+      return this.cacheTypeForBlock(toBlock);
+    } else if ("eth_call" === method || "eth_getBlockByNumber" === method) {
+      // Pull out the block tag from params. Its position in params is dependent on the method.
+      // We are only interested in numeric block tags, which would be hex-encoded strings.
+      const idx = method === "eth_getBlockByNumber" ? 0 : 1;
+      const blockNumber = parseInt(String(params[idx]), 16);
+
+      // If the block number isn't present or is a text string, this will be NaN and we return false.
+      if (Number.isNaN(blockNumber)) {
+        return Promise.resolve(CacheType.NONE);
+      }
+
+      // If the block is old enough to cache, cache the call.
+      return this.cacheTypeForBlock(blockNumber);
+    } else {
+      return Promise.resolve(CacheType.NONE);
+    }
+  }
+
+  private async cacheTypeForBlock(blockNumber: number): Promise<CacheType> {
+    // Note: this method is an internal method provided by the BaseProvider. It allows the caller to specify a maxAge of
+    // the block that is allowed. This means if a block has been retrieved within the last n seconds, no provider
+    // query will be made.
+    const currentBlockNumber = await super._getInternalBlockNumber(BLOCK_NUMBER_TTL * 1000);
+
+    // Determine the distance that the block is from HEAD.
+    const headDistance = currentBlockNumber - blockNumber;
+
+    // If the distance from head is large enough, set with no TTL.
+    if (headDistance > this.noTtlBlockDistance) {
+      return CacheType.NO_TTL;
+    }
+
+    // If the distance is <= noTtlBlockDistance, but > standardTtlBlockDistance, use standard TTL.
+    if (headDistance > this.standardTtlBlockDistance) {
+      return CacheType.WITH_TTL;
+    }
+
+    // Too close to HEAD, no cache.
+    return CacheType.NONE;
+  }
+}

package/src/providers/constants.ts

@@ -0,0 +1,11 @@
+// This is how many seconds stale the block number can be for us to use it for evaluating the reorg distance in the cache provider.
+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

@@ -0,0 +1,5 @@
+export * from "./rateLimitedProvider";
+export * from "./cachedProvider";
+export * from "./retryProvider";
+export * from "./constants";
+export * from "./utils";

package/src/providers/rateLimitedProvider.ts

@@ -0,0 +1,94 @@
+// StaticJsonRpcProvider is used in place of JsonRpcProvider to avoid redundant eth_chainId queries prior to each
+// request. This is safe to use when the back-end provider is guaranteed not to change.
+// See https://docs.ethers.io/v5/api/providers/jsonrpc-provider/#StaticJsonRpcProvider
+
+import { QueueObject, queue } from "async";
+import { ethers } from "ethers";
+import { RateLimitTask } from "./utils";
+import { getOriginFromURL } from "../utils/NetworkUtils";
+import { Logger } from "winston";
+import { Logger as umaLogger } from "@uma/logger";
+
+// This provider is a very small addition to the StaticJsonRpcProvider that ensures that no more than `maxConcurrency`
+// requests are ever in flight. It uses the async/queue library to manage this.
+export class RateLimitedProvider extends ethers.providers.StaticJsonRpcProvider {
+  // The queue object that manages the tasks.
+  private queue: QueueObject<RateLimitTask>;
+
+  // Takes the same arguments as the JsonRpcProvider, but it has an additional maxConcurrency value at the beginning
+  // of the list.
+  constructor(
+    maxConcurrency: number,
+    readonly pctRpcCallsLogged: number,
+    readonly logger: Logger = umaLogger,
+    ...cacheConstructorParams: ConstructorParameters<typeof ethers.providers.StaticJsonRpcProvider>
+  ) {
+    super(...cacheConstructorParams);
+
+    // This sets up the queue. Each task is executed by calling the superclass's send method, which fires off the
+    // request. This queue sends out requests concurrently, but stops once the concurrency limit is reached. The
+    // maxConcurrency is configured here.
+    this.queue = queue(async ({ sendArgs, resolve, reject }: RateLimitTask, callback: () => void) => {
+      await this.wrapSendWithLog(...sendArgs)
+        .then(resolve)
+        .catch(reject);
+      // we need this for the queue to know that the task is done
+      // @see: https://caolan.github.io/async/v3/global.html
+      callback();
+    }, maxConcurrency);
+  }
+
+  async wrapSendWithLog(method: string, params: Array<unknown>) {
+    if (this.pctRpcCallsLogged <= 0 || Math.random() > this.pctRpcCallsLogged / 100) {
+      // Non sample path: no logging or timing, just issue the request.
+      return super.send(method, params);
+    } else {
+      const loggerArgs = {
+        at: "ProviderUtils",
+        message: "Provider response sample",
+        provider: getOriginFromURL(this.connection.url),
+        method,
+        params,
+        chainId: this.network.chainId,
+      };
+
+      // In this path we log an rpc response sample.
+      // Note: use performance.now() to ensure a purely monotonic clock.
+      const startTime = performance.now();
+      try {
+        const result = await super.send(method, params);
+        const elapsedTimeS = (performance.now() - startTime) / 1000;
+        this.logger.debug({
+          ...loggerArgs,
+          success: true,
+          timeElapsed: elapsedTimeS,
+        });
+        return result;
+      } catch (error) {
+        // Log errors as well.
+        // For now, to keep logs light, don't log the error itself, just propogate and let it be handled higher up.
+        const elapsedTimeS = (performance.now() - startTime) / 1000;
+        this.logger.debug({
+          ...loggerArgs,
+          success: false,
+          timeElapsed: elapsedTimeS,
+        });
+        throw error;
+      }
+    }
+  }
+
+  override send(method: string, params: Array<unknown>): Promise<unknown> {
+    // This simply creates a promise and adds the arguments and resolve and reject handlers to the task.
+    return new Promise<unknown>((resolve, reject) => {
+      const task: RateLimitTask = {
+        sendArgs: [method, params],
+        resolve,
+        reject,
+      };
+      // We didn't previously wait for this push so we can emulate
+      // the same behavior with the `void` keyword.
+      void this.queue.push(task);
+    });
+  }
+}