@openocean.finance/openocean-sdk 1.2.33 → 1.2.35

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.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.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);