@pioneer-platform/uniswap-client 0.0.22 → 0.0.24

package/lib/routing/utils.js

@@ -0,0 +1,319 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLimitTrade = exports.isUniswapXTrade = exports.isSubmittableTrade = exports.isPreviewTrade = exports.isClassicTrade = exports.currencyAddressForSwapQuote = exports.isExactInput = exports.transformQuoteToTrade = exports.getUSDCostPerGas = exports.transformQuickRouteToTrade = exports.computeRoutes = void 0;
+var bignumber_1 = require("@ethersproject/bignumber");
+var router_sdk_1 = require("@uniswap/router-sdk");
+var sdk_core_1 = require("@uniswap/sdk-core");
+var v2_sdk_1 = require("@uniswap/v2-sdk");
+var v3_sdk_1 = require("@uniswap/v3-sdk");
+var misc_1 = require("../constants/misc");
+var tokens_1 = require("../constants/tokens");
+var PRECISION = 10000;
+var DENOMINATOR = PRECISION * 100;
+function toSlippagePercent(slippage) {
+    var numerator = Number(slippage) * PRECISION;
+    return new sdk_core_1.Percent(numerator, DENOMINATOR);
+}
+var gas_1 = require("./gas");
+var types_1 = require("./types");
+/**
+ * Transforms a Routing API quote into an array of routes that can be used to
+ * create a `Trade`.
+ */
+function computeRoutes(args, routes) {
+    if (routes.length === 0)
+        return [];
+    var _a = getTradeCurrencies(args, false, routes), currencyIn = _a[0], currencyOut = _a[1];
+    try {
+        return routes.map(function (route) {
+            if (route.length === 0) {
+                throw new Error('Expected route to have at least one pair or pool');
+            }
+            var rawAmountIn = route[0].amountIn;
+            var rawAmountOut = route[route.length - 1].amountOut;
+            if (!rawAmountIn || !rawAmountOut) {
+                throw new Error('Expected both amountIn and amountOut to be present');
+            }
+            var isOnlyV2 = isVersionedRoute(types_1.PoolType.V2Pool, route);
+            var isOnlyV3 = isVersionedRoute(types_1.PoolType.V3Pool, route);
+            return {
+                routev3: isOnlyV3 ? new v3_sdk_1.Route(route.map(parsePool), currencyIn, currencyOut) : null,
+                routev2: isOnlyV2 ? new v2_sdk_1.Route(route.map(parsePair), currencyIn, currencyOut) : null,
+                mixedRoute: !isOnlyV3 && !isOnlyV2 ? new router_sdk_1.MixedRouteSDK(route.map(parsePoolOrPair), currencyIn, currencyOut) : null,
+                inputAmount: sdk_core_1.CurrencyAmount.fromRawAmount(currencyIn, rawAmountIn),
+                outputAmount: sdk_core_1.CurrencyAmount.fromRawAmount(currencyOut, rawAmountOut),
+            };
+        });
+    }
+    catch (e) {
+        console.error('Error computing routes', e);
+        return;
+    }
+}
+exports.computeRoutes = computeRoutes;
+var parsePoolOrPair = function (pool) {
+    return pool.type === types_1.PoolType.V3Pool ? parsePool(pool) : parsePair(pool);
+};
+function isVersionedRoute(type, route) {
+    return route.every(function (pool) { return pool.type === type; });
+}
+function toDutchOrderInfo(orderInfoJSON) {
+    var nonce = orderInfoJSON.nonce, input = orderInfoJSON.input, outputs = orderInfoJSON.outputs, exclusivityOverrideBps = orderInfoJSON.exclusivityOverrideBps;
+    return __assign(__assign({}, orderInfoJSON), { nonce: bignumber_1.BigNumber.from(nonce), exclusivityOverrideBps: bignumber_1.BigNumber.from(exclusivityOverrideBps), input: __assign(__assign({}, input), { startAmount: bignumber_1.BigNumber.from(input.startAmount), endAmount: bignumber_1.BigNumber.from(input.endAmount) }), outputs: outputs.map(function (output) { return (__assign(__assign({}, output), { startAmount: bignumber_1.BigNumber.from(output.startAmount), endAmount: bignumber_1.BigNumber.from(output.endAmount) })); }) });
+}
+// Prepares the currencies used for the actual Swap (either UniswapX or Universal Router)
+// May not match `currencyIn` that the user selected because for ETH inputs in UniswapX, the actual
+// swap will use WETH.
+function getTradeCurrencies(args, isUniswapXTrade, routes) {
+    var _a, _b, _c, _d, _e;
+    var tokenInAddress = args.tokenInAddress, tokenInChainId = args.tokenInChainId, tokenInDecimals = args.tokenInDecimals, tokenInSymbol = args.tokenInSymbol, tokenOutAddress = args.tokenOutAddress, tokenOutChainId = args.tokenOutChainId, tokenOutDecimals = args.tokenOutDecimals, tokenOutSymbol = args.tokenOutSymbol;
+    var tokenInIsNative = Object.values(types_1.SwapRouterNativeAssets).includes(tokenInAddress);
+    var tokenOutIsNative = Object.values(types_1.SwapRouterNativeAssets).includes(tokenOutAddress);
+    var serializedTokenIn = (_b = (_a = routes === null || routes === void 0 ? void 0 : routes[0]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.tokenIn;
+    var serializedTokenOut = (_e = (_c = routes === null || routes === void 0 ? void 0 : routes[0]) === null || _c === void 0 ? void 0 : _c[((_d = routes[0]) === null || _d === void 0 ? void 0 : _d.length) - 1]) === null || _e === void 0 ? void 0 : _e.tokenOut;
+    var currencyIn = tokenInIsNative
+        ? (0, tokens_1.nativeOnChain)(tokenInChainId)
+        : parseToken({
+            address: tokenInAddress,
+            chainId: tokenInChainId,
+            decimals: tokenInDecimals,
+            symbol: tokenInSymbol,
+            buyFeeBps: serializedTokenIn === null || serializedTokenIn === void 0 ? void 0 : serializedTokenIn.buyFeeBps,
+            sellFeeBps: serializedTokenIn === null || serializedTokenIn === void 0 ? void 0 : serializedTokenIn.sellFeeBps,
+        });
+    var currencyOut = tokenOutIsNative
+        ? (0, tokens_1.nativeOnChain)(tokenOutChainId)
+        : parseToken({
+            address: tokenOutAddress,
+            chainId: tokenOutChainId,
+            decimals: tokenOutDecimals,
+            symbol: tokenOutSymbol,
+            buyFeeBps: serializedTokenOut === null || serializedTokenOut === void 0 ? void 0 : serializedTokenOut.buyFeeBps,
+            sellFeeBps: serializedTokenOut === null || serializedTokenOut === void 0 ? void 0 : serializedTokenOut.sellFeeBps,
+        });
+    if (!isUniswapXTrade) {
+        return [currencyIn, currencyOut];
+    }
+    return [currencyIn.isNative ? currencyIn.wrapped : currencyIn, currencyOut];
+}
+function getSwapFee(data) {
+    var portionAmount = data.portionAmount, portionBips = data.portionBips, portionRecipient = data.portionRecipient;
+    if (!portionAmount || !portionBips || !portionRecipient)
+        return undefined;
+    return {
+        recipient: portionRecipient,
+        percent: new sdk_core_1.Percent(portionBips, misc_1.BIPS_BASE),
+        amount: portionAmount,
+    };
+}
+function getClassicTradeDetails(args, data) {
+    var _a;
+    var classicQuote = data.routing === types_1.URAQuoteType.CLASSIC ? data.quote : (_a = data.allQuotes.find(types_1.isClassicQuoteResponse)) === null || _a === void 0 ? void 0 : _a.quote;
+    if (!classicQuote) {
+        return {};
+    }
+    return {
+        gasUseEstimate: classicQuote.gasUseEstimate ? parseFloat(classicQuote.gasUseEstimate) : undefined,
+        gasUseEstimateUSD: classicQuote.gasUseEstimateUSD ? parseFloat(classicQuote.gasUseEstimateUSD) : undefined,
+        blockNumber: classicQuote.blockNumber,
+        routes: computeRoutes(args, classicQuote.route),
+        swapFee: getSwapFee(classicQuote),
+    };
+}
+function transformQuickRouteToTrade(args, data) {
+    var amount = args.amount, tradeType = args.tradeType;
+    var _a = getTradeCurrencies(args, false), currencyIn = _a[0], currencyOut = _a[1];
+    var _b = data.tradeType === 'EXACT_IN' ? [amount, data.quote.amount] : [data.quote.amount, amount], rawAmountIn = _b[0], rawAmountOut = _b[1];
+    var inputAmount = sdk_core_1.CurrencyAmount.fromRawAmount(currencyIn, rawAmountIn);
+    var outputAmount = sdk_core_1.CurrencyAmount.fromRawAmount(currencyOut, rawAmountOut);
+    return new types_1.PreviewTrade({ inputAmount: inputAmount, outputAmount: outputAmount, tradeType: tradeType });
+}
+exports.transformQuickRouteToTrade = transformQuickRouteToTrade;
+function getUSDCostPerGas(gasUseEstimateUSD, gasUseEstimate) {
+    // Some sus javascript float math but it's ok because its just an estimate for display purposes
+    if (!gasUseEstimateUSD || !gasUseEstimate)
+        return undefined;
+    return gasUseEstimateUSD / gasUseEstimate;
+}
+exports.getUSDCostPerGas = getUSDCostPerGas;
+function transformQuoteToTrade(args, data, quoteMethod) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function () {
+        var tradeType, needsWrapIfUniswapX, routerPreference, account, amount, showUniswapXTrade, _d, currencyIn, currencyOut, _e, gasUseEstimateUSD, blockNumber, routes, gasUseEstimate, swapFee, usdCostPerGas, approveInfo, classicTrade, isUniswapXBetter, orderInfo, swapFee_1, wrapInfo, uniswapXTrade;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    tradeType = args.tradeType, needsWrapIfUniswapX = args.needsWrapIfUniswapX, routerPreference = args.routerPreference, account = args.account, amount = args.amount;
+                    showUniswapXTrade = data.routing === types_1.URAQuoteType.DUTCH_LIMIT && routerPreference === types_1.RouterPreference.X;
+                    _d = getTradeCurrencies(args, showUniswapXTrade), currencyIn = _d[0], currencyOut = _d[1];
+                    _e = getClassicTradeDetails(args, data), gasUseEstimateUSD = _e.gasUseEstimateUSD, blockNumber = _e.blockNumber, routes = _e.routes, gasUseEstimate = _e.gasUseEstimate, swapFee = _e.swapFee;
+                    usdCostPerGas = getUSDCostPerGas(gasUseEstimateUSD, gasUseEstimate);
+                    return [4 /*yield*/, (0, gas_1.getApproveInfo)(account, currencyIn, amount, usdCostPerGas)];
+                case 1:
+                    approveInfo = _f.sent();
+                    classicTrade = new types_1.ClassicTrade({
+                        v2Routes: (_a = routes === null || routes === void 0 ? void 0 : routes.filter(function (r) { return r.routev2 !== null; }).map(function (_a) {
+                            var routev2 = _a.routev2, inputAmount = _a.inputAmount, outputAmount = _a.outputAmount;
+                            return ({
+                                routev2: routev2,
+                                inputAmount: inputAmount,
+                                outputAmount: outputAmount,
+                            });
+                        })) !== null && _a !== void 0 ? _a : [],
+                        v3Routes: (_b = routes === null || routes === void 0 ? void 0 : routes.filter(function (r) { return r.routev3 !== null; }).map(function (_a) {
+                            var routev3 = _a.routev3, inputAmount = _a.inputAmount, outputAmount = _a.outputAmount;
+                            return ({
+                                routev3: routev3,
+                                inputAmount: inputAmount,
+                                outputAmount: outputAmount,
+                            });
+                        })) !== null && _b !== void 0 ? _b : [],
+                        mixedRoutes: (_c = routes === null || routes === void 0 ? void 0 : routes.filter(function (r) { return r.mixedRoute !== null; }).map(function (_a) {
+                            var mixedRoute = _a.mixedRoute, inputAmount = _a.inputAmount, outputAmount = _a.outputAmount;
+                            return ({
+                                mixedRoute: mixedRoute,
+                                inputAmount: inputAmount,
+                                outputAmount: outputAmount,
+                            });
+                        })) !== null && _c !== void 0 ? _c : [],
+                        tradeType: tradeType,
+                        gasUseEstimateUSD: gasUseEstimateUSD,
+                        gasUseEstimate: gasUseEstimate,
+                        approveInfo: approveInfo,
+                        blockNumber: blockNumber,
+                        requestId: data.quote.requestId,
+                        quoteMethod: quoteMethod,
+                        swapFee: swapFee,
+                    });
+                    isUniswapXBetter = data.routing === types_1.URAQuoteType.DUTCH_LIMIT;
+                    if (!isUniswapXBetter) return [3 /*break*/, 3];
+                    orderInfo = toDutchOrderInfo(data.quote.orderInfo);
+                    swapFee_1 = getSwapFee(data.quote);
+                    return [4 /*yield*/, (0, gas_1.getWrapInfo)(needsWrapIfUniswapX, account, currencyIn.chainId, amount, usdCostPerGas)];
+                case 2:
+                    wrapInfo = _f.sent();
+                    uniswapXTrade = new types_1.DutchOrderTrade({
+                        currencyIn: currencyIn,
+                        currenciesOut: [currencyOut],
+                        orderInfo: orderInfo,
+                        tradeType: tradeType,
+                        quoteId: data.quote.quoteId,
+                        requestId: data.quote.requestId,
+                        classicGasUseEstimateUSD: classicTrade.totalGasUseEstimateUSD,
+                        wrapInfo: wrapInfo,
+                        approveInfo: approveInfo,
+                        auctionPeriodSecs: data.quote.auctionPeriodSecs,
+                        startTimeBufferSecs: data.quote.startTimeBufferSecs,
+                        deadlineBufferSecs: data.quote.deadlineBufferSecs,
+                        slippageTolerance: toSlippagePercent(data.quote.slippageTolerance),
+                        swapFee: swapFee_1,
+                    });
+                    return [2 /*return*/, {
+                            state: types_1.QuoteState.SUCCESS,
+                            trade: uniswapXTrade,
+                        }];
+                case 3: return [2 /*return*/, { state: types_1.QuoteState.SUCCESS, trade: classicTrade }];
+            }
+        });
+    });
+}
+exports.transformQuoteToTrade = transformQuoteToTrade;
+function parseToken(_a) {
+    var address = _a.address, chainId = _a.chainId, decimals = _a.decimals, symbol = _a.symbol, buyFeeBps = _a.buyFeeBps, sellFeeBps = _a.sellFeeBps;
+    var buyFeeBpsBN = buyFeeBps ? bignumber_1.BigNumber.from(buyFeeBps) : undefined;
+    var sellFeeBpsBN = sellFeeBps ? bignumber_1.BigNumber.from(sellFeeBps) : undefined;
+    return new sdk_core_1.Token(chainId, address, parseInt(decimals.toString()), symbol, undefined, false, buyFeeBpsBN, sellFeeBpsBN);
+}
+function parsePool(_a) {
+    var fee = _a.fee, sqrtRatioX96 = _a.sqrtRatioX96, liquidity = _a.liquidity, tickCurrent = _a.tickCurrent, tokenIn = _a.tokenIn, tokenOut = _a.tokenOut;
+    return new v3_sdk_1.Pool(parseToken(tokenIn), parseToken(tokenOut), parseInt(fee), sqrtRatioX96, liquidity, parseInt(tickCurrent));
+}
+var parsePair = function (_a) {
+    var reserve0 = _a.reserve0, reserve1 = _a.reserve1;
+    return new v2_sdk_1.Pair(sdk_core_1.CurrencyAmount.fromRawAmount(parseToken(reserve0.token), reserve0.quotient), sdk_core_1.CurrencyAmount.fromRawAmount(parseToken(reserve1.token), reserve1.quotient));
+};
+// TODO(WEB-2050): Convert other instances of tradeType comparison to use this utility function
+function isExactInput(tradeType) {
+    return tradeType === sdk_core_1.TradeType.EXACT_INPUT;
+}
+exports.isExactInput = isExactInput;
+function currencyAddressForSwapQuote(currency) {
+    if (currency.isNative) {
+        if ((0, tokens_1.isPolygon)(currency.chainId))
+            return types_1.SwapRouterNativeAssets.MATIC;
+        if ((0, tokens_1.isBsc)(currency.chainId))
+            return types_1.SwapRouterNativeAssets.BNB;
+        if ((0, tokens_1.isAvalanche)(currency.chainId))
+            return types_1.SwapRouterNativeAssets.AVAX;
+        return types_1.SwapRouterNativeAssets.ETH;
+    }
+    return currency.address;
+}
+exports.currencyAddressForSwapQuote = currencyAddressForSwapQuote;
+function isClassicTrade(trade) {
+    return (trade === null || trade === void 0 ? void 0 : trade.fillType) === types_1.TradeFillType.Classic;
+}
+exports.isClassicTrade = isClassicTrade;
+function isPreviewTrade(trade) {
+    return (trade === null || trade === void 0 ? void 0 : trade.fillType) === types_1.TradeFillType.None;
+}
+exports.isPreviewTrade = isPreviewTrade;
+function isSubmittableTrade(trade) {
+    return (trade === null || trade === void 0 ? void 0 : trade.fillType) === types_1.TradeFillType.Classic || (trade === null || trade === void 0 ? void 0 : trade.fillType) === types_1.TradeFillType.UniswapX;
+}
+exports.isSubmittableTrade = isSubmittableTrade;
+function isUniswapXTrade(trade) {
+    return (trade === null || trade === void 0 ? void 0 : trade.fillType) === types_1.TradeFillType.UniswapX;
+}
+exports.isUniswapXTrade = isUniswapXTrade;
+function isLimitTrade(trade) {
+    return (trade === null || trade === void 0 ? void 0 : trade.fillType) === types_1.TradeFillType.UniswapX && (trade === null || trade === void 0 ? void 0 : trade.offchainOrderType) === types_1.OffchainOrderType.LIMIT_ORDER;
+}
+exports.isLimitTrade = isLimitTrade;

