@openocean.finance/openocean-sdk 1.2.1 → 1.2.3

package/lib/v1/entities/fractions/tokenAmount.js

@@ -0,0 +1,43 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenAmount = void 0;
+var currencyAmount_1 = require("./currencyAmount");
+var tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+var jsbi_1 = __importDefault(require("jsbi"));
+var TokenAmount = /** @class */ (function (_super) {
+    __extends(TokenAmount, _super);
+    // amount _must_ be raw, i.e. in the native representation
+    function TokenAmount(token, amount) {
+        var _this = _super.call(this, token, amount) || this;
+        _this.token = token;
+        return _this;
+    }
+    TokenAmount.prototype.add = function (other) {
+        (0, tiny_invariant_1.default)(this.token.equals(other.token), 'TOKEN');
+        return new TokenAmount(this.token, jsbi_1.default.add(this.raw, other.raw));
+    };
+    TokenAmount.prototype.subtract = function (other) {
+        (0, tiny_invariant_1.default)(this.token.equals(other.token), 'TOKEN');
+        return new TokenAmount(this.token, jsbi_1.default.subtract(this.raw, other.raw));
+    };
+    return TokenAmount;
+}(currencyAmount_1.CurrencyAmount));
+exports.TokenAmount = TokenAmount;

package/lib/v1/entities/index.d.ts

@@ -0,0 +1,6 @@
+export * from './token';
+export * from './pair';
+export * from './route';
+export * from './trade';
+export * from './currency';
+export * from './fractions';

package/lib/v1/entities/index.js

@@ -0,0 +1,22 @@
+"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("./token"), exports);
+__exportStar(require("./pair"), exports);
+__exportStar(require("./route"), exports);
+__exportStar(require("./trade"), exports);
+__exportStar(require("./currency"), exports);
+__exportStar(require("./fractions"), exports);

package/lib/v1/entities/pair.d.ts

@@ -0,0 +1,41 @@
+import { Price } from './fractions/price';
+import { TokenAmount } from './fractions/tokenAmount';
+import { BigintIsh, ChainId } from '../constants';
+import { Token } from './token';
+export declare class Pair {
+    readonly liquidityToken: Token;
+    private readonly tokenAmounts;
+    static getAddress(tokenA: Token, tokenB: Token): string;
+    constructor(tokenAmountA: TokenAmount, tokenAmountB: TokenAmount);
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token to check
+     */
+    involvesToken(token: Token): boolean;
+    /**
+     * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
+     */
+    get token0Price(): Price;
+    /**
+     * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
+     */
+    get token1Price(): Price;
+    /**
+     * Return the price of the given token in terms of the other token in the pair.
+     * @param token token to return price of
+     */
+    priceOf(token: Token): Price;
+    /**
+     * Returns the chain ID of the tokens in the pair.
+     */
+    get chainId(): ChainId;
+    get token0(): Token;
+    get token1(): Token;
+    get reserve0(): TokenAmount;
+    get reserve1(): TokenAmount;
+    reserveOf(token: Token): TokenAmount;
+    getOutputAmount(inputAmount: TokenAmount): [TokenAmount, Pair];
+    getInputAmount(outputAmount: TokenAmount): [TokenAmount, Pair];
+    getLiquidityMinted(totalSupply: TokenAmount, tokenAmountA: TokenAmount, tokenAmountB: TokenAmount): TokenAmount;
+    getLiquidityValue(token: Token, totalSupply: TokenAmount, liquidity: TokenAmount, feeOn?: boolean, kLast?: BigintIsh): TokenAmount;
+}

package/lib/v1/entities/pair.js

