@alcorexchange/alcor-swap-sdk 1.0.0

package/.eslintignore

@@ -0,0 +1,2 @@
+node_modules
+dist

package/.eslintrc

@@ -0,0 +1,12 @@
+{
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint"
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended"
+    ]
+  }

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ChimGoKien
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/entities/baseCurrency.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCurrency = void 0;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+class BaseCurrency {
+    /**
+     * Constructs an instance of the base class `BaseCurrency`.
+     * @param chainId the chain ID on which this currency resides
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    constructor(contract, decimals, symbol, id) {
+        (0, tiny_invariant_1.default)(decimals >= 0 && decimals < 19 && Number.isInteger(decimals), "DECIMALS");
+        this.contract = contract;
+        this.decimals = decimals;
+        this.symbol = symbol;
+        this.id = id;
+    }
+}
+exports.BaseCurrency = BaseCurrency;

package/build/entities/currency.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/entities/fractions/currencyAmount.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrencyAmount = void 0;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const jsbi_1 = __importDefault(require("jsbi"));
+const fraction_1 = require("./fraction");
+const big_js_1 = __importDefault(require("big.js"));
+const toformat_1 = __importDefault(require("toformat"));
+const internalConstants_1 = require("../../internalConstants");
+const Big = (0, toformat_1.default)(big_js_1.default);
+class CurrencyAmount extends fraction_1.Fraction {
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount(currency, rawAmount) {
+        return new CurrencyAmount(currency, rawAmount);
+    }
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount(currency, numerator, denominator) {
+        return new CurrencyAmount(currency, numerator, denominator);
+    }
+    constructor(currency, numerator, denominator) {
+        super(numerator, denominator);
+        (0, tiny_invariant_1.default)(jsbi_1.default.lessThanOrEqual(this.quotient, internalConstants_1.MaxUint256), "AMOUNT");
+        this.currency = currency;
+        this.decimalScale = jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(currency.decimals));
+    }
+    add(other) {
+        (0, tiny_invariant_1.default)(this.currency.equals(other.currency), "CURRENCY");
+        const added = super.add(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
+    }
+    subtract(other) {
+        (0, tiny_invariant_1.default)(this.currency.equals(other.currency), "CURRENCY");
+        const subtracted = super.subtract(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
+    }
+    multiply(other) {
+        const multiplied = super.multiply(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
+    }
+    divide(other) {
+        const divided = super.divide(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
+    }
+    toSignificant(significantDigits = 6, format, rounding = internalConstants_1.Rounding.ROUND_DOWN) {
+        return super
+            .divide(this.decimalScale)
+            .toSignificant(significantDigits, format, rounding);
+    }
+    toFixed(decimalPlaces = this.currency.decimals, format, rounding = internalConstants_1.Rounding.ROUND_DOWN) {
+        (0, tiny_invariant_1.default)(decimalPlaces <= this.currency.decimals, "DECIMALS");
+        return super
+            .divide(this.decimalScale)
+            .toFixed(decimalPlaces, format, rounding);
+    }
+    toExact(format = { groupSeparator: "" }) {
+        Big.DP = this.currency.decimals;
+        return new Big(this.quotient.toString())
+            .div(this.decimalScale.toString())
+            .toFormat(format);
+    }
+    toAsset(...args) {
+        return `${this.toFixed(...args)} ${this.currency.symbol}`;
+    }
+    toExtendedAsset(...args) {
+        return `${this.toFixed(...args)} ${this.currency.symbol}@${this.currency.contract}`;
+    }
+}
+exports.CurrencyAmount = CurrencyAmount;

package/build/entities/fractions/fraction.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.Fraction = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const toformat_1 = __importDefault(require("toformat"));
+const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+const big_js_1 = __importDefault(require("big.js"));
+const internalConstants_1 = require("../../internalConstants");
+const Decimal = (0, toformat_1.default)(decimal_js_light_1.default);
+const Big = (0, toformat_1.default)(big_js_1.default);
+const toSignificantRounding = {
+    [internalConstants_1.Rounding.ROUND_DOWN]: Decimal.ROUND_DOWN,
+    [internalConstants_1.Rounding.ROUND_HALF_UP]: Decimal.ROUND_HALF_UP,
+    [internalConstants_1.Rounding.ROUND_UP]: Decimal.ROUND_UP,
+};
+// const toFixedRounding = {
+//   [Rounding.ROUND_DOWN]: RoundingMode.RoundDown,
+//   [Rounding.ROUND_HALF_UP]: RoundingMode.RoundHalfUp,
+//   [Rounding.ROUND_UP]: RoundingMode.RoundUp
+// }
+const toFixedRounding = {
+    [internalConstants_1.Rounding.ROUND_DOWN]: 0,
+    [internalConstants_1.Rounding.ROUND_HALF_UP]: 1,
+    [internalConstants_1.Rounding.ROUND_UP]: 3,
+};
+class Fraction {
+    constructor(numerator, denominator = jsbi_1.default.BigInt(1)) {
+        this.numerator = jsbi_1.default.BigInt(numerator);
+        this.denominator = jsbi_1.default.BigInt(denominator);
+    }
+    static tryParseFraction(fractionish) {
+        if (fractionish instanceof jsbi_1.default ||
+            typeof fractionish === "number" ||
+            typeof fractionish === "string")
+            return new Fraction(fractionish);
+        if ("numerator" in fractionish && "denominator" in fractionish)
+            return fractionish;
+        throw new Error("Could not parse fraction");
+    }
+    // performs floor division
+    get quotient() {
+        return jsbi_1.default.divide(this.numerator, this.denominator);
+    }
+    // remainder after floor division
+    get remainder() {
+        return new Fraction(jsbi_1.default.remainder(this.numerator, this.denominator), this.denominator);
+    }
+    invert() {
+        return new Fraction(this.denominator, this.numerator);
+    }
+    add(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        if (jsbi_1.default.equal(this.denominator, otherParsed.denominator)) {
+            return new Fraction(jsbi_1.default.add(this.numerator, otherParsed.numerator), this.denominator);
+        }
+        return new Fraction(jsbi_1.default.add(jsbi_1.default.multiply(this.numerator, otherParsed.denominator), jsbi_1.default.multiply(otherParsed.numerator, this.denominator)), jsbi_1.default.multiply(this.denominator, otherParsed.denominator));
+    }
+    subtract(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        if (jsbi_1.default.equal(this.denominator, otherParsed.denominator)) {
+            return new Fraction(jsbi_1.default.subtract(this.numerator, otherParsed.numerator), this.denominator);
+        }
+        return new Fraction(jsbi_1.default.subtract(jsbi_1.default.multiply(this.numerator, otherParsed.denominator), jsbi_1.default.multiply(otherParsed.numerator, this.denominator)), jsbi_1.default.multiply(this.denominator, otherParsed.denominator));
+    }
+    lessThan(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        return jsbi_1.default.lessThan(jsbi_1.default.multiply(this.numerator, otherParsed.denominator), jsbi_1.default.multiply(otherParsed.numerator, this.denominator));
+    }
+    equalTo(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        return jsbi_1.default.equal(jsbi_1.default.multiply(this.numerator, otherParsed.denominator), jsbi_1.default.multiply(otherParsed.numerator, this.denominator));
+    }
+    greaterThan(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        return jsbi_1.default.greaterThan(jsbi_1.default.multiply(this.numerator, otherParsed.denominator), jsbi_1.default.multiply(otherParsed.numerator, this.denominator));
+    }
+    multiply(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        return new Fraction(jsbi_1.default.multiply(this.numerator, otherParsed.numerator), jsbi_1.default.multiply(this.denominator, otherParsed.denominator));
+    }
+    divide(other) {
+        const otherParsed = Fraction.tryParseFraction(other);
+        return new Fraction(jsbi_1.default.multiply(this.numerator, otherParsed.denominator), jsbi_1.default.multiply(this.denominator, otherParsed.numerator));
+    }
+    toSignificant(significantDigits, format = { groupSeparator: "" }, rounding = internalConstants_1.Rounding.ROUND_HALF_UP) {
+        (0, tiny_invariant_1.default)(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
+        (0, tiny_invariant_1.default)(significantDigits > 0, `${significantDigits} is not positive.`);
+        Decimal.set({
+            precision: significantDigits + 1,
+            rounding: toSignificantRounding[rounding],
+        });
+        const quotient = new Decimal(this.numerator.toString())
+            .div(this.denominator.toString())
+            .toSignificantDigits(significantDigits);
+        return quotient.toFormat(quotient.decimalPlaces(), format);
+    }
+    toFixed(decimalPlaces, format = { groupSeparator: "" }, rounding = internalConstants_1.Rounding.ROUND_HALF_UP) {
+        (0, tiny_invariant_1.default)(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
+        (0, tiny_invariant_1.default)(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
+        Big.DP = decimalPlaces;
+        Big.RM = toFixedRounding[rounding];
+        return new Big(this.numerator.toString())
+            .div(this.denominator.toString())
+            .toFormat(decimalPlaces, format);
+    }
+    /**
+     * Helper method for converting any super class back to a fraction
+     */
+    get asFraction() {
+        return new Fraction(this.numerator, this.denominator);
+    }
+}
+exports.Fraction = Fraction;