package/lib/rpc/AppJsonRpcProvider.d.ts

@@ -0,0 +1,44 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import ConfiguredJsonRpcProvider from './ConfiguredJsonRpcProvider';
+/**
+ * A controller which marks itself disabled on an error, and re-enables itself using exponential backoff.
+ * After each retry, it will wait twice as long to retry again. After a success, it will reset the backoff.
+ */
+declare class Controller {
+    private minimumBackoffTime;
+    private isEnabled;
+    private timeout;
+    private exponentialBackoffFactor;
+    constructor(minimumBackoffTime: number);
+    private reset;
+    onSuccess(): void;
+    /**
+     * Called onError.
+     * Idempotent - calling this multiple times will *not* reset the exponential backoff timer.
+     */
+    onError(): void;
+    get enabled(): boolean;
+}
+interface ControlledProvider {
+    provider: JsonRpcProvider;
+    controller: Controller;
+}
+interface AppJsonRpcProviderOptions {
+    minimumBackoffTime?: number;
+}
+/**
+ * An application-specific JSON-RPC provider.
+ *
+ * This super-provider will instantiate providers for all supported JSON-RPC URLs, so that it may use them as fallbacks.
+ * It will use the first (primary) JSON-RPC URL unless there is issue, at which point it will fallback to the next, &c.,
+ * retrying the former using exponential backoff. This prevents secondary URLs from permanently overtaking primary URLs.
+ */
+export default class AppJsonRpcProvider extends ConfiguredJsonRpcProvider {
+    providers: ReadonlyArray<ControlledProvider>;
+    constructor(providers: JsonRpcProvider[], { minimumBackoffTime }?: AppJsonRpcProviderOptions);
+    perform(method: string, params: {
+        [name: string]: any;
+    }): Promise<any>;
+    static sortProviders(providers: ReadonlyArray<ControlledProvider>): Array<ControlledProvider>;
+}
+export {};

