@synthra-swap/smart-order-router 3.15.0

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 '@synthra-swap/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,66 @@
+import { Protocol } from '@uniswap/router-sdk';
+import { ChainId, Token, TradeType } from '@synthra-swap/sdk-core';
+import { MixedRoute, RouteWithValidQuote, V2Route, V3Route } from '../../../../routers';
+import { CachedRoute } from './cached-route';
+interface CachedRoutesParams {
+    routes: CachedRoute<V3Route | V2Route | MixedRoute>[];
+    chainId: ChainId;
+    tokenIn: Token;
+    tokenOut: Token;
+    protocolsCovered: Protocol[];
+    blockNumber: number;
+    tradeType: TradeType;
+    originalAmount: string;
+    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;
+    readonly originalAmount: string;
+    blocksToLive: number;
+    /**
+     * @param routes
+     * @param chainId
+     * @param tokenIn
+     * @param tokenOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     * @param originalAmount
+     * @param blocksToLive
+     */
+    constructor({ routes, chainId, tokenIn, tokenOut, protocolsCovered, blockNumber, tradeType, originalAmount, 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
+     * @param originalAmount
+     */
+    static fromRoutesWithValidQuotes(routes: RouteWithValidQuote[], chainId: ChainId, tokenIn: Token, tokenOut: Token, protocolsCovered: Protocol[], blockNumber: number, tradeType: TradeType, originalAmount: string): 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,70 @@
+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 originalAmount
+     * @param blocksToLive
+     */
+    constructor({ routes, chainId, tokenIn, tokenOut, protocolsCovered, blockNumber, tradeType, originalAmount, blocksToLive = 0, }) {
+        this.routes = routes;
+        this.chainId = chainId;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+        this.protocolsCovered = protocolsCovered;
+        this.blockNumber = blockNumber;
+        this.tradeType = tradeType;
+        this.originalAmount = originalAmount;
+        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
+     * @param originalAmount
+     */
+    static fromRoutesWithValidQuotes(routes, chainId, tokenIn, tokenOut, protocolsCovered, blockNumber, tradeType, originalAmount) {
+        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,
+            tokenIn,
+            tokenOut,
+            protocolsCovered,
+            blockNumber,
+            tradeType,
+            originalAmount,
+        });
+    }
+    /**
+     * 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLXJvdXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGluZy9yb3V0ZS9tb2RlbC9jYWNoZWQtcm91dGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sQ0FBQyxNQUFNLFFBQVEsQ0FBQztBQVN2QixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFjN0M7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQVl2Qjs7Ozs7Ozs7OztPQVVHO0lBQ0gsWUFBWSxFQUNWLE1BQU0sRUFDTixPQUFPLEVBQ1AsT0FBTyxFQUNQLFFBQVEsRUFDUixnQkFBZ0IsRUFDaEIsV0FBVyxFQUNYLFNBQVMsRUFDVCxjQUFjLEVBQ2QsWUFBWSxHQUFHLENBQUMsR0FDRztRQUNuQixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztRQUN6QixJQUFJLENBQUMsZ0JBQWdCLEdBQUcsZ0JBQWdCLENBQUM7UUFDekMsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7UUFDckMsSUFBSSxDQUFDLFlBQVksR0FBRyxZQUFZLENBQUM7SUFDbkMsQ0FBQztJQUVEOzs7Ozs7Ozs7Ozs7O09BYUc7SUFDSSxNQUFNLENBQUMseUJBQXlCLENBQ3JDLE1BQTZCLEVBQzdCLE9BQWdCLEVBQ2hCLE9BQWMsRUFDZCxRQUFlLEVBQ2YsZ0JBQTRCLEVBQzVCLFdBQW1CLEVBQ25CLFNBQW9CLEVBQ3BCLGNBQXNCO1FBRXRCLElBQUksTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDO1lBQUUsT0FBTyxTQUFTLENBQUM7UUFFekMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FDeEIsTUFBTSxFQUNOLENBQUMsS0FBMEIsRUFBRSxFQUFFLENBQzdCLElBQUksV0FBVyxDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUNsRSxDQUFDO1FBRUYsT0FBTyxJQUFJLFlBQVksQ0FBQztZQUN0QixNQUFNLEVBQUUsWUFBWTtZQUNwQixPQUFPO1lBQ1AsT0FBTztZQUNQLFFBQVE7WUFDUixnQkFBZ0I7WUFDaEIsV0FBVztZQUNYLFNBQVM7WUFDVCxjQUFjO1NBQ2YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxVQUFVLENBQUMsa0JBQTBCO1FBQzFDLE9BQU8sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLFdBQVcsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDO0lBQ3BFLENBQUM7Q0FDRiJ9

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,90 @@
+/**
+ * Provider for getting token data from a Token List.
+ *
+ * @export
+ * @interface IRouteCachingProvider
+ */
+import { Protocol } from '@uniswap/router-sdk';
+import { ChainId, Currency, CurrencyAmount, Token, TradeType } from '@synthra-swap/sdk-core';
+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,66 @@
+import { TradeType, } from '@synthra-swap/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 '@synthra-swap/sdk-core';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1nYXMtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmctZ2FzLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFLbEM7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8seUJBQXlCO0lBR3BDOzs7OztPQUtHO0lBQ0gsWUFDWSxPQUFnQixFQUNsQixnQkFBbUMsRUFDbkMsS0FBdUI7UUFGckIsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNsQixxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQW1CO1FBQ25DLFVBQUssR0FBTCxLQUFLLENBQWtCO1FBWHpCLFlBQU8sR0FBRyxDQUFDLE9BQWdCLEVBQUUsRUFBRSxDQUFDLFlBQVksT0FBTyxFQUFFLENBQUM7SUFZM0QsQ0FBQztJQUVHLEtBQUssQ0FBQyxXQUFXO1FBQ3RCLE1BQU0sY0FBYyxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUV4RSxJQUFJLGNBQWMsRUFBRTtZQUNsQixHQUFHLENBQUMsSUFBSSxDQUNOLEVBQUUsY0FBYyxFQUFFLEVBQ2xCLDJDQUEyQyxjQUFjLENBQUMsV0FBVyxHQUFHLENBQ3pFLENBQUM7WUFFRixPQUFPLGNBQWMsQ0FBQztTQUN2QjtRQUVELEdBQUcsQ0FBQyxJQUFJLENBQUMscUNBQXFDLENBQUMsQ0FBQztRQUNoRCxNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUMzRCxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBRTNELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,40 @@
+import { TokenList } from '@uniswap/token-lists';
+import { Token } from '@synthra-swap/sdk-core';
+import { SupportedIds } from '../util';
+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: SupportedIds | number, tokenList: TokenList, tokenCache: ICache<Token>);
+    static fromTokenListURI(chainId: SupportedIds | number, tokenListURI: string, tokenCache: ICache<Token>): Promise<CachingTokenListProvider>;
+    private static buildTokenList;
+    static fromTokenList(chainId: SupportedIds | 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;
+}