@fanx-protocol/smart-order-router 0.0.1

package/build/main/routers/alpha-router/quoters/v3-quoter.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V3Quoter = void 0;
+const router_sdk_1 = require("@fanx-protocol/router-sdk");
+const sdk_core_1 = require("@fanx-protocol/sdk-core");
+const lodash_1 = __importDefault(require("lodash"));
+const providers_1 = require("../../../providers");
+const util_1 = require("../../../util");
+const entities_1 = require("../entities");
+const compute_all_routes_1 = require("../functions/compute-all-routes");
+const base_quoter_1 = require("./base-quoter");
+class V3Quoter extends base_quoter_1.BaseQuoter {
+    constructor(v3SubgraphProvider, v3PoolProvider, onChainQuoteProvider, tokenProvider, chainId, blockedTokenListProvider, tokenValidatorProvider) {
+        super(tokenProvider, chainId, router_sdk_1.Protocol.V3, blockedTokenListProvider, tokenValidatorProvider);
+        this.v3SubgraphProvider = v3SubgraphProvider;
+        this.v3PoolProvider = v3PoolProvider;
+        this.onChainQuoteProvider = onChainQuoteProvider;
+    }
+    async getRoutes(tokenIn, tokenOut, v3CandidatePools, _tradeType, routingConfig) {
+        const beforeGetRoutes = Date.now();
+        // Fetch all the pools that we will consider routing via. There are thousands
+        // of pools, so we filter them to a set of candidate pools that we expect will
+        // result in good prices.
+        const { poolAccessor, candidatePools } = v3CandidatePools;
+        const poolsRaw = poolAccessor.getAllPools();
+        // Drop any pools that contain fee on transfer tokens (not supported by v3) or have issues with being transferred.
+        const pools = await this.applyTokenValidatorToPools(poolsRaw, (token, tokenValidation) => {
+            // If there is no available validation result we assume the token is fine.
+            if (!tokenValidation) {
+                return false;
+            }
+            // Only filters out *intermediate* pools that involve tokens that we detect
+            // cant be transferred. This prevents us trying to route through tokens that may
+            // not be transferrable, but allows users to still swap those tokens if they
+            // specify.
+            //
+            if (tokenValidation == providers_1.TokenValidationResult.STF &&
+                (token.equals(tokenIn) || token.equals(tokenOut))) {
+                return false;
+            }
+            return (tokenValidation == providers_1.TokenValidationResult.FOT ||
+                tokenValidation == providers_1.TokenValidationResult.STF);
+        });
+        // Given all our candidate pools, compute all the possible ways to route from tokenIn to tokenOut.
+        const { maxSwapsPerPath } = routingConfig;
+        const routes = (0, compute_all_routes_1.computeAllV3Routes)(tokenIn, tokenOut, pools, maxSwapsPerPath);
+        util_1.metric.putMetric('V3GetRoutesLoad', Date.now() - beforeGetRoutes, util_1.MetricLoggerUnit.Milliseconds);
+        return {
+            routes,
+            candidatePools,
+        };
+    }
+    async getQuotes(routes, amounts, percents, quoteToken, tradeType, routingConfig, candidatePools, gasModel) {
+        const beforeGetQuotes = Date.now();
+        util_1.log.info('Starting to get V3 quotes');
+        if (gasModel === undefined) {
+            throw new Error('GasModel for V3RouteWithValidQuote is required to getQuotes');
+        }
+        if (routes.length == 0) {
+            return { routesWithValidQuotes: [], candidatePools };
+        }
+        // For all our routes, and all the fractional amounts, fetch quotes on-chain.
+        const quoteFn = tradeType == sdk_core_1.TradeType.EXACT_INPUT
+            ? this.onChainQuoteProvider.getQuotesManyExactIn.bind(this.onChainQuoteProvider)
+            : this.onChainQuoteProvider.getQuotesManyExactOut.bind(this.onChainQuoteProvider);
+        const beforeQuotes = Date.now();
+        util_1.log.info(`Getting quotes for V3 for ${routes.length} routes with ${amounts.length} amounts per route.`);
+        const { routesWithQuotes } = await quoteFn(amounts, routes, routingConfig);
+        util_1.metric.putMetric('V3QuotesLoad', Date.now() - beforeQuotes, util_1.MetricLoggerUnit.Milliseconds);
+        util_1.metric.putMetric('V3QuotesFetched', (0, lodash_1.default)(routesWithQuotes)
+            .map(([, quotes]) => quotes.length)
+            .sum(), util_1.MetricLoggerUnit.Count);
+        const routesWithValidQuotes = [];
+        for (const routeWithQuote of routesWithQuotes) {
+            const [route, quotes] = routeWithQuote;
+            for (let i = 0; i < quotes.length; i++) {
+                const percent = percents[i];
+                const amountQuote = quotes[i];
+                const { quote, amount, sqrtPriceX96AfterList, initializedTicksCrossedList, gasEstimate, } = amountQuote;
+                if (!quote ||
+                    !sqrtPriceX96AfterList ||
+                    !initializedTicksCrossedList ||
+                    !gasEstimate) {
+                    util_1.log.debug({
+                        route: (0, util_1.routeToString)(route),
+                        amountQuote,
+                    }, 'Dropping a null V3 quote for route.');
+                    continue;
+                }
+                const routeWithValidQuote = new entities_1.V3RouteWithValidQuote({
+                    route,
+                    rawQuote: quote,
+                    amount,
+                    percent,
+                    sqrtPriceX96AfterList,
+                    initializedTicksCrossedList,
+                    quoterGasEstimate: gasEstimate,
+                    gasModel,
+                    quoteToken,
+                    tradeType,
+                    v3PoolProvider: this.v3PoolProvider,
+                });
+                routesWithValidQuotes.push(routeWithValidQuote);
+            }
+        }
+        util_1.metric.putMetric('V3GetQuotesLoad', Date.now() - beforeGetQuotes, util_1.MetricLoggerUnit.Milliseconds);
+        return {
+            routesWithValidQuotes,
+            candidatePools,
+        };
+    }
+}
+exports.V3Quoter = V3Quoter;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/routers/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../util/metric';
+export * from './alpha-router';
+export * from './router';