package/lib/rpc/AppJsonRpcProvider.js

@@ -0,0 +1,183 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var chainInfo_1 = require("../constants/chainInfo");
+var ConfiguredJsonRpcProvider_1 = __importDefault(require("./ConfiguredJsonRpcProvider"));
+/**
+ * A controller which marks itself disabled on an error, and re-enables itself using exponential backoff.
+ * After each retry, it will wait twice as long to retry again. After a success, it will reset the backoff.
+ */
+var Controller = /** @class */ (function () {
+    function Controller(minimumBackoffTime) {
+        this.minimumBackoffTime = minimumBackoffTime;
+        this.isEnabled = true;
+        this.exponentialBackoffFactor = 1;
+    }
+    Controller.prototype.reset = function () {
+        this.isEnabled = true;
+        // @ts-ignore
+        clearTimeout(this.timeout);
+        this.timeout = undefined;
+    };
+    Controller.prototype.onSuccess = function () {
+        this.reset();
+        this.exponentialBackoffFactor = 1;
+    };
+    /**
+     * Called onError.
+     * Idempotent - calling this multiple times will *not* reset the exponential backoff timer.
+     */
+    Controller.prototype.onError = function () {
+        var _this = this;
+        this.isEnabled = false;
+        if (!this.timeout) {
+            this.timeout = setTimeout(function () {
+                _this.reset();
+                _this.exponentialBackoffFactor *= 2;
+            }, this.minimumBackoffTime * this.exponentialBackoffFactor);
+        }
+    };
+    Object.defineProperty(Controller.prototype, "enabled", {
+        get: function () {
+            return this.isEnabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Controller;
+}());
+/**
+ * An application-specific JSON-RPC provider.
+ *
+ * This super-provider will instantiate providers for all supported JSON-RPC URLs, so that it may use them as fallbacks.
+ * It will use the first (primary) JSON-RPC URL unless there is issue, at which point it will fallback to the next, &c.,
+ * retrying the former using exponential backoff. This prevents secondary URLs from permanently overtaking primary URLs.
+ */
+var AppJsonRpcProvider = /** @class */ (function (_super) {
+    __extends(AppJsonRpcProvider, _super);
+    function AppJsonRpcProvider(providers, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.minimumBackoffTime, minimumBackoffTime = _c === void 0 ? chainInfo_1.AVERAGE_L1_BLOCK_TIME : _c;
+        var _this = this;
+        if (providers.length === 0)
+            throw new Error('Missing providers for AppJsonRpcProvider');
+        _this = _super.call(this, undefined, providers[0].network) || this;
+        // AppJsonRpcProvider configures its own pollingInterval, so the encapsulated providers do not need to poll.
+        // providers.forEach((provider) => (provider.pollingInterval = Infinity))
+        _this.providers = providers.map(function (provider) { return ({ provider: provider, controller: new Controller(minimumBackoffTime) }); });
+        return _this;
+    }
+    AppJsonRpcProvider.prototype.perform = function (method, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sortedProviders, _i, sortedProviders_1, _a, provider, controller, result, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        sortedProviders = AppJsonRpcProvider.sortProviders(this.providers);
+                        _i = 0, sortedProviders_1 = sortedProviders;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < sortedProviders_1.length)) return [3 /*break*/, 6];
+                        _a = sortedProviders_1[_i], provider = _a.provider, controller = _a.controller;
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, provider.perform(method, params)];
+                    case 3:
+                        result = _b.sent();
+                        controller.onSuccess();
+                        return [2 /*return*/, result];
+                    case 4:
+                        error_1 = _b.sent();
+                        console.warn('rpc action failed', error_1);
+                        controller.onError();
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: throw new Error("All providers failed to perform the operation: ".concat(method));
+                }
+            });
+        });
+    };
+    AppJsonRpcProvider.sortProviders = function (providers) {
+        // Try enabled providers before resorting to disabled providers.
+        // Note that we do not filtered out disabled providers.
+        return __spreadArray([], providers, true).sort(function (_a, _b) {
+            var a = _a.controller.enabled;
+            var b = _b.controller.enabled;
+            if (a && !b) {
+                return -1;
+            }
+            else if (!a && b) {
+                return 1;
+            }
+            else {
+                return 0; // sort is stable
+            }
+        });
+    };
+    return AppJsonRpcProvider;
+}(ConfiguredJsonRpcProvider_1.default));
+exports.default = AppJsonRpcProvider;

