@fanx-protocol/smart-order-router 0.0.1

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

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedRoutes = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const cached_route_1 = require("./cached-route");
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+class CachedRoutes {
+    /**
+     * @param routes
+     * @param chainId
+     * @param currencyIn
+     * @param currencyOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     * @param originalAmount
+     * @param blocksToLive
+     */
+    constructor({ routes, chainId, currencyIn, currencyOut, protocolsCovered, blockNumber, tradeType, originalAmount, blocksToLive = 0, }) {
+        this.routes = routes;
+        this.chainId = chainId;
+        this.currencyIn = currencyIn;
+        this.currencyOut = currencyOut;
+        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 currencyIn
+     * @param currencyOut
+     * @param protocolsCovered
+     * @param blockNumber
+     * @param tradeType
+     * @param originalAmount
+     */
+    static fromRoutesWithValidQuotes(routes, chainId, currencyIn, currencyOut, protocolsCovered, blockNumber, tradeType, originalAmount) {
+        if (routes.length == 0)
+            return undefined;
+        const cachedRoutes = lodash_1.default.map(routes, (route) => new cached_route_1.CachedRoute({ route: route.route, percent: route.percent }));
+        return new CachedRoutes({
+            routes: cachedRoutes,
+            chainId,
+            currencyIn,
+            currencyOut,
+            protocolsCovered,
+            blockNumber,
+            tradeType,
+            originalAmount,
+        });
+    }
+    /**
+     * Function to determine if, given a block number, the CachedRoute is expired or not.
+     *
+     * @param currentBlockNumber
+     * @param optimistic
+     */
+    notExpired(currentBlockNumber, optimistic = false) {
+        // When it's not optimistic, we only allow the route of the existing block.
+        const blocksToLive = optimistic ? this.blocksToLive : 0;
+        const blocksDifference = currentBlockNumber - this.blockNumber;
+        return blocksDifference <= blocksToLive;
+    }
+}
+exports.CachedRoutes = CachedRoutes;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkLXJvdXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGluZy9yb3V0ZS9tb2RlbC9jYWNoZWQtcm91dGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUVBLG9EQUF1QjtBQUl2QixpREFBNkM7QUFjN0M7Ozs7O0dBS0c7QUFDSCxNQUFhLFlBQVk7SUFZdkI7Ozs7Ozs7Ozs7T0FVRztJQUNILFlBQVksRUFDVixNQUFNLEVBQ04sT0FBTyxFQUNQLFVBQVUsRUFDVixXQUFXLEVBQ1gsZ0JBQWdCLEVBQ2hCLFdBQVcsRUFDWCxTQUFTLEVBQ1QsY0FBYyxFQUNkLFlBQVksR0FBRyxDQUFDLEdBQ0c7UUFDbkIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGdCQUFnQixDQUFDO1FBQ3pDLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzNCLElBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxDQUFDO1FBQ3JDLElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO0lBQ25DLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7OztPQWFHO0lBQ0ksTUFBTSxDQUFDLHlCQUF5QixDQUNyQyxNQUE2QixFQUM3QixPQUFnQixFQUNoQixVQUFvQixFQUNwQixXQUFxQixFQUNyQixnQkFBNEIsRUFDNUIsV0FBbUIsRUFDbkIsU0FBb0IsRUFDcEIsY0FBc0I7UUFFdEIsSUFBSSxNQUFNLENBQUMsTUFBTSxJQUFJLENBQUM7WUFBRSxPQUFPLFNBQVMsQ0FBQztRQUV6QyxNQUFNLFlBQVksR0FBRyxnQkFBQyxDQUFDLEdBQUcsQ0FDeEIsTUFBTSxFQUNOLENBQUMsS0FBMEIsRUFBRSxFQUFFLENBQzdCLElBQUksMEJBQVcsQ0FBQyxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUMsS0FBSyxFQUFFLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FDbEUsQ0FBQztRQUVGLE9BQU8sSUFBSSxZQUFZLENBQUM7WUFDdEIsTUFBTSxFQUFFLFlBQVk7WUFDcEIsT0FBTztZQUNQLFVBQVU7WUFDVixXQUFXO1lBQ1gsZ0JBQWdCO1lBQ2hCLFdBQVc7WUFDWCxTQUFTO1lBQ1QsY0FBYztTQUNmLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNJLFVBQVUsQ0FBQyxrQkFBMEIsRUFBRSxVQUFVLEdBQUcsS0FBSztRQUM5RCwyRUFBMkU7UUFDM0UsTUFBTSxZQUFZLEdBQUcsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDeEQsTUFBTSxnQkFBZ0IsR0FBRyxrQkFBa0IsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDO1FBRS9ELE9BQU8sZ0JBQWdCLElBQUksWUFBWSxDQUFDO0lBQzFDLENBQUM7Q0FDRjtBQXRHRCxvQ0FzR0MifQ==

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache-mode"), exports);
+__exportStar(require("./cached-route"), exports);
+__exportStar(require("./cached-routes"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmcvcm91dGUvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtDQUE2QjtBQUM3QixpREFBK0I7QUFDL0Isa0RBQWdDIn0=

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

@@ -0,0 +1,88 @@
+/**
+ * Provider for getting currency data from a currency List.
+ *
+ * @export
+ * @interface IRouteCachingProvider
+ */
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { ChainId, Currency, CurrencyAmount, TradeType } from '@fanx-protocol/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 quoteCurrency
+     * @param tradeType
+     * @param protocols
+     * @param blockNumber
+     */
+    readonly getCachedRoute: (chainId: number, amount: CurrencyAmount<Currency>, quoteCurrency: Currency, tradeType: TradeType, protocols: Protocol[], blockNumber: number, optimistic?: boolean) => 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, currencyIn, currencyOut and tradetype
+     *
+     * @public
+     * @abstract
+     * @param chainId
+     * @param amount
+     * @param tradeType
+     */
+    abstract getCacheMode(chainId: ChainId, amount: CurrencyAmount<Currency>, quoteCurrency: Currency, tradeType: TradeType, protocols: Protocol[]): Promise<CacheMode>;
+    protected filterExpiredCachedRoutes(cachedRoutes: CachedRoutes | undefined, blockNumber: number, optimistic: boolean): CachedRoutes | undefined;
+    /**
+     * Internal function to fetch the CachedRoute from the cache.
+     * Must be implemented.
+     *
+     * @param chainId
+     * @param amount
+     * @param quoteCurrency
+     * @param tradeType
+     * @param protocols
+     * @protected
+     */
+    protected abstract _getCachedRoute(chainId: ChainId, amount: CurrencyAmount<Currency>, quoteCurrency: Currency, tradeType: TradeType, protocols: Protocol[], currentBlockNumber: number, optimistic: boolean): 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/main/providers/caching/route/route-caching-provider.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRouteCachingProvider = void 0;
+const sdk_core_1 = require("@fanx-protocol/sdk-core");
+const model_1 = require("./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.
+ */
+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 quoteCurrency
+         * @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, quoteCurrency, tradeType, protocols, blockNumber, optimistic = false) => {
+            if ((await this.getCacheMode(chainId, amount, quoteCurrency, tradeType, protocols)) == model_1.CacheMode.Darkmode) {
+                return undefined;
+            }
+            const cachedRoute = await this._getCachedRoute(chainId, amount, quoteCurrency, tradeType, protocols, blockNumber, optimistic);
+            return this.filterExpiredCachedRoutes(cachedRoute, blockNumber, optimistic);
+        };
+        /**
+         * 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)) ==
+                model_1.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 quoteCurrency = cachedRoutes.tradeType == sdk_core_1.TradeType.EXACT_INPUT
+            ? cachedRoutes.currencyOut
+            : cachedRoutes.currencyIn;
+        return this.getCacheMode(cachedRoutes.chainId, amount, quoteCurrency, cachedRoutes.tradeType, cachedRoutes.protocolsCovered);
+    }
+    filterExpiredCachedRoutes(cachedRoutes, blockNumber, optimistic) {
+        return (cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.notExpired(blockNumber, optimistic))
+            ? cachedRoutes
+            : undefined;
+    }
+}
+exports.IRouteCachingProvider = IRouteCachingProvider;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+import { ChainId } from '@fanx-protocol/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 extends 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(latestBlockNumber: number, requestBlockNumber?: number): Promise<GasPrice>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingGasStationProvider = void 0;
+const log_1 = require("../util/log");
+const gas_price_provider_1 = require("./gas-price-provider");
+/**
+ * Provider for getting gas price, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV3SubgraphProvider
+ */
+class CachingGasStationProvider extends gas_price_provider_1.IGasPriceProvider {
+    /**
+     * 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) {
+        super();
+        this.chainId = chainId;
+        this.gasPriceProvider = gasPriceProvider;
+        this.cache = cache;
+        this.GAS_KEY = (chainId, blockNumber) => `gasPrice-${chainId}-${blockNumber}`;
+    }
+    async getGasPrice(latestBlockNumber, requestBlockNumber) {
+        // If block number is specified in the request, we have to use that block number find any potential cache hits.
+        // Otherwise, we can use the latest block number.
+        const targetBlockNumber = requestBlockNumber !== null && requestBlockNumber !== void 0 ? requestBlockNumber : latestBlockNumber;
+        const cachedGasPrice = await this.cache.get(this.GAS_KEY(this.chainId, targetBlockNumber));
+        if (cachedGasPrice) {
+            log_1.log.info({ cachedGasPrice }, `Got gas station price from local cache: ${cachedGasPrice.gasPriceWei}.`);
+            return cachedGasPrice;
+        }
+        const gasPrice = await this.gasPriceProvider.getGasPrice(latestBlockNumber, requestBlockNumber);
+        await this.cache.set(this.GAS_KEY(this.chainId, targetBlockNumber), gasPrice);
+        return gasPrice;
+    }
+}
+exports.CachingGasStationProvider = CachingGasStationProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1nYXMtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmctZ2FzLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLHFDQUFrQztBQUdsQyw2REFBbUU7QUFFbkU7Ozs7O0dBS0c7QUFDSCxNQUFhLHlCQUEwQixTQUFRLHNDQUFpQjtJQUk5RDs7Ozs7T0FLRztJQUNILFlBQ1ksT0FBZ0IsRUFDbEIsZ0JBQW1DLEVBQ25DLEtBQXVCO1FBRS9CLEtBQUssRUFBRSxDQUFDO1FBSkUsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNsQixxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQW1CO1FBQ25DLFVBQUssR0FBTCxLQUFLLENBQWtCO1FBWnpCLFlBQU8sR0FBRyxDQUFDLE9BQWdCLEVBQUUsV0FBbUIsRUFBRSxFQUFFLENBQzFELFlBQVksT0FBTyxJQUFJLFdBQVcsRUFBRSxDQUFDO0lBY3ZDLENBQUM7SUFFZSxLQUFLLENBQUMsV0FBVyxDQUMvQixpQkFBeUIsRUFDekIsa0JBQTJCO1FBRTNCLCtHQUErRztRQUMvRyxpREFBaUQ7UUFDakQsTUFBTSxpQkFBaUIsR0FBRyxrQkFBa0IsYUFBbEIsa0JBQWtCLGNBQWxCLGtCQUFrQixHQUFJLGlCQUFpQixDQUFDO1FBQ2xFLE1BQU0sY0FBYyxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQ3pDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxpQkFBaUIsQ0FBQyxDQUM5QyxDQUFDO1FBRUYsSUFBSSxjQUFjLEVBQUU7WUFDbEIsU0FBRyxDQUFDLElBQUksQ0FDTixFQUFFLGNBQWMsRUFBRSxFQUNsQiwyQ0FBMkMsY0FBYyxDQUFDLFdBQVcsR0FBRyxDQUN6RSxDQUFDO1lBRUYsT0FBTyxjQUFjLENBQUM7U0FDdkI7UUFFRCxNQUFNLFFBQVEsR0FBRyxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxXQUFXLENBQ3RELGlCQUFpQixFQUNqQixrQkFBa0IsQ0FDbkIsQ0FBQztRQUNGLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQ2xCLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxpQkFBaUIsQ0FBQyxFQUM3QyxRQUFRLENBQ1QsQ0FBQztRQUVGLE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRjtBQWpERCw4REFpREMifQ==

package/build/main/providers/caching-subgraph-provider.d.ts

@@ -0,0 +1,33 @@
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { ChainId, Token } from '@fanx-protocol/sdk-core';
+import { SubgraphPool } from '../routers/alpha-router/functions/get-candidate-pools';
+import { ICache } from './cache';
+import { ProviderConfig } from './provider';
+import { V3SubgraphPool } from './v3/subgraph-provider';
+declare type ChainTokenList = {
+    readonly [chainId in ChainId]: Token[];
+};
+export declare const BASES_TO_CHECK_TRADES_AGAINST: ChainTokenList;
+export interface IV3SubgraphProvider {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<V3SubgraphPool[]>;
+}
+export interface ISubgraphProvider<TSubgraphPool extends SubgraphPool> {
+    getPools(tokenIn?: Token, tokenOut?: Token, providerConfig?: ProviderConfig): Promise<TSubgraphPool[]>;
+}
+export declare abstract class CachingSubgraphProvider<TSubgraphPool extends SubgraphPool> implements ISubgraphProvider<TSubgraphPool> {
+    private chainId;
+    protected subgraphProvider: ISubgraphProvider<TSubgraphPool>;
+    private cache;
+    private protocol;
+    private SUBGRAPH_KEY;
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     * @param protocol Subgraph protocol version
+     */
+    constructor(chainId: ChainId, subgraphProvider: ISubgraphProvider<TSubgraphPool>, cache: ICache<TSubgraphPool[]>, protocol: Protocol);
+    getPools(): Promise<TSubgraphPool[]>;
+}
+export {};

package/build/main/providers/caching-subgraph-provider.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingSubgraphProvider = exports.BASES_TO_CHECK_TRADES_AGAINST = void 0;
+const sdk_core_1 = require("@fanx-protocol/sdk-core");
+const util_1 = require("../util");
+const token_provider_1 = require("./token-provider");
+exports.BASES_TO_CHECK_TRADES_AGAINST = {
+    [sdk_core_1.ChainId.SPICY]: [util_1.WRAPPED_NATIVE_CURRENCY[sdk_core_1.ChainId.SPICY], token_provider_1.USDC_SPICY],
+    [sdk_core_1.ChainId.CHILIZ]: [util_1.WRAPPED_NATIVE_CURRENCY[sdk_core_1.ChainId.CHILIZ], token_provider_1.USDC_CHILIZ],
+};
+class CachingSubgraphProvider {
+    /**
+     * Creates an instance of CachingV3SubgraphProvider.
+     * @param chainId The chain id to use.
+     * @param subgraphProvider The provider to use to get the subgraph pools when not in the cache.
+     * @param cache Cache instance to hold cached pools.
+     * @param protocol Subgraph protocol version
+     */
+    constructor(chainId, subgraphProvider, cache, protocol) {
+        this.chainId = chainId;
+        this.subgraphProvider = subgraphProvider;
+        this.cache = cache;
+        this.protocol = protocol;
+        this.SUBGRAPH_KEY = (chainId) => `subgraph-pools-${this.protocol}-${chainId}`;
+    }
+    async getPools() {
+        const cachedPools = await this.cache.get(this.SUBGRAPH_KEY(this.chainId));
+        if (cachedPools) {
+            return cachedPools;
+        }
+        const pools = await this.subgraphProvider.getPools();
+        await this.cache.set(this.SUBGRAPH_KEY(this.chainId), pools);
+        return pools;
+    }
+}
+exports.CachingSubgraphProvider = CachingSubgraphProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGluZy1zdWJncmFwaC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxzREFBeUQ7QUFHekQsa0NBQWtEO0FBSWxELHFEQUEyRDtBQU85QyxRQUFBLDZCQUE2QixHQUFtQjtJQUMzRCxDQUFDLGtCQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyw4QkFBdUIsQ0FBQyxrQkFBTyxDQUFDLEtBQUssQ0FBRSxFQUFFLDJCQUFVLENBQUM7SUFDdEUsQ0FBQyxrQkFBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsOEJBQXVCLENBQUMsa0JBQU8sQ0FBQyxNQUFNLENBQUUsRUFBRSw0QkFBVyxDQUFDO0NBQzFFLENBQUM7QUFrQkYsTUFBc0IsdUJBQXVCO0lBTzNDOzs7Ozs7T0FNRztJQUNILFlBQ1UsT0FBZ0IsRUFDZCxnQkFBa0QsRUFDcEQsS0FBOEIsRUFDOUIsUUFBa0I7UUFIbEIsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUNkLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBa0M7UUFDcEQsVUFBSyxHQUFMLEtBQUssQ0FBeUI7UUFDOUIsYUFBUSxHQUFSLFFBQVEsQ0FBVTtRQWRwQixpQkFBWSxHQUFHLENBQUMsT0FBZ0IsRUFBRSxFQUFFLENBQzFDLGtCQUFrQixJQUFJLENBQUMsUUFBUSxJQUFJLE9BQU8sRUFBRSxDQUFDO0lBYzVDLENBQUM7SUFFRyxLQUFLLENBQUMsUUFBUTtRQUNuQixNQUFNLFdBQVcsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7UUFFMUUsSUFBSSxXQUFXLEVBQUU7WUFDZixPQUFPLFdBQVcsQ0FBQztTQUNwQjtRQUVELE1BQU0sS0FBSyxHQUFHLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxDQUFDO1FBRXJELE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFFN0QsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBQ0Y7QUFsQ0QsMERBa0NDIn0=

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

@@ -0,0 +1,52 @@
+import { ChainId, Token } from '@fanx-protocol/sdk-core';
+import { TokenList } from '@uniswap/token-lists';
+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 {
+    hasTokenBySymbol(_symbol: string): Promise<boolean>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    hasTokenByAddress(address: string): Promise<boolean>;
+    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;
+    private CHAIN_SYMBOL_KEY;
+    private CHAIN_ADDRESS_KEY;
+    /**
+     * 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>;
+    /**
+     * If no addresses array is specified, all tokens in the token list are
+     * returned.
+     *
+     * @param _addresses (optional) The token addresses to get.
+     * @returns Promise<TokenAccessor> A token accessor with methods for accessing the tokens.
+     */
+    getTokens(_addresses?: string[]): Promise<TokenAccessor>;
+    hasTokenBySymbol(_symbol: string): Promise<boolean>;
+    getTokenBySymbol(_symbol: string): Promise<Token | undefined>;
+    hasTokenByAddress(address: string): Promise<boolean>;
+    getTokenByAddress(address: string): Promise<Token | undefined>;
+    private buildToken;
+}

package/build/main/providers/caching-token-list-provider.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingTokenListProvider = void 0;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const sdk_core_1 = require("@fanx-protocol/sdk-core");
+const axios_1 = __importDefault(require("axios"));
+const log_1 = require("../util/log");
+const metric_1 = require("../util/metric");
+class CachingTokenListProvider {
+    /**
+     * 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, tokenList, tokenCache) {
+        this.tokenCache = tokenCache;
+        this.CACHE_KEY = (tokenInfo) => `token-list-token-${this.chainId}/${this.tokenList.name}/${this.tokenList.timestamp}/${this.tokenList.version}/${tokenInfo.address.toLowerCase()}/${tokenInfo.decimals}/${tokenInfo.symbol}/${tokenInfo.name}`;
+        this.CHAIN_SYMBOL_KEY = (chainId, symbol) => `${chainId.toString()}/${symbol}`;
+        this.CHAIN_ADDRESS_KEY = (chainId, address) => `${chainId.toString()}/${address.toLowerCase()}`;
+        this.chainId = chainId;
+        this.tokenList = tokenList;
+        this.chainToTokenInfos = new Map();
+        this.chainSymbolToTokenInfo = new Map();
+        this.chainAddressToTokenInfo = new Map();
+        for (const tokenInfo of this.tokenList.tokens) {
+            const chainId = tokenInfo.chainId;
+            const chainIdString = chainId.toString();
+            const symbol = tokenInfo.symbol;
+            const address = tokenInfo.address.toLowerCase();
+            if (!this.chainToTokenInfos.has(chainIdString)) {
+                this.chainToTokenInfos.set(chainIdString, []);
+            }
+            this.chainToTokenInfos.get(chainIdString).push(tokenInfo);
+            this.chainSymbolToTokenInfo.set(this.CHAIN_SYMBOL_KEY(chainId, symbol), tokenInfo);
+            this.chainAddressToTokenInfo.set(this.CHAIN_ADDRESS_KEY(chainId, address), tokenInfo);
+        }
+    }
+    static async fromTokenListURI(chainId, tokenListURI, tokenCache) {
+        const now = Date.now();
+        const tokenList = await this.buildTokenList(tokenListURI);
+        metric_1.metric.putMetric('TokenListLoad', Date.now() - now, metric_1.MetricLoggerUnit.Milliseconds);
+        return new CachingTokenListProvider(chainId, tokenList, tokenCache);
+    }
+    static async buildTokenList(tokenListURI) {
+        log_1.log.info(`Getting tokenList from ${tokenListURI}.`);
+        const response = await axios_1.default.get(tokenListURI);
+        log_1.log.info(`Got tokenList from ${tokenListURI}.`);
+        const { data: tokenList, status } = response;
+        if (status != 200) {
+            log_1.log.error({ response }, `Unabled to get token list from ${tokenListURI}.`);
+            throw new Error(`Unable to get token list from ${tokenListURI}`);
+        }
+        return tokenList;
+    }
+    static async fromTokenList(chainId, tokenList, tokenCache) {
+        const now = Date.now();
+        const tokenProvider = new CachingTokenListProvider(chainId, tokenList, tokenCache);
+        metric_1.metric.putMetric('TokenListLoad', Date.now() - now, metric_1.MetricLoggerUnit.Milliseconds);
+        return tokenProvider;
+    }
+    /**
+     * If no addresses array is specified, all tokens in the token list are
+     * returned.
+     *
+     * @param _addresses (optional) The token addresses to get.
+     * @returns Promise<TokenAccessor> A token accessor with methods for accessing the tokens.
+     */
+    async getTokens(_addresses) {
+        var _a;
+        const addressToToken = new Map();
+        const symbolToToken = new Map();
+        const addToken = (token) => {
+            if (!token)
+                return;
+            addressToToken.set(token.address.toLowerCase(), token);
+            if (token.symbol !== undefined) {
+                symbolToToken.set(token.symbol.toLowerCase(), token);
+            }
+        };
+        if (_addresses) {
+            for (const address of _addresses) {
+                const token = await this.getTokenByAddress(address);
+                addToken(token);
+            }
+        }
+        else {
+            const chainTokens = (_a = this.chainToTokenInfos.get(this.chainId.toString())) !== null && _a !== void 0 ? _a : [];
+            for (const info of chainTokens) {
+                const token = await this.buildToken(info);
+                addToken(token);
+            }
+        }
+        return {
+            getTokenByAddress: (address) => addressToToken.get(address.toLowerCase()),
+            getTokenBySymbol: (symbol) => symbolToToken.get(symbol.toLowerCase()),
+            getAllTokens: () => {
+                return Array.from(addressToToken.values());
+            },
+        };
+    }
+    async hasTokenBySymbol(_symbol) {
+        return this.chainSymbolToTokenInfo.has(this.CHAIN_SYMBOL_KEY(this.chainId, _symbol));
+    }
+    async getTokenBySymbol(_symbol) {
+        let symbol = _symbol;
+        // We consider ETH as a regular ERC20 Token throughout this package. We don't use the NativeCurrency object from the sdk.
+        // When we build the calldata for swapping we insert wrapping/unwrapping as needed.
+        if (_symbol == 'ETH') {
+            symbol = 'WETH';
+        }
+        const tokenInfo = this.chainSymbolToTokenInfo.get(this.CHAIN_SYMBOL_KEY(this.chainId, symbol));
+        if (!tokenInfo) {
+            return undefined;
+        }
+        const token = await this.buildToken(tokenInfo);
+        return token;
+    }
+    async hasTokenByAddress(address) {
+        return this.chainAddressToTokenInfo.has(this.CHAIN_ADDRESS_KEY(this.chainId, address));
+    }
+    async getTokenByAddress(address) {
+        const tokenInfo = this.chainAddressToTokenInfo.get(this.CHAIN_ADDRESS_KEY(this.chainId, address));
+        if (!tokenInfo) {
+            return undefined;
+        }
+        const token = await this.buildToken(tokenInfo);
+        return token;
+    }
+    async buildToken(tokenInfo) {
+        const cacheKey = this.CACHE_KEY(tokenInfo);
+        const cachedToken = await this.tokenCache.get(cacheKey);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        const token = new sdk_core_1.Token(this.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
+        await this.tokenCache.set(cacheKey, token);
+        return token;
+    }
+}
+exports.CachingTokenListProvider = CachingTokenListProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/providers/caching-token-provider.d.ts

@@ -0,0 +1,24 @@
+import { ChainId, Token } from '@fanx-protocol/sdk-core';
+import { ICache } from './cache';
+import { ITokenProvider, TokenAccessor } from './token-provider';
+export declare const CACHE_SEED_TOKENS: {
+    [chainId in ChainId]?: {
+        [symbol: string]: Token;
+    };
+};
+/**
+ * Provider for getting token metadata that falls back to a different provider
+ * in the event of failure.
+ *
+ * @export
+ * @class CachingTokenProviderWithFallback
+ */
+export declare class CachingTokenProviderWithFallback implements ITokenProvider {
+    protected chainId: ChainId;
+    private tokenCache;
+    protected primaryTokenProvider: ITokenProvider;
+    protected fallbackTokenProvider?: ITokenProvider | undefined;
+    private CACHE_KEY;
+    constructor(chainId: ChainId, tokenCache: ICache<Token>, primaryTokenProvider: ITokenProvider, fallbackTokenProvider?: ITokenProvider | undefined);
+    getTokens(_addresses: string[]): Promise<TokenAccessor>;
+}