package/build/main/routers/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("../util/metric"), exports);
+__exportStar(require("./alpha-router"), exports);
+__exportStar(require("./router"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcm91dGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLGlEQUErQjtBQUMvQiwyQ0FBeUIifQ==

package/build/main/routers/router.d.ts

@@ -0,0 +1,186 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { CondensedAddLiquidityOptions, MixedRouteSDK, Protocol, Trade } from '@fanx-protocol/router-sdk';
+import { Currency, Fraction, Percent, Token, TradeType } from '@fanx-protocol/sdk-core';
+import { SwapOptions as UniversalRouterSwapOptions, UniversalRouterVersion } from '@fanx-protocol/universal-router-sdk';
+import { Route as V2RouteRaw } from '@fanx-protocol/v2-sdk';
+import { MethodParameters as SDKMethodParameters, Pool, Position, Route as V3RouteRaw } from '@fanx-protocol/v3-sdk';
+import { SimulationStatus } from '../providers';
+import { CurrencyAmount } from '../util/amounts';
+import { RouteWithValidQuote } from './alpha-router';
+export declare class V3Route extends V3RouteRaw<Token, Token> {
+    protocol: Protocol.V3;
+}
+export declare class V2Route extends V2RouteRaw<Token, Token> {
+    protocol: Protocol.V2;
+}
+export declare class MixedRoute extends MixedRouteSDK<Currency, Currency> {
+    protocol: Protocol.MIXED;
+}
+export declare type SupportedRoutes = /* V4Route | */ V3Route | V2Route | MixedRoute;
+export declare type SwapRoute = {
+    /**
+     * The quote for the swap.
+     * For EXACT_IN swaps this will be an amount of token out.
+     * For EXACT_OUT this will be an amount of token in.
+     */
+    quote: CurrencyAmount;
+    /**
+     * The quote adjusted for the estimated gas used by the swap.
+     * This is computed by estimating the amount of gas used by the swap, converting
+     * this estimate to be in terms of the quote token, and subtracting that from the quote.
+     * i.e. quoteGasAdjusted = quote - estimatedGasUsedQuoteToken
+     */
+    quoteGasAdjusted: CurrencyAmount;
+    /**
+     * The quote adjusted for the estimated gas used by the swap as well as the portion amount, if applicable.
+     * This is computed by estimating the amount of gas used by the swap, converting
+     * this estimate to be in terms of the quote token, and subtracting that from the quote.
+     * Then it uses the IPortionProvider.getPortionAdjustedQuote method to adjust the quote for the portion amount.
+     * i.e. quoteGasAdjusted = quote - estimatedGasUsedQuoteToken - portionAmount
+     */
+    quoteGasAndPortionAdjusted?: CurrencyAmount;
+    /**
+     * The estimate of the gas used by the swap.
+     */
+    estimatedGasUsed: BigNumber;
+    /**
+     * The estimate of the gas used by the swap in terms of the quote token.
+     */
+    estimatedGasUsedQuoteToken: CurrencyAmount;
+    /**
+     * The estimate of the gas used by the swap in USD.
+     */
+    estimatedGasUsedUSD: CurrencyAmount;
+    /**
+     * The estimate of the gas used by the swap in terms of the gas token if specified.
+     * will be undefined if no gas token is specified in the AlphaRouter config
+     */
+    estimatedGasUsedGasToken?: CurrencyAmount;
+    gasPriceWei: BigNumber;
+    /**
+     * The Trade object representing the swap.
+     */
+    trade: Trade<Currency, Currency, TradeType>;
+    /**
+     * The routes of the swap.
+     */
+    route: RouteWithValidQuote[];
+    /**
+     * The block number used when computing the swap.
+     */
+    blockNumber: BigNumber;
+    /**
+     * The calldata to execute the swap. Only returned if swapConfig was provided when calling the router.
+     */
+    methodParameters?: MethodParameters;
+    /**
+     * Enum that is returned if simulation was requested
+     * 0 if simulation was not attempted
+     * 1 if simulation was attempted and failed
+     * 2 if simulation was successful (simulated gas estimates are returned)
+     */
+    simulationStatus?: SimulationStatus;
+    /**
+     * Used internally within routing-api to see how many route requests
+     * hit the cached routes. This is used further down the line for future perf optimizations.
+     */
+    hitsCachedRoute?: boolean;
+    /**
+     * Portion amount either echoed from upstream routing-api for exact out or calculated from portionBips for exact in
+     */
+    portionAmount?: CurrencyAmount;
+};
+export declare type MethodParameters = SDKMethodParameters & {
+    to: string;
+};
+export declare type SwapToRatioRoute = SwapRoute & {
+    optimalRatio: Fraction;
+    postSwapTargetPool: Pool;
+};
+export declare enum SwapToRatioStatus {
+    SUCCESS = 1,
+    NO_ROUTE_FOUND = 2,
+    NO_SWAP_NEEDED = 3
+}
+export declare type SwapToRatioSuccess = {
+    status: SwapToRatioStatus.SUCCESS;
+    result: SwapToRatioRoute;
+};
+export declare type SwapToRatioFail = {
+    status: SwapToRatioStatus.NO_ROUTE_FOUND;
+    error: string;
+};
+export declare type SwapToRatioNoSwapNeeded = {
+    status: SwapToRatioStatus.NO_SWAP_NEEDED;
+};
+export declare type SwapToRatioResponse = SwapToRatioSuccess | SwapToRatioFail | SwapToRatioNoSwapNeeded;
+export declare enum SwapType {
+    UNIVERSAL_ROUTER = 0,
+    SWAP_ROUTER_02 = 1
+}
+export declare type SwapOptionsUniversalRouter = UniversalRouterSwapOptions & {
+    type: SwapType.UNIVERSAL_ROUTER;
+    version: UniversalRouterVersion;
+    simulate?: {
+        fromAddress: string;
+    };
+};
+export declare type SwapOptionsSwapRouter02 = {
+    type: SwapType.SWAP_ROUTER_02;
+    recipient: string;
+    slippageTolerance: Percent;
+    deadline: number;
+    simulate?: {
+        fromAddress: string;
+    };
+    inputTokenPermit?: {
+        v: 0 | 1 | 27 | 28;
+        r: string;
+        s: string;
+    } & ({
+        amount: string;
+        deadline: string;
+    } | {
+        nonce: string;
+        expiry: string;
+    });
+};
+export declare type SwapOptions = SwapOptionsUniversalRouter | SwapOptionsSwapRouter02;
+export declare type SwapAndAddConfig = {
+    maxIterations: number;
+    ratioErrorTolerance: Fraction;
+};
+export declare type SwapAndAddOptions = {
+    swapOptions: SwapOptionsSwapRouter02;
+    addLiquidityOptions: CondensedAddLiquidityOptions;
+};
+export declare type SwapAndAddParameters = {
+    initialBalanceTokenIn: CurrencyAmount;
+    initialBalanceTokenOut: CurrencyAmount;
+    preLiquidityPosition: Position;
+};
+/**
+ * Provides functionality for finding optimal swap routes on the Uniswap protocol.
+ *
+ * @export
+ * @abstract
+ * @class IRouter
+ */
+export declare abstract class IRouter<RoutingConfig> {
+    /**
+     * Finds the optimal way to swap tokens, and returns the route as well as a quote for the swap.
+     * Considers split routes, multi-hop swaps, and gas costs.
+     *
+     * @abstract
+     * @param amount The amount specified by the user. For EXACT_IN swaps, this is the input token amount. For EXACT_OUT swaps, this is the output token.
+     * @param quoteCurrency The currency of the token we are returning a quote for. For EXACT_IN swaps, this is the output token. For EXACT_OUT, this is the input token.
+     * @param tradeType The type of the trade, either exact in or exact out.
+     * @param [swapOptions] Optional config for executing the swap. If provided, calldata for executing the swap will also be returned.
+     * @param [partialRoutingConfig] Optional config for finding the optimal route.
+     * @returns The swap route.
+     */
+    abstract route(amount: CurrencyAmount, quoteCurrency: Currency, swapType: TradeType, swapOptions?: SwapOptions, partialRoutingConfig?: Partial<RoutingConfig>): Promise<SwapRoute | null>;
+}
+export declare abstract class ISwapToRatio<RoutingConfig, SwapAndAddConfig> {
+    abstract routeToRatio(token0Balance: CurrencyAmount, token1Balance: CurrencyAmount, position: Position, swapAndAddConfig: SwapAndAddConfig, swapAndAddOptions?: SwapAndAddOptions, routingConfig?: RoutingConfig): Promise<SwapToRatioResponse>;
+}

package/build/main/routers/router.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISwapToRatio = exports.IRouter = exports.SwapType = exports.SwapToRatioStatus = exports.MixedRoute = exports.V2Route = exports.V3Route = void 0;
+const router_sdk_1 = require("@fanx-protocol/router-sdk");
+const v2_sdk_1 = require("@fanx-protocol/v2-sdk");
+const v3_sdk_1 = require("@fanx-protocol/v3-sdk");
+// export class V4Route extends V4RouteRaw<Currency, Currency> {
+//   protocol: Protocol.V4 = Protocol.V4;
+// }
+class V3Route extends v3_sdk_1.Route {
+    constructor() {
+        super(...arguments);
+        this.protocol = router_sdk_1.Protocol.V3;
+    }
+}
+exports.V3Route = V3Route;
+class V2Route extends v2_sdk_1.Route {
+    constructor() {
+        super(...arguments);
+        this.protocol = router_sdk_1.Protocol.V2;
+    }
+}
+exports.V2Route = V2Route;
+class MixedRoute extends router_sdk_1.MixedRouteSDK {
+    constructor() {
+        super(...arguments);
+        this.protocol = router_sdk_1.Protocol.MIXED;
+    }
+}
+exports.MixedRoute = MixedRoute;
+var SwapToRatioStatus;
+(function (SwapToRatioStatus) {
+    SwapToRatioStatus[SwapToRatioStatus["SUCCESS"] = 1] = "SUCCESS";
+    SwapToRatioStatus[SwapToRatioStatus["NO_ROUTE_FOUND"] = 2] = "NO_ROUTE_FOUND";
+    SwapToRatioStatus[SwapToRatioStatus["NO_SWAP_NEEDED"] = 3] = "NO_SWAP_NEEDED";
+})(SwapToRatioStatus = exports.SwapToRatioStatus || (exports.SwapToRatioStatus = {}));
+var SwapType;
+(function (SwapType) {
+    SwapType[SwapType["UNIVERSAL_ROUTER"] = 0] = "UNIVERSAL_ROUTER";
+    SwapType[SwapType["SWAP_ROUTER_02"] = 1] = "SWAP_ROUTER_02";
+})(SwapType = exports.SwapType || (exports.SwapType = {}));
+/**
+ * Provides functionality for finding optimal swap routes on the Uniswap protocol.
+ *
+ * @export
+ * @abstract
+ * @class IRouter
+ */
+class IRouter {
+}
+exports.IRouter = IRouter;
+class ISwapToRatio {
+}
+exports.ISwapToRatio = ISwapToRatio;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JvdXRlcnMvcm91dGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLDBEQUttQztBQVluQyxrREFBNEQ7QUFDNUQsa0RBSytCO0FBUS9CLGdFQUFnRTtBQUNoRSx5Q0FBeUM7QUFDekMsSUFBSTtBQUNKLE1BQWEsT0FBUSxTQUFRLGNBQXdCO0lBQXJEOztRQUNFLGFBQVEsR0FBZ0IscUJBQVEsQ0FBQyxFQUFFLENBQUM7SUFDdEMsQ0FBQztDQUFBO0FBRkQsMEJBRUM7QUFDRCxNQUFhLE9BQVEsU0FBUSxjQUF3QjtJQUFyRDs7UUFDRSxhQUFRLEdBQWdCLHFCQUFRLENBQUMsRUFBRSxDQUFDO0lBQ3RDLENBQUM7Q0FBQTtBQUZELDBCQUVDO0FBQ0QsTUFBYSxVQUFXLFNBQVEsMEJBQWlDO0lBQWpFOztRQUNFLGFBQVEsR0FBbUIscUJBQVEsQ0FBQyxLQUFLLENBQUM7SUFDNUMsQ0FBQztDQUFBO0FBRkQsZ0NBRUM7QUF1RkQsSUFBWSxpQkFJWDtBQUpELFdBQVksaUJBQWlCO0lBQzNCLCtEQUFXLENBQUE7SUFDWCw2RUFBa0IsQ0FBQTtJQUNsQiw2RUFBa0IsQ0FBQTtBQUNwQixDQUFDLEVBSlcsaUJBQWlCLEdBQWpCLHlCQUFpQixLQUFqQix5QkFBaUIsUUFJNUI7QUFxQkQsSUFBWSxRQUdYO0FBSEQsV0FBWSxRQUFRO0lBQ2xCLCtEQUFnQixDQUFBO0lBQ2hCLDJEQUFjLENBQUE7QUFDaEIsQ0FBQyxFQUhXLFFBQVEsR0FBUixnQkFBUSxLQUFSLGdCQUFRLFFBR25CO0FBMkREOzs7Ozs7R0FNRztBQUNILE1BQXNCLE9BQU87Q0FvQjVCO0FBcEJELDBCQW9CQztBQUVELE1BQXNCLFlBQVk7Q0FTakM7QUFURCxvQ0FTQyJ9