package/lib/rpc/ConfiguredJsonRpcProvider.d.ts

@@ -0,0 +1,8 @@
+import { Networkish } from '@ethersproject/networks';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { SupportedInterfaceChain } from '../constants/chains';
+export default class ConfiguredJsonRpcProvider extends StaticJsonRpcProvider {
+    constructor(url: string | undefined, networkish: Networkish & {
+        chainId: SupportedInterfaceChain;
+    }, pollingInterval?: any);
+}

package/lib/rpc/ConfiguredJsonRpcProvider.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var providers_1 = require("@ethersproject/providers");
+var chainInfo_1 = require("../constants/chainInfo");
+var ConfiguredJsonRpcProvider = /** @class */ (function (_super) {
+    __extends(ConfiguredJsonRpcProvider, _super);
+    function ConfiguredJsonRpcProvider(url, 
+    // Including networkish allows ethers to skip the initial detectNetwork call.
+    networkish, pollingInterval) {
+        if (pollingInterval === void 0) { pollingInterval = chainInfo_1.AVERAGE_L1_BLOCK_TIME; }
+        var _this = _super.call(this, url, networkish) || this;
+        // NB: Third-party providers (eg MetaMask) will have their own polling intervals,
+        // which should be left as-is to allow operations (eg transaction confirmation) to resolve faster.
+        // Network providers need to update less frequently to be considered responsive.
+        _this.pollingInterval = pollingInterval;
+        return _this;
+    }
+    return ConfiguredJsonRpcProvider;
+}(providers_1.StaticJsonRpcProvider));
+exports.default = ConfiguredJsonRpcProvider;