package/build/entities/fractions/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Price = exports.Percent = exports.Fraction = exports.CurrencyAmount = void 0;
+var currencyAmount_1 = require("./currencyAmount");
+Object.defineProperty(exports, "CurrencyAmount", { enumerable: true, get: function () { return currencyAmount_1.CurrencyAmount; } });
+var fraction_1 = require("./fraction");
+Object.defineProperty(exports, "Fraction", { enumerable: true, get: function () { return fraction_1.Fraction; } });
+var percent_1 = require("./percent");
+Object.defineProperty(exports, "Percent", { enumerable: true, get: function () { return percent_1.Percent; } });
+var price_1 = require("./price");
+Object.defineProperty(exports, "Price", { enumerable: true, get: function () { return price_1.Price; } });

package/build/entities/fractions/percent.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Percent = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const fraction_1 = require("./fraction");
+const ONE_HUNDRED = new fraction_1.Fraction(jsbi_1.default.BigInt(100));
+/**
+ * Converts a fraction to a percent
+ * @param fraction the fraction to convert
+ */
+function toPercent(fraction) {
+    return new Percent(fraction.numerator, fraction.denominator);
+}
+class Percent extends fraction_1.Fraction {
+    constructor() {
+        super(...arguments);
+        /**
+         * This boolean prevents a fraction from being interpreted as a Percent
+         */
+        this.isPercent = true;
+    }
+    add(other) {
+        return toPercent(super.add(other));
+    }
+    subtract(other) {
+        return toPercent(super.subtract(other));
+    }
+    multiply(other) {
+        return toPercent(super.multiply(other));
+    }
+    divide(other) {
+        return toPercent(super.divide(other));
+    }
+    toSignificant(significantDigits = 5, format, rounding) {
+        return super
+            .multiply(ONE_HUNDRED)
+            .toSignificant(significantDigits, format, rounding);
+    }
+    toFixed(decimalPlaces = 2, format, rounding) {
+        return super.multiply(ONE_HUNDRED).toFixed(decimalPlaces, format, rounding);
+    }
+}
+exports.Percent = Percent;