@@ -0,0 +1,210 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pair = void 0;
+var price_1 = require("./fractions/price");
+var tokenAmount_1 = require("./fractions/tokenAmount");
+var tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+var jsbi_1 = __importDefault(require("jsbi"));
+var solidity_1 = require("@ethersproject/solidity");
+var address_1 = require("@ethersproject/address");
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var errors_1 = require("../errors");
+var token_1 = require("./token");
+var PAIR_ADDRESS_CACHE = {};
+var Pair = /** @class */ (function () {
+    function Pair(tokenAmountA, tokenAmountB) {
+        var tokenAmounts = tokenAmountA.token.sortsBefore(tokenAmountB.token) // does safety checks
+            ? [tokenAmountA, tokenAmountB]
+            : [tokenAmountB, tokenAmountA];
+        this.liquidityToken = new token_1.Token(tokenAmounts[0].token.chainId, Pair.getAddress(tokenAmounts[0].token, tokenAmounts[1].token), 18, 'UNI-V2', 'Uniswap V2');
+        this.tokenAmounts = tokenAmounts;
+    }
+    Pair.getAddress = function (tokenA, tokenB) {
+        var _a, _b;
+        var _c;
+        var tokens = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA]; // does safety checks
+        if (((_c = PAIR_ADDRESS_CACHE === null || PAIR_ADDRESS_CACHE === void 0 ? void 0 : PAIR_ADDRESS_CACHE[tokens[0].address]) === null || _c === void 0 ? void 0 : _c[tokens[1].address]) === undefined) {
+            var chainId = tokenA.chainId;
+            var factory_address = constants_1.FACTORY_ADDRESS[chainId];
+            var init_code_hash = constants_1.INIT_CODE_HASH[chainId];
+            PAIR_ADDRESS_CACHE = __assign(__assign({}, PAIR_ADDRESS_CACHE), (_a = {}, _a[tokens[0].address] = __assign(__assign({}, PAIR_ADDRESS_CACHE === null || PAIR_ADDRESS_CACHE === void 0 ? void 0 : PAIR_ADDRESS_CACHE[tokens[0].address]), (_b = {}, _b[tokens[1].address] = (0, address_1.getCreate2Address)(factory_address, (0, solidity_1.keccak256)(['bytes'], [(0, solidity_1.pack)(['address', 'address'], [tokens[0].address, tokens[1].address])]), init_code_hash), _b)), _a));
+        }
+        return PAIR_ADDRESS_CACHE[tokens[0].address][tokens[1].address];
+    };
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token to check
+     */
+    Pair.prototype.involvesToken = function (token) {
+        return token.equals(this.token0) || token.equals(this.token1);
+    };
+    Object.defineProperty(Pair.prototype, "token0Price", {
+        /**
+         * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
+         */
+        get: function () {
+            return new price_1.Price(this.token0, this.token1, this.tokenAmounts[0].raw, this.tokenAmounts[1].raw);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Pair.prototype, "token1Price", {
+        /**
+         * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
+         */
+        get: function () {
+            return new price_1.Price(this.token1, this.token0, this.tokenAmounts[1].raw, this.tokenAmounts[0].raw);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Return the price of the given token in terms of the other token in the pair.
+     * @param token token to return price of
+     */
+    Pair.prototype.priceOf = function (token) {
+        (0, tiny_invariant_1.default)(this.involvesToken(token), 'TOKEN');
+        return token.equals(this.token0) ? this.token0Price : this.token1Price;
+    };
+    Object.defineProperty(Pair.prototype, "chainId", {
+        /**
+         * Returns the chain ID of the tokens in the pair.
+         */
+        get: function () {
+            return this.token0.chainId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Pair.prototype, "token0", {
+        get: function () {
+            return this.tokenAmounts[0].token;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Pair.prototype, "token1", {
+        get: function () {
+            return this.tokenAmounts[1].token;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Pair.prototype, "reserve0", {
+        get: function () {
+            return this.tokenAmounts[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Pair.prototype, "reserve1", {
+        get: function () {
+            return this.tokenAmounts[1];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Pair.prototype.reserveOf = function (token) {
+        (0, tiny_invariant_1.default)(this.involvesToken(token), 'TOKEN');
+        return token.equals(this.token0) ? this.reserve0 : this.reserve1;
+    };
+    Pair.prototype.getOutputAmount = function (inputAmount) {
+        (0, tiny_invariant_1.default)(this.involvesToken(inputAmount.token), 'TOKEN');
+        if (jsbi_1.default.equal(this.reserve0.raw, constants_1.ZERO) || jsbi_1.default.equal(this.reserve1.raw, constants_1.ZERO)) {
+            throw new errors_1.InsufficientReservesError();
+        }
+        var inputReserve = this.reserveOf(inputAmount.token);
+        var outputReserve = this.reserveOf(inputAmount.token.equals(this.token0) ? this.token1 : this.token0);
+        var inputAmountWithFee = jsbi_1.default.multiply(inputAmount.raw, constants_1._998);
+        var numerator = jsbi_1.default.multiply(inputAmountWithFee, outputReserve.raw);
+        var denominator = jsbi_1.default.add(jsbi_1.default.multiply(inputReserve.raw, constants_1._1000), inputAmountWithFee);
+        var outputAmount = new tokenAmount_1.TokenAmount(inputAmount.token.equals(this.token0) ? this.token1 : this.token0, jsbi_1.default.divide(numerator, denominator));
+        if (jsbi_1.default.equal(outputAmount.raw, constants_1.ZERO)) {
+            throw new errors_1.InsufficientInputAmountError();
+        }
+        return [outputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
+    };
+    Pair.prototype.getInputAmount = function (outputAmount) {
+        (0, tiny_invariant_1.default)(this.involvesToken(outputAmount.token), 'TOKEN');
+        if (jsbi_1.default.equal(this.reserve0.raw, constants_1.ZERO) ||
+            jsbi_1.default.equal(this.reserve1.raw, constants_1.ZERO) ||
+            jsbi_1.default.greaterThanOrEqual(outputAmount.raw, this.reserveOf(outputAmount.token).raw)) {
+            throw new errors_1.InsufficientReservesError();
+        }
+        var outputReserve = this.reserveOf(outputAmount.token);
+        var inputReserve = this.reserveOf(outputAmount.token.equals(this.token0) ? this.token1 : this.token0);
+        var numerator = jsbi_1.default.multiply(jsbi_1.default.multiply(inputReserve.raw, outputAmount.raw), constants_1._1000);
+        var denominator = jsbi_1.default.multiply(jsbi_1.default.subtract(outputReserve.raw, outputAmount.raw), constants_1._998);
+        var inputAmount = new tokenAmount_1.TokenAmount(outputAmount.token.equals(this.token0) ? this.token1 : this.token0, jsbi_1.default.add(jsbi_1.default.divide(numerator, denominator), constants_1.ONE));
+        return [inputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
+    };
+    Pair.prototype.getLiquidityMinted = function (totalSupply, tokenAmountA, tokenAmountB) {
+        (0, tiny_invariant_1.default)(totalSupply.token.equals(this.liquidityToken), 'LIQUIDITY');
+        var tokenAmounts = tokenAmountA.token.sortsBefore(tokenAmountB.token) // does safety checks
+            ? [tokenAmountA, tokenAmountB]
+            : [tokenAmountB, tokenAmountA];
+        (0, tiny_invariant_1.default)(tokenAmounts[0].token.equals(this.token0) && tokenAmounts[1].token.equals(this.token1), 'TOKEN');
+        var liquidity;
+        if (jsbi_1.default.equal(totalSupply.raw, constants_1.ZERO)) {
+            liquidity = jsbi_1.default.subtract((0, utils_1.sqrt)(jsbi_1.default.multiply(tokenAmounts[0].raw, tokenAmounts[1].raw)), constants_1.MINIMUM_LIQUIDITY);
+        }
+        else {
+            var amount0 = jsbi_1.default.divide(jsbi_1.default.multiply(tokenAmounts[0].raw, totalSupply.raw), this.reserve0.raw);
+            var amount1 = jsbi_1.default.divide(jsbi_1.default.multiply(tokenAmounts[1].raw, totalSupply.raw), this.reserve1.raw);
+            liquidity = jsbi_1.default.lessThanOrEqual(amount0, amount1) ? amount0 : amount1;
+        }
+        if (!jsbi_1.default.greaterThan(liquidity, constants_1.ZERO)) {
+            throw new errors_1.InsufficientInputAmountError();
+        }
+        return new tokenAmount_1.TokenAmount(this.liquidityToken, liquidity);
+    };
+    Pair.prototype.getLiquidityValue = function (token, totalSupply, liquidity, feeOn, kLast) {
+        if (feeOn === void 0) { feeOn = false; }
+        (0, tiny_invariant_1.default)(this.involvesToken(token), 'TOKEN');
+        (0, tiny_invariant_1.default)(totalSupply.token.equals(this.liquidityToken), 'TOTAL_SUPPLY');
+        (0, tiny_invariant_1.default)(liquidity.token.equals(this.liquidityToken), 'LIQUIDITY');
+        (0, tiny_invariant_1.default)(jsbi_1.default.lessThanOrEqual(liquidity.raw, totalSupply.raw), 'LIQUIDITY');
+        var totalSupplyAdjusted;
+        if (!feeOn) {
+            totalSupplyAdjusted = totalSupply;
+        }
+        else {
+            (0, tiny_invariant_1.default)(!!kLast, 'K_LAST');
+            var kLastParsed = (0, utils_1.parseBigintIsh)(kLast);
+            if (!jsbi_1.default.equal(kLastParsed, constants_1.ZERO)) {
+                var rootK = (0, utils_1.sqrt)(jsbi_1.default.multiply(this.reserve0.raw, this.reserve1.raw));
+                var rootKLast = (0, utils_1.sqrt)(kLastParsed);
+                if (jsbi_1.default.greaterThan(rootK, rootKLast)) {
+                    var numerator = jsbi_1.default.multiply(totalSupply.raw, jsbi_1.default.subtract(rootK, rootKLast));
+                    var denominator = jsbi_1.default.add(jsbi_1.default.multiply(rootK, constants_1.FIVE), rootKLast);
+                    var feeLiquidity = jsbi_1.default.divide(numerator, denominator);
+                    totalSupplyAdjusted = totalSupply.add(new tokenAmount_1.TokenAmount(this.liquidityToken, feeLiquidity));
+                }
+                else {
+                    totalSupplyAdjusted = totalSupply;
+                }
+            }
+            else {
+                totalSupplyAdjusted = totalSupply;
+            }
+        }
+        return new tokenAmount_1.TokenAmount(token, jsbi_1.default.divide(jsbi_1.default.multiply(liquidity.raw, this.reserveOf(token).raw), totalSupplyAdjusted.raw));
+    };
+    return Pair;
+}());
+exports.Pair = Pair;

package/lib/v1/entities/route.d.ts

@@ -0,0 +1,14 @@
+import { ChainId } from '../constants';
+import { Currency } from './currency';
+import { Token } from './token';
+import { Pair } from './pair';
+import { Price } from './fractions/price';
+export declare class Route {
+    readonly pairs: Pair[];
+    readonly path: Token[];
+    readonly input: Currency;
+    readonly output: Currency;
+    readonly midPrice: Price;
+    constructor(pairs: any, input: Currency, output?: Currency);
+    get chainId(): ChainId;
+}

package/lib/v1/entities/route.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+var tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+var currency_1 = require("./currency");
+var token_1 = require("./token");
+var price_1 = require("./fractions/price");
+var Route = /** @class */ (function () {
+    function Route(pairs, input, output) {
+        (0, tiny_invariant_1.default)(pairs.length > 0, 'PAIRS');
+        (0, tiny_invariant_1.default)(pairs.every(function (pair) { return pair.chainId === pairs[0].chainId; }), 'CHAIN_IDS');
+        (0, tiny_invariant_1.default)((input instanceof token_1.Token && pairs[0].involvesToken(input)) ||
+            (input === currency_1.ETHER && pairs[0].involvesToken(token_1.WETH[pairs[0].chainId])), 'INPUT');
+        (0, tiny_invariant_1.default)(typeof output === 'undefined' ||
+            (output instanceof token_1.Token && pairs[pairs.length - 1].involvesToken(output)) ||
+            (output === currency_1.ETHER && pairs[pairs.length - 1].involvesToken(token_1.WETH[pairs[0].chainId])), 'OUTPUT');
+        var path = [input instanceof token_1.Token ? input : token_1.WETH[pairs[0].chainId]];
+        for (var _i = 0, _a = pairs.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], i = _b[0], pair = _b[1];
+            var currentInput = path[i];
+            (0, tiny_invariant_1.default)(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), 'PATH');
+            var output_1 = currentInput.equals(pair.token0) ? pair.token1 : pair.token0;
+            path.push(output_1);
+        }
+        this.pairs = pairs;
+        this.path = path;
+        this.midPrice = price_1.Price.fromRoute(this);
+        this.input = input;
+        this.output = output !== null && output !== void 0 ? output : path[path.length - 1];
+    }
+    Object.defineProperty(Route.prototype, "chainId", {
+        get: function () {
+            return this.pairs[0].chainId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Route;
+}());
+exports.Route = Route;

package/lib/v1/entities/token.d.ts

@@ -0,0 +1,27 @@
+import { ChainId } from '../constants';
+import { Currency } from './currency';
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export declare class Token extends Currency {
+    readonly chainId: ChainId;
+    readonly address: string;
+    constructor(chainId: ChainId, address: string, decimals: number, symbol?: string, name?: string);
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: Token): boolean;
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @throws if the tokens have the same address
+     * @throws if the tokens are on different chains
+     */
+    sortsBefore(other: Token): boolean;
+}
+/**
+ * Compares two currencies for equality
+ */
+export declare function currencyEquals(currencyA: Currency, currencyB: Currency): boolean;
+export declare const WETH: any;

package/lib/v1/entities/token.js

@@ -0,0 +1,87 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WETH = exports.currencyEquals = exports.Token = void 0;
+var tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+var currency_1 = require("./currency");
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+var Token = /** @class */ (function (_super) {
+    __extends(Token, _super);
+    function Token(chainId, address, decimals, symbol, name) {
+        var _this = _super.call(this, decimals, symbol, name) || this;
+        _this.chainId = chainId;
+        _this.address = (0, utils_1.validateAndParseAddress)(address);
+        return _this;
+    }
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    Token.prototype.equals = function (other) {
+        // short circuit on reference equality
+        if (this === other) {
+            return true;
+        }
+        return this.chainId === other.chainId && this.address === other.address;
+    };
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @throws if the tokens have the same address
+     * @throws if the tokens are on different chains
+     */
+    Token.prototype.sortsBefore = function (other) {
+        (0, tiny_invariant_1.default)(this.chainId === other.chainId, 'CHAIN_IDS');
+        (0, tiny_invariant_1.default)(this.address !== other.address, 'ADDRESSES');
+        return this.address.toLowerCase() < other.address.toLowerCase();
+    };
+    return Token;
+}(currency_1.Currency));
+exports.Token = Token;
+/**
+ * Compares two currencies for equality
+ */
+function currencyEquals(currencyA, currencyB) {
+    if (currencyA instanceof Token && currencyB instanceof Token) {
+        return currencyA.equals(currencyB);
+    }
+    else if (currencyA instanceof Token) {
+        return false;
+    }
+    else if (currencyB instanceof Token) {
+        return false;
+    }
+    else {
+        return currencyA === currencyB;
+    }
+}
+exports.currencyEquals = currencyEquals;
+exports.WETH = (_a = {},
+    _a[constants_1.ChainId.ETH] = new Token(constants_1.ChainId.ETH, '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', 18, 'WETH', 'Wrapped ETH'),
+    _a[constants_1.ChainId.MAINNET] = new Token(constants_1.ChainId.MAINNET, '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', 18, 'WBNB', 'Wrapped BNB'),
+    _a[constants_1.ChainId.BSCTESTNET] = new Token(constants_1.ChainId.BSCTESTNET, '0xaE8E19eFB41e7b96815649A6a60785e1fbA84C1e', 18, 'WBNB', 'Wrapped BNB'),
+    _a[constants_1.ChainId.POLYGON] = new Token(constants_1.ChainId.POLYGON, '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270', 18, 'WMATIC', 'Wrapped MATIC'),
+    _a[constants_1.ChainId.AVAX] = new Token(constants_1.ChainId.AVAX, '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7', 18, 'WAVAX', 'Avalanche Token'),
+    _a);

package/lib/v1/entities/trade.d.ts

@@ -0,0 +1,106 @@
+import { TradeType } from '../constants';
+import { Currency } from './currency';
+import { CurrencyAmount } from './fractions/currencyAmount';
+import { Percent } from './fractions/percent';
+import { Price } from './fractions/price';
+import { Pair } from './pair';
+import { Route } from './route';
+interface InputOutput {
+    readonly inputAmount: CurrencyAmount;
+    readonly outputAmount: CurrencyAmount;
+}
+export declare function inputOutputComparator(a: InputOutput, b: InputOutput): number;
+export declare function tradeComparator(a: Trade, b: Trade): number;
+export interface BestTradeOptions {
+    maxNumResults?: number;
+    maxHops?: number;
+}
+/**
+ * Represents a trade executed against a list of pairs.
+ * Does not account for slippage, i.e. trades that front run this trade and move the price.
+ */
+export declare class Trade {
+    /**
+     * The route of the trade, i.e. which pairs the trade goes through.
+     */
+    readonly route: Route;
+    /**
+     * The type of the trade, either exact in or exact out.
+     */
+    readonly tradeType: TradeType;
+    /**
+     * The input amount for the trade assuming no slippage.
+     */
+    readonly inputAmount: CurrencyAmount;
+    /**
+     * The output amount for the trade assuming no slippage.
+     */
+    readonly outputAmount: CurrencyAmount;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    readonly executionPrice: Price;
+    /**
+     * The mid price after the trade executes assuming no slippage.
+     */
+    readonly nextMidPrice: Price;
+    /**
+     * The percent difference between the mid price before the trade and the trade execution price.
+     */
+    readonly priceImpact: Percent;
+    /**
+     * Constructs an exact in trade with the given amount in and route
+     * @param route route of the exact in trade
+     * @param amountIn the amount being passed in
+     */
+    static exactIn(route: Route, amountIn: CurrencyAmount): Trade;
+    /**
+     * Constructs an exact out trade with the given amount out and route
+     * @param route route of the exact out trade
+     * @param amountOut the amount returned by the trade
+     */
+    static exactOut(route: Route, amountOut: CurrencyAmount): Trade;
+    constructor(route: Route, amount: CurrencyAmount, tradeType: TradeType);
+    /**
+     * Get the minimum amount that must be received from this trade for the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
+     */
+    minimumAmountOut(slippageTolerance: Percent): CurrencyAmount;
+    /**
+     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
+     */
+    maximumAmountIn(slippageTolerance: Percent): CurrencyAmount;
+    /**
+     * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
+     * amount to an output token, making at most `maxHops` hops.
+     * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pairs the pairs to consider in finding the best trade
+     * @param currencyAmountIn exact amount of input currency to spend
+     * @param currencyOut the desired currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
+     * @param currentPairs used in recursion; the current list of pairs
+     * @param originalAmountIn used in recursion; the original value of the currencyAmountIn parameter
+     * @param bestTrades used in recursion; the current list of best trades
+     */
+    static bestTradeExactIn(pairs: Pair[], currencyAmountIn: CurrencyAmount, currencyOut: Currency, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], originalAmountIn?: CurrencyAmount, bestTrades?: Trade[]): Trade[];
+    /**
+     * similar to the above method but instead targets a fixed output amount
+     * given a list of pairs, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
+     * to an output token amount, making at most `maxHops` hops
+     * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
+     * the amount in among multiple routes.
+     * @param pairs the pairs to consider in finding the best trade
+     * @param currencyIn the currency to spend
+     * @param currencyAmountOut the exact amount of currency out
+     * @param maxNumResults maximum number of results to return
+     * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
+     * @param currentPairs used in recursion; the current list of pairs
+     * @param originalAmountOut used in recursion; the original value of the currencyAmountOut parameter
+     * @param bestTrades used in recursion; the current list of best trades
+     */
+    static bestTradeExactOut(pairs: Pair[], currencyIn: Currency, currencyAmountOut: CurrencyAmount, { maxNumResults, maxHops }?: BestTradeOptions, currentPairs?: Pair[], originalAmountOut?: CurrencyAmount, bestTrades?: Trade[]): Trade[];
+}
+export {};