v-swap-smart-order-router 3.10.2

package/build/module/index.d.ts

@@ -0,0 +1,3 @@
+export * from './providers';
+export * from './routers';
+export * from './util';

package/build/module/index.js

@@ -0,0 +1,4 @@
+export * from './providers';
+export * from './routers';
+export * from './util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxRQUFRLENBQUMifQ==

package/build/module/providers/cache-node.d.ts

@@ -0,0 +1,9 @@
+import NodeCache from 'node-cache';
+import { ICache } from './cache';
+export declare class NodeJSCache<T> implements ICache<T> {
+    private nodeCache;
+    constructor(nodeCache: NodeCache);
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+}

package/build/module/providers/cache-node.js

@@ -0,0 +1,15 @@
+export class NodeJSCache {
+    constructor(nodeCache) {
+        this.nodeCache = nodeCache;
+    }
+    async get(key) {
+        return this.nodeCache.get(key);
+    }
+    async set(key, value) {
+        return this.nodeCache.set(key, value);
+    }
+    async has(key) {
+        return this.nodeCache.has(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtbm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGUtbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sV0FBVztJQUN0QixZQUFvQixTQUFvQjtRQUFwQixjQUFTLEdBQVQsU0FBUyxDQUFXO0lBQUcsQ0FBQztJQUU1QyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQVc7UUFDbkIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBSSxHQUFHLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFXLEVBQUUsS0FBUTtRQUM3QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUN4QyxDQUFDO0lBRUQsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFXO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDakMsQ0FBQztDQUNGIn0=

package/build/module/providers/cache.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generic cache used by providers. Allows caching of results to minimize
+ * round trips to external data sources.
+ *
+ * @export
+ * @interface ICache
+ * @template T
+ */
+export interface ICache<T> {
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+}

package/build/module/providers/cache.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/build/module/providers/caching/route/index.d.ts

@@ -0,0 +1,2 @@
+export * from './route-caching-provider';
+export * from './model/';

package/build/module/providers/caching/route/index.js

@@ -0,0 +1,3 @@
+export * from './route-caching-provider';
+export * from './model/';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmcvcm91dGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLFVBQVUsQ0FBQyJ9

package/build/module/providers/caching/route/model/cache-mode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CacheMode enum that controls the way that the RouteCachingProvider works.
+ * - *Livemode*:   This mode will set materialized routes into cache and fetch routes from cache.
+ *                 If the route exists in cache, it will be quoted and returned, otherwise it will materialized.
+ * - *Darkmode*:   This mode indicates that the cache will not be used, it will not be inserted nor fetched.
+ *                 Routes will always be materialized.
+ * - *Tapcompare*: In this mode we will insert and fetch routes to/from cache, and we will also materialize the route.
+ *                 Ultimately the materialized route will be returned, but we will log some metrics comparing both.
+ *
+ * @enum {string}
+ */
+export declare enum CacheMode {
+    Livemode = "livemode",
+    Darkmode = "darkmode",
+    Tapcompare = "tapcompare"
+}

package/build/module/providers/caching/route/model/cache-mode.js

@@ -0,0 +1,18 @@
+/**
+ * CacheMode enum that controls the way that the RouteCachingProvider works.
+ * - *Livemode*:   This mode will set materialized routes into cache and fetch routes from cache.
+ *                 If the route exists in cache, it will be quoted and returned, otherwise it will materialized.
+ * - *Darkmode*:   This mode indicates that the cache will not be used, it will not be inserted nor fetched.
+ *                 Routes will always be materialized.
+ * - *Tapcompare*: In this mode we will insert and fetch routes to/from cache, and we will also materialize the route.
+ *                 Ultimately the materialized route will be returned, but we will log some metrics comparing both.
+ *
+ * @enum {string}
+ */
+export var CacheMode;
+(function (CacheMode) {
+    CacheMode["Livemode"] = "livemode";
+    CacheMode["Darkmode"] = "darkmode";
+    CacheMode["Tapcompare"] = "tapcompare";
+})(CacheMode || (CacheMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtbW9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGluZy9yb3V0ZS9tb2RlbC9jYWNoZS1tb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLENBQU4sSUFBWSxTQUlYO0FBSkQsV0FBWSxTQUFTO0lBQ25CLGtDQUFxQixDQUFBO0lBQ3JCLGtDQUFxQixDQUFBO0lBQ3JCLHNDQUF5QixDQUFBO0FBQzNCLENBQUMsRUFKVyxTQUFTLEtBQVQsU0FBUyxRQUlwQiJ9

package/build/module/providers/caching/route/model/cached-route.d.ts

@@ -0,0 +1,26 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { Token } from '@uniswap/sdk-core';
+import { MixedRoute, V2Route, V3Route } from '../../../../routers';
+interface CachedRouteParams<Route extends V3Route | V2Route | MixedRoute> {
+    route: Route;
+    percent: number;
+}
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+export declare class CachedRoute<Route extends V3Route | V2Route | MixedRoute> {
+    readonly route: Route;
+    readonly percent: number;
+    /**
+     * @param route
+     * @param percent
+     */
+    constructor({ route, percent }: CachedRouteParams<Route>);
+    get protocol(): Protocol;
+    get tokenIn(): Token;
+    get tokenOut(): Token;
+}
+export {};

package/build/module/providers/caching/route/model/cached-route.js

@@ -0,0 +1,26 @@
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+export class CachedRoute {
+    /**
+     * @param route
+     * @param percent
+     */
+    constructor({ route, percent }) {
+        this.route = route;
+        this.percent = percent;
+    }
+    get protocol() {
+        return this.route.protocol;
+    }
+    get tokenIn() {
+        return this.route.input;
+    }
+    get tokenOut() {
+        return this.route.output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLXJvdXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9jYWNoaW5nL3JvdXRlL21vZGVsL2NhY2hlZC1yb3V0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFVQTs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyxXQUFXO0lBSXRCOzs7T0FHRztJQUNILFlBQVksRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUE0QjtRQUN0RCxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUN6QixDQUFDO0lBRUQsSUFBVyxRQUFRO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUM7SUFDN0IsQ0FBQztJQUVELElBQVcsT0FBTztRQUNoQixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUFXLFFBQVE7UUFDakIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQztJQUMzQixDQUFDO0NBQ0YifQ==

package/build/module/providers/caching/route/model/cached-routes.d.ts

@@ -0,0 +1,63 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { Token, TradeType } from '@uniswap/sdk-core';
+import { MixedRoute, RouteWithValidQuote, V2Route, V3Route } from '../../../../routers';
+import { ChainId } from '../../../../util';
+import { CachedRoute } from './cached-route';
+interface CachedRoutesParams {
+    routes: CachedRoute<V3Route | V2Route | MixedRoute>[];
+    chainId: ChainId;
+    tokenIn: Token;
+    tokenOut: Token;
+    protocolsCovered: Protocol[];
+    blockNumber: number;
+    tradeType: TradeType;
+    blocksToLive?: number;
+}
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+export declare class CachedRoutes {
+    readonly routes: CachedRoute<V3Route | V2Route | MixedRoute>[];
+    readonly chainId: ChainId;
+    readonly tokenIn: Token;
+    readonly tokenOut: Token;
+    readonly protocolsCovered: Protocol[];
+    readonly blockNumber: number;
+    readonly tradeType: TradeType;
+    blocksToLive: number;
+    /**
+     * @param routes
+     * @param chainId
+     * @param tokenIn
+     * @param tokenOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     * @param blocksToLive
+     */
+    constructor({ routes, chainId, tokenIn, tokenOut, protocolsCovered, blockNumber, tradeType, blocksToLive }: CachedRoutesParams);
+    /**
+     * Factory method that creates a `CachedRoutes` object from an array of RouteWithValidQuote.
+     *
+     * @public
+     * @static
+     * @param routes
+     * @param chainId
+     * @param tokenIn
+     * @param tokenOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     */
+    static fromRoutesWithValidQuotes(routes: RouteWithValidQuote[], chainId: ChainId, tokenIn: Token, tokenOut: Token, protocolsCovered: Protocol[], blockNumber: number, tradeType: TradeType): CachedRoutes | undefined;
+    /**
+     * Function to determine if, given a block number, the CachedRoute is expired or not.
+     *
+     * @param currentBlockNumber
+     */
+    notExpired(currentBlockNumber: number): boolean;
+}
+export {};

package/build/module/providers/caching/route/model/cached-routes.js

@@ -0,0 +1,66 @@
+import _ from 'lodash';
+import { CachedRoute } from './cached-route';
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+export class CachedRoutes {
+    /**
+     * @param routes
+     * @param chainId
+     * @param tokenIn
+     * @param tokenOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     * @param blocksToLive
+     */
+    constructor({ routes, chainId, tokenIn, tokenOut, protocolsCovered, blockNumber, tradeType, blocksToLive = 0 }) {
+        this.routes = routes;
+        this.chainId = chainId;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+        this.protocolsCovered = protocolsCovered;
+        this.blockNumber = blockNumber;
+        this.tradeType = tradeType;
+        this.blocksToLive = blocksToLive;
+    }
+    /**
+     * Factory method that creates a `CachedRoutes` object from an array of RouteWithValidQuote.
+     *
+     * @public
+     * @static
+     * @param routes
+     * @param chainId
+     * @param tokenIn
+     * @param tokenOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     */
+    static fromRoutesWithValidQuotes(routes, chainId, tokenIn, tokenOut, protocolsCovered, blockNumber, tradeType) {
+        if (routes.length == 0)
+            return undefined;
+        const cachedRoutes = _.map(routes, (route) => new CachedRoute({ route: route.route, percent: route.percent }));
+        return new CachedRoutes({
+            routes: cachedRoutes,
+            chainId: chainId,
+            tokenIn: tokenIn,
+            tokenOut: tokenOut,
+            protocolsCovered: protocolsCovered,
+            blockNumber: blockNumber,
+            tradeType: tradeType
+        });
+    }
+    /**
+     * Function to determine if, given a block number, the CachedRoute is expired or not.
+     *
+     * @param currentBlockNumber
+     */
+    notExpired(currentBlockNumber) {
+        return (currentBlockNumber - this.blockNumber) <= this.blocksToLive;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLXJvdXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGluZy9yb3V0ZS9tb2RlbC9jYWNoZWQtcm91dGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sQ0FBQyxNQUFNLFFBQVEsQ0FBQztBQUt2QixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFhN0M7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQVd2Qjs7Ozs7Ozs7O09BU0c7SUFDSCxZQUNFLEVBQ0UsTUFBTSxFQUNOLE9BQU8sRUFDUCxPQUFPLEVBQ1AsUUFBUSxFQUNSLGdCQUFnQixFQUNoQixXQUFXLEVBQ1gsU0FBUyxFQUNULFlBQVksR0FBRyxDQUFDLEVBQ0c7UUFFckIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7UUFDekIsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGdCQUFnQixDQUFDO1FBQ3pDLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzNCLElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO0lBQ25DLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7O09BWUc7SUFDSSxNQUFNLENBQUMseUJBQXlCLENBQ3JDLE1BQTZCLEVBQzdCLE9BQWdCLEVBQ2hCLE9BQWMsRUFDZCxRQUFlLEVBQ2YsZ0JBQTRCLEVBQzVCLFdBQW1CLEVBQ25CLFNBQW9CO1FBRXBCLElBQUksTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDO1lBQUUsT0FBTyxTQUFTLENBQUM7UUFFekMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxLQUEwQixFQUFFLEVBQUUsQ0FDaEUsSUFBSSxXQUFXLENBQUMsRUFBRSxLQUFLLEVBQUUsS0FBSyxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQ2hFLENBQUM7UUFFRixPQUFPLElBQUksWUFBWSxDQUFDO1lBQ3RCLE1BQU0sRUFBRSxZQUFZO1lBQ3BCLE9BQU8sRUFBRSxPQUFPO1lBQ2hCLE9BQU8sRUFBRSxPQUFPO1lBQ2hCLFFBQVEsRUFBRSxRQUFRO1lBQ2xCLGdCQUFnQixFQUFFLGdCQUFnQjtZQUNsQyxXQUFXLEVBQUUsV0FBVztZQUN4QixTQUFTLEVBQUUsU0FBUztTQUNyQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLFVBQVUsQ0FBQyxrQkFBMEI7UUFDMUMsT0FBTyxDQUFDLGtCQUFrQixHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDO0lBQ3RFLENBQUM7Q0FDRiJ9

package/build/module/providers/caching/route/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cached-route';
+export * from './cached-routes';
+export * from './cache-mode';

package/build/module/providers/caching/route/model/index.js

@@ -0,0 +1,4 @@
+export * from './cached-route';
+export * from './cached-routes';
+export * from './cache-mode';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmcvcm91dGUvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDIn0=

package/build/module/providers/caching/route/route-caching-provider.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Provider for getting token data from a Token List.
+ *
+ * @export
+ * @interface IRouteCachingProvider
+ */
+import { Protocol } from '@uniswap/router-sdk';
+import { Currency, CurrencyAmount, Token, TradeType } from '@uniswap/sdk-core';
+import { ChainId } from '../../../util';
+import { CacheMode } from './model';
+import { CachedRoutes } from './model/cached-routes';
+/**
+ * Abstract class for a RouteCachingProvider.
+ * Defines the base methods of how to interact with this interface, but not the implementation of how to cache.
+ */
+export declare abstract class IRouteCachingProvider {
+    /**
+     * Final implementation of the public `getCachedRoute` method, this is how code will interact with the implementation
+     *
+     * @public
+     * @readonly
+     * @param chainId
+     * @param amount
+     * @param quoteToken
+     * @param tradeType
+     * @param protocols
+     * @param blockNumber
+     */
+    readonly getCachedRoute: (chainId: number, amount: CurrencyAmount<Currency>, quoteToken: Token, tradeType: TradeType, protocols: Protocol[], blockNumber: number) => Promise<CachedRoutes | undefined>;
+    /**
+     * Final implementation of the public `setCachedRoute` method.
+     * This method will set the blockToLive in the CachedRoutes object before calling the internal method to insert in cache.
+     *
+     * @public
+     * @readonly
+     * @param cachedRoutes The route to cache.
+     * @returns Promise<boolean> Indicates if the route was inserted into cache.
+     */
+    readonly setCachedRoute: (cachedRoutes: CachedRoutes, amount: CurrencyAmount<Currency>) => Promise<boolean>;
+    /**
+     * Returns the CacheMode for the given cachedRoutes and amount
+     *
+     * @param cachedRoutes
+     * @param amount
+     */
+    getCacheModeFromCachedRoutes(cachedRoutes: CachedRoutes, amount: CurrencyAmount<Currency>): Promise<CacheMode>;
+    /**
+     * Returns the CacheMode for the given combination of chainId, tokenIn, tokenOut and tradetype
+     *
+     * @public
+     * @abstract
+     * @param chainId
+     * @param tokenIn
+     * @param tokenOut
+     * @param tradeType
+     * @param amount
+     */
+    abstract getCacheMode(chainId: ChainId, amount: CurrencyAmount<Currency>, quoteToken: Token, tradeType: TradeType, protocols: Protocol[]): Promise<CacheMode>;
+    private filterExpiredCachedRoutes;
+    /**
+     * Internal function to fetch the CachedRoute from the cache.
+     * Must be implemented.
+     *
+     * @param chainId
+     * @param amount
+     * @param quoteToken
+     * @param tradeType
+     * @param protocols
+     * @protected
+     */
+    protected abstract _getCachedRoute(chainId: ChainId, amount: CurrencyAmount<Currency>, quoteToken: Token, tradeType: TradeType, protocols: Protocol[]): Promise<CachedRoutes | undefined>;
+    /**
+     * Internal function to insert the CachedRoute into cache.
+     * Must be implemented.
+     *
+     * @param cachedRoutes
+     * @param amount
+     * @protected
+     */
+    protected abstract _setCachedRoute(cachedRoutes: CachedRoutes, amount: CurrencyAmount<Currency>): Promise<boolean>;
+    /**
+     * Internal function to getBlocksToLive for a given cachedRoute.
+     * This function is called before attempting to insert the route into cache.
+     * Must be implemented.
+     *
+     * @param cachedRoutes
+     * @param amount
+     * @protected
+     */
+    protected abstract _getBlocksToLive(cachedRoutes: CachedRoutes, amount: CurrencyAmount<Currency>): Promise<number>;
+}

package/build/module/providers/caching/route/route-caching-provider.js

@@ -0,0 +1,61 @@
+import { TradeType } from '@uniswap/sdk-core';
+import { CacheMode } from './model';
+/**
+ * Abstract class for a RouteCachingProvider.
+ * Defines the base methods of how to interact with this interface, but not the implementation of how to cache.
+ */
+export class IRouteCachingProvider {
+    constructor() {
+        /**
+         * Final implementation of the public `getCachedRoute` method, this is how code will interact with the implementation
+         *
+         * @public
+         * @readonly
+         * @param chainId
+         * @param amount
+         * @param quoteToken
+         * @param tradeType
+         * @param protocols
+         * @param blockNumber
+         */
+        this.getCachedRoute = async (// Defined as a readonly member instead of a regular function to make it final.
+        chainId, amount, quoteToken, tradeType, protocols, blockNumber) => {
+            if (await this.getCacheMode(chainId, amount, quoteToken, tradeType, protocols) == CacheMode.Darkmode) {
+                return undefined;
+            }
+            const cachedRoute = await this._getCachedRoute(chainId, amount, quoteToken, tradeType, protocols);
+            return this.filterExpiredCachedRoutes(cachedRoute, blockNumber);
+        };
+        /**
+         * Final implementation of the public `setCachedRoute` method.
+         * This method will set the blockToLive in the CachedRoutes object before calling the internal method to insert in cache.
+         *
+         * @public
+         * @readonly
+         * @param cachedRoutes The route to cache.
+         * @returns Promise<boolean> Indicates if the route was inserted into cache.
+         */
+        this.setCachedRoute = async (// Defined as a readonly member instead of a regular function to make it final.
+        cachedRoutes, amount) => {
+            if (await this.getCacheModeFromCachedRoutes(cachedRoutes, amount) == CacheMode.Darkmode) {
+                return false;
+            }
+            cachedRoutes.blocksToLive = await this._getBlocksToLive(cachedRoutes, amount);
+            return this._setCachedRoute(cachedRoutes, amount);
+        };
+    }
+    /**
+     * Returns the CacheMode for the given cachedRoutes and amount
+     *
+     * @param cachedRoutes
+     * @param amount
+     */
+    getCacheModeFromCachedRoutes(cachedRoutes, amount) {
+        const quoteToken = cachedRoutes.tradeType == TradeType.EXACT_INPUT ? cachedRoutes.tokenOut : cachedRoutes.tokenIn;
+        return this.getCacheMode(cachedRoutes.chainId, amount, quoteToken, cachedRoutes.tradeType, cachedRoutes.protocolsCovered);
+    }
+    filterExpiredCachedRoutes(cachedRoutes, blockNumber) {
+        return (cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.notExpired(blockNumber)) ? cachedRoutes : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/providers/caching-gas-provider.d.ts

@@ -0,0 +1,23 @@
+import { ChainId } from '../util/chains';
+import { ICache } from './cache';
+import { GasPrice, IGasPriceProvider } from './gas-price-provider';
+/**
+ * Provider for getting gas price, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV3SubgraphProvider
+ */
+export declare class CachingGasStationProvider implements IGasPriceProvider {
+    protected chainId: ChainId;
+    private gasPriceProvider;
+    private cache;
+    private GAS_KEY;
+    /**
+     * Creates an instance of CachingGasStationProvider.
+     * @param chainId The chain id to use.
+     * @param gasPriceProvider The provider to use to get the gas price when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     */
+    constructor(chainId: ChainId, gasPriceProvider: IGasPriceProvider, cache: ICache<GasPrice>);
+    getGasPrice(): Promise<GasPrice>;
+}

package/build/module/providers/caching-gas-provider.js

@@ -0,0 +1,33 @@
+import { log } from '../util/log';
+/**
+ * Provider for getting gas price, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV3SubgraphProvider
+ */
+export class CachingGasStationProvider {
+    /**
+     * Creates an instance of CachingGasStationProvider.
+     * @param chainId The chain id to use.
+     * @param gasPriceProvider The provider to use to get the gas price when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     */
+    constructor(chainId, gasPriceProvider, cache) {
+        this.chainId = chainId;
+        this.gasPriceProvider = gasPriceProvider;
+        this.cache = cache;
+        this.GAS_KEY = (chainId) => `gasPrice-${chainId}`;
+    }
+    async getGasPrice() {
+        const cachedGasPrice = await this.cache.get(this.GAS_KEY(this.chainId));
+        if (cachedGasPrice) {
+            log.info({ cachedGasPrice }, `Got gas station price from local cache: ${cachedGasPrice.gasPriceWei}.`);
+            return cachedGasPrice;
+        }
+        log.info('Gas station price local cache miss.');
+        const gasPrice = await this.gasPriceProvider.getGasPrice();
+        await this.cache.set(this.GAS_KEY(this.chainId), gasPrice);
+        return gasPrice;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1nYXMtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmctZ2FzLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFLbEM7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8seUJBQXlCO0lBR3BDOzs7OztPQUtHO0lBQ0gsWUFDWSxPQUFnQixFQUNsQixnQkFBbUMsRUFDbkMsS0FBdUI7UUFGckIsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNsQixxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQW1CO1FBQ25DLFVBQUssR0FBTCxLQUFLLENBQWtCO1FBWHpCLFlBQU8sR0FBRyxDQUFDLE9BQWdCLEVBQUUsRUFBRSxDQUFDLFlBQVksT0FBTyxFQUFFLENBQUM7SUFZM0QsQ0FBQztJQUVHLEtBQUssQ0FBQyxXQUFXO1FBQ3RCLE1BQU0sY0FBYyxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUV4RSxJQUFJLGNBQWMsRUFBRTtZQUNsQixHQUFHLENBQUMsSUFBSSxDQUNOLEVBQUUsY0FBYyxFQUFFLEVBQ2xCLDJDQUEyQyxjQUFjLENBQUMsV0FBVyxHQUFHLENBQ3pFLENBQUM7WUFFRixPQUFPLGNBQWMsQ0FBQztTQUN2QjtRQUVELEdBQUcsQ0FBQyxJQUFJLENBQUMscUNBQXFDLENBQUMsQ0FBQztRQUNoRCxNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUMzRCxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBRTNELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

package/build/module/providers/caching-token-list-provider.d.ts

@@ -0,0 +1,40 @@
+import { Token } from '@uniswap/sdk-core';
+import { TokenList } from '@uniswap/token-lists';
+import { ChainId } from '../util/chains';
+import { ICache } from './cache';
+import { ITokenProvider, TokenAccessor } from './token-provider';
+/**
+ * Provider for getting token data from a Token List.
+ *
+ * @export
+ * @interface ITokenListProvider
+ */
+export interface ITokenListProvider {
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+}
+export declare class CachingTokenListProvider implements ITokenProvider, ITokenListProvider {
+    private tokenCache;
+    private CACHE_KEY;
+    private chainId;
+    private chainToTokenInfos;
+    private chainSymbolToTokenInfo;
+    private chainAddressToTokenInfo;
+    private tokenList;
+    /**
+     * Creates an instance of CachingTokenListProvider.
+     * Token metadata (e.g. symbol and decimals) generally don't change so can be cached indefinitely.
+     *
+     * @param chainId The chain id to use.
+     * @param tokenList The token list to get the tokens from.
+     * @param tokenCache Cache instance to hold cached tokens.
+     */
+    constructor(chainId: ChainId | number, tokenList: TokenList, tokenCache: ICache<Token>);
+    static fromTokenListURI(chainId: ChainId | number, tokenListURI: string, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    private static buildTokenList;
+    static fromTokenList(chainId: ChainId | number, tokenList: TokenList, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    getTokens(_addresses: string[]): Promise<TokenAccessor>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+    private buildToken;
+}