package/build/entities/fractions/price.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Price = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const fraction_1 = require("./fraction");
+const currencyAmount_1 = require("./currencyAmount");
+class Price extends fraction_1.Fraction {
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args) {
+        let baseCurrency, quoteCurrency, denominator, numerator;
+        if (args.length === 4) {
+            [baseCurrency, quoteCurrency, denominator, numerator] = args;
+        }
+        else {
+            const result = args[0].quoteAmount.divide(args[0].baseAmount);
+            [baseCurrency, quoteCurrency, denominator, numerator] = [
+                args[0].baseAmount.currency,
+                args[0].quoteAmount.currency,
+                result.denominator,
+                result.numerator,
+            ];
+        }
+        super(numerator, denominator);
+        this.baseCurrency = baseCurrency;
+        this.quoteCurrency = quoteCurrency;
+        this.scalar = new fraction_1.Fraction(jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(baseCurrency.decimals)), jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(quoteCurrency.decimals)));
+    }
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert() {
+        return new Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
+    }
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply(other) {
+        (0, tiny_invariant_1.default)(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
+        const fraction = super.multiply(other);
+        return new Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
+    }
+    /**
+     * Return the amount of quote currency corresponding to a given amount of the base currency
+     * @param currencyAmount the amount of base currency to quote against the price
+     */
+    quote(currencyAmount) {
+        (0, tiny_invariant_1.default)(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+        const result = super.multiply(currencyAmount);
+        return currencyAmount_1.CurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
+    }
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    get adjustedForDecimals() {
+        return super.multiply(this.scalar);
+    }
+    toSignificant(significantDigits = 6, format, rounding) {
+        return this.adjustedForDecimals.toSignificant(significantDigits, format, rounding);
+    }
+    toFixed(decimalPlaces = 4, format, rounding) {
+        return this.adjustedForDecimals.toFixed(decimalPlaces, format, rounding);
+    }
+}
+exports.Price = Price;

package/build/entities/index.js

@@ -0,0 +1,26 @@
+"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("./fractions"), exports);
+__exportStar(require("./tick"), exports);
+__exportStar(require("./tickDataProvider"), exports);
+__exportStar(require("./tickListDataProvider"), exports);
+__exportStar(require("./currency"), exports);
+__exportStar(require("./token"), exports);
+__exportStar(require("./pool"), exports);
+__exportStar(require("./position"), exports);
+__exportStar(require("./route"), exports);
+__exportStar(require("./trade"), exports);