package/lib/utils/contracts/getContract.d.ts

@@ -0,0 +1,3 @@
+import { Contract, ContractInterface } from '@ethersproject/contracts';
+import { JsonRpcProvider } from '@ethersproject/providers';
+export declare function getContract(address: string, ABI: ContractInterface, provider: JsonRpcProvider, account?: string): Contract;

package/lib/utils/contracts/getContract.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContract = void 0;
+var constants_1 = require("@ethersproject/constants");
+var contracts_1 = require("@ethersproject/contracts");
+var address_1 = require("@ethersproject/address");
+function isAddress(value) {
+    if (!value) {
+        return false;
+    }
+    try {
+        // Alphabetical letters must be made lowercase for getAddress to work.
+        // See documentation here: https://docs.ethers.io/v5/api/utils/address/
+        return (0, address_1.getAddress)(value.toLowerCase());
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function getContract(address, ABI, provider, account) {
+    if (!isAddress(address) || address === constants_1.AddressZero) {
+        throw Error("Invalid 'address' parameter '".concat(address, "'."));
+    }
+    return new contracts_1.Contract(address, ABI, getProviderOrSigner(provider, account));
+}
+exports.getContract = getContract;
+function getProviderOrSigner(provider, account) {
+    return account ? provider.getSigner(account).connectUnchecked() : provider;
+}

package/lib/utils/transformSwapRouteToGetQuoteResult.d.ts

@@ -0,0 +1,4 @@
+import { Currency, CurrencyAmount, TradeType } from '@uniswap/sdk-core';
+import { SwapRoute } from '@uniswap/smart-order-router';
+import { QuoteResult } from '../routing/types';
+export declare function transformSwapRouteToGetQuoteResult(tradeType: TradeType, amount: CurrencyAmount<Currency>, { quote, quoteGasAdjusted, route, estimatedGasUsed, estimatedGasUsedQuoteToken, estimatedGasUsedUSD, gasPriceWei, methodParameters, blockNumber, }: SwapRoute): QuoteResult;