@fanx-protocol/smart-order-router 0.0.1

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,10 @@
+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>;
+    batchGet(keys: Set<string>): Promise<Record<string, T | undefined>>;
+    set(key: string, value: T, ttl?: number): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+}

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

@@ -0,0 +1,29 @@
+export class NodeJSCache {
+    constructor(nodeCache) {
+        this.nodeCache = nodeCache;
+    }
+    async get(key) {
+        return this.nodeCache.get(key);
+    }
+    async batchGet(keys) {
+        const keysArr = Array.from(keys);
+        const values = await Promise.all(keysArr.map((key) => this.get(key)));
+        const result = {};
+        keysArr.forEach((key, index) => {
+            result[key] = values[index];
+        });
+        return result;
+    }
+    async set(key, value, ttl) {
+        if (ttl) {
+            return this.nodeCache.set(key, value, ttl);
+        }
+        else {
+            return this.nodeCache.set(key, value);
+        }
+    }
+    async has(key) {
+        return this.nodeCache.has(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtbm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcm92aWRlcnMvY2FjaGUtbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sV0FBVztJQUN0QixZQUFvQixTQUFvQjtRQUFwQixjQUFTLEdBQVQsU0FBUyxDQUFXO0lBQUcsQ0FBQztJQUU1QyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQVc7UUFDbkIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBSSxHQUFHLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQsS0FBSyxDQUFDLFFBQVEsQ0FBQyxJQUFpQjtRQUM5QixNQUFNLE9BQU8sR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pDLE1BQU0sTUFBTSxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUV0RSxNQUFNLE1BQU0sR0FBa0MsRUFBRSxDQUFDO1FBRWpELE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxFQUFFLEVBQUU7WUFDN0IsTUFBTSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM5QixDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQVcsRUFBRSxLQUFRLEVBQUUsR0FBWTtRQUMzQyxJQUFJLEdBQUcsRUFBRTtZQUNQLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztTQUM1QzthQUFNO1lBQ0wsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7U0FDdkM7SUFDSCxDQUFDO0lBRUQsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFXO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDakMsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,14 @@
+/**
+ * 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>;
+    batchGet(keys: Set<string>): Promise<Record<string, T | undefined>>;
+    set(key: string, value: T, ttl?: number): 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 './model/';
+export * from './route-caching-provider';

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

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

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,29 @@
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { Token } from '@fanx-protocol/sdk-core';
+import { SupportedRoutes } from '../../../../routers';
+interface CachedRouteParams<Route extends SupportedRoutes> {
+    route: Route;
+    percent: number;
+}
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+export declare class CachedRoute<Route extends SupportedRoutes> {
+    readonly route: Route;
+    readonly percent: number;
+    private hashCode;
+    /**
+     * @param route
+     * @param percent
+     */
+    constructor({ route, percent }: CachedRouteParams<Route>);
+    get protocol(): Protocol;
+    get tokenIn(): Token;
+    get tokenOut(): Token;
+    get routePath(): string;
+    get routeId(): number;
+}
+export {};

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

@@ -0,0 +1,85 @@
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { Pair } from '@fanx-protocol/v2-sdk';
+import { Pool as V3Pool } from '@fanx-protocol/v3-sdk';
+/**
+ * Class defining the route to cache
+ *
+ * @export
+ * @class CachedRoute
+ */
+export class CachedRoute {
+    /**
+     * @param route
+     * @param percent
+     */
+    constructor({ route, percent }) {
+        // Hashing function copying the same implementation as Java's `hashCode`
+        // Sourced from: https://gist.github.com/hyamamoto/fd435505d29ebfa3d9716fd2be8d42f0?permalink_comment_id=4613539#gistcomment-4613539
+        this.hashCode = (str) => [...str].reduce((s, c) => (Math.imul(31, s) + c.charCodeAt(0)) | 0, 0);
+        this.route = route;
+        this.percent = percent;
+    }
+    get protocol() {
+        return this.route.protocol;
+    }
+    // TODO: ROUTE-217 - Support native currency routing in V4
+    get tokenIn() {
+        return this.route.input.wrapped;
+    }
+    // TODO: ROUTE-217 - Support native currency routing in V4
+    get tokenOut() {
+        return this.route.output.wrapped;
+    }
+    get routePath() {
+        switch (this.protocol) {
+            // case Protocol.V4:
+            //   // TODO: ROUTE-217 - Support native currency routing in V4
+            //   return (this.route as V4Route).pools
+            //     .map(
+            //       (pool) =>
+            //         `[V4]${pool.token0.wrapped.address}/${pool.token1.wrapped.address}`
+            //     )
+            //     .join('->');
+            case Protocol.V3:
+                return this.route.pools
+                    .map((pool) => `[V3]${pool.token0.address}/${pool.token1.address}/${pool.fee}`)
+                    .join('->');
+            case Protocol.V2:
+                return this.route.pairs
+                    .map((pair) => `[V2]${pair.token0.address}/${pair.token1.address}`)
+                    .join('->');
+            case Protocol.MIXED:
+                return this.route.pools
+                    .map((pool) => {
+                    // if (pool instanceof V4Pool) {
+                    //   // TODO: ROUTE-217 - Support native currency routing in V4
+                    //   return `[V4]${
+                    //     pool.token0.isToken
+                    //       ? pool.token0.wrapped.address
+                    //       : pool.token0.symbol
+                    //   }/${
+                    //     pool.token1.isToken
+                    //       ? pool.token1.wrapped.address
+                    //       : pool.token1.symbol
+                    //   }`;
+                    // } else
+                    if (pool instanceof V3Pool) {
+                        return `[V3]${pool.token0.address}/${pool.token1.address}/${pool.fee}`;
+                    }
+                    else if (pool instanceof Pair) {
+                        return `[V2]${pool.token0.address}/${pool.token1.address}`;
+                    }
+                    else {
+                        throw new Error(`Unsupported pool type ${JSON.stringify(pool)}`);
+                    }
+                })
+                    .join('->');
+            default:
+                throw new Error(`Unsupported protocol ${this.protocol}`);
+        }
+    }
+    get routeId() {
+        return this.hashCode(this.routePath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,67 @@
+import { Protocol } from '@fanx-protocol/router-sdk';
+import { ChainId, Currency, TradeType } from '@fanx-protocol/sdk-core';
+import { RouteWithValidQuote, SupportedRoutes } from '../../../../routers';
+import { CachedRoute } from './cached-route';
+interface CachedRoutesParams {
+    routes: CachedRoute<SupportedRoutes>[];
+    chainId: ChainId;
+    currencyIn: Currency;
+    currencyOut: Currency;
+    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<SupportedRoutes>[];
+    readonly chainId: ChainId;
+    readonly currencyIn: Currency;
+    readonly currencyOut: Currency;
+    readonly protocolsCovered: Protocol[];
+    readonly blockNumber: number;
+    readonly tradeType: TradeType;
+    readonly originalAmount: string;
+    blocksToLive: number;
+    /**
+     * @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, }: CachedRoutesParams);
+    /**
+     * 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: RouteWithValidQuote[], chainId: ChainId, currencyIn: Currency, currencyOut: Currency, 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
+     * @param optimistic
+     */
+    notExpired(currentBlockNumber: number, optimistic?: boolean): boolean;
+}
+export {};

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

@@ -0,0 +1,74 @@
+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 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 = _.map(routes, (route) => new 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/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/module/providers/caching/route/model/index.js

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

package/build/module/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/module/providers/caching/route/route-caching-provider.js

@@ -0,0 +1,68 @@
+import { TradeType, } from '@fanx-protocol/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 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)) == 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)) ==
+                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 == 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;
+    }
+}
+//# 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 '@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/module/providers/caching-gas-provider.js

@@ -0,0 +1,37 @@
+import { log } from '../util/log';
+import { IGasPriceProvider } from './gas-price-provider';
+/**
+ * Provider for getting gas price, with functionality for caching the results.
+ *
+ * @export
+ * @class CachingV3SubgraphProvider
+ */
+export class CachingGasStationProvider extends 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.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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZy1nYXMtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NhY2hpbmctZ2FzLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFHbEMsT0FBTyxFQUFZLGlCQUFpQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbkU7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8seUJBQTBCLFNBQVEsaUJBQWlCO0lBSTlEOzs7OztPQUtHO0lBQ0gsWUFDWSxPQUFnQixFQUNsQixnQkFBbUMsRUFDbkMsS0FBdUI7UUFFL0IsS0FBSyxFQUFFLENBQUM7UUFKRSxZQUFPLEdBQVAsT0FBTyxDQUFTO1FBQ2xCLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBbUI7UUFDbkMsVUFBSyxHQUFMLEtBQUssQ0FBa0I7UUFaekIsWUFBTyxHQUFHLENBQUMsT0FBZ0IsRUFBRSxXQUFtQixFQUFFLEVBQUUsQ0FDMUQsWUFBWSxPQUFPLElBQUksV0FBVyxFQUFFLENBQUM7SUFjdkMsQ0FBQztJQUVlLEtBQUssQ0FBQyxXQUFXLENBQy9CLGlCQUF5QixFQUN6QixrQkFBMkI7UUFFM0IsK0dBQStHO1FBQy9HLGlEQUFpRDtRQUNqRCxNQUFNLGlCQUFpQixHQUFHLGtCQUFrQixhQUFsQixrQkFBa0IsY0FBbEIsa0JBQWtCLEdBQUksaUJBQWlCLENBQUM7UUFDbEUsTUFBTSxjQUFjLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FDekMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLGlCQUFpQixDQUFDLENBQzlDLENBQUM7UUFFRixJQUFJLGNBQWMsRUFBRTtZQUNsQixHQUFHLENBQUMsSUFBSSxDQUNOLEVBQUUsY0FBYyxFQUFFLEVBQ2xCLDJDQUEyQyxjQUFjLENBQUMsV0FBVyxHQUFHLENBQ3pFLENBQUM7WUFFRixPQUFPLGNBQWMsQ0FBQztTQUN2QjtRQUVELE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixDQUFDLFdBQVcsQ0FDdEQsaUJBQWlCLEVBQ2pCLGtCQUFrQixDQUNuQixDQUFDO1FBQ0YsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FDbEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLGlCQUFpQixDQUFDLEVBQzdDLFFBQVEsQ0FDVCxDQUFDO1FBRUYsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztDQUNGIn0=

package/build/module/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 {};