@alcorexchange/alcor-swap-sdk 1.0.0

package/build/entities/route.js

@@ -0,0 +1,70 @@
+"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;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const fractions_1 = require("./fractions");
+/**
+ * Represents a list of pools through which a swap can occur
+ * @template TInput The input token
+ * @template TOutput The output token
+ */
+class Route {
+    /**
+     * Creates an instance of route.
+     * @param pools An array of `Pool` objects, ordered by the route the swap will take
+     * @param input The input token
+     * @param output The output token
+     */
+    constructor(pools, input, output) {
+        this._midPrice = null;
+        (0, tiny_invariant_1.default)(pools.length > 0, 'POOLS');
+        const wrappedInput = input;
+        (0, tiny_invariant_1.default)(pools[0].involvesToken(wrappedInput), 'INPUT');
+        (0, tiny_invariant_1.default)(pools[pools.length - 1].involvesToken(output), 'OUTPUT');
+        /**
+         * Normalizes tokenA-tokenB order and selects the next token/fee step to add to the path
+         * */
+        const tokenPath = [wrappedInput];
+        for (const [i, pool] of pools.entries()) {
+            const currentInputToken = tokenPath[i];
+            (0, tiny_invariant_1.default)(currentInputToken.equals(pool.tokenA) || currentInputToken.equals(pool.tokenB), 'PATH');
+            const nextToken = currentInputToken.equals(pool.tokenA) ? pool.tokenB : pool.tokenA;
+            tokenPath.push(nextToken);
+        }
+        this.pools = pools;
+        this.tokenPath = tokenPath;
+        this.input = input;
+        this.output = output !== null && output !== void 0 ? output : tokenPath[tokenPath.length - 1];
+    }
+    /**
+     * Returns the mid price of the route
+     */
+    get midPrice() {
+        if (this._midPrice !== null)
+            return this._midPrice;
+        const price = this.pools.slice(1).reduce(({ nextInput, price }, pool) => {
+            return nextInput.equals(pool.tokenA)
+                ? {
+                    nextInput: pool.tokenB,
+                    price: price.multiply(pool.tokenAPrice)
+                }
+                : {
+                    nextInput: pool.tokenA,
+                    price: price.multiply(pool.tokenBPrice)
+                };
+        }, this.pools[0].tokenA.equals(this.input)
+            ? {
+                nextInput: this.pools[0].tokenB,
+                price: this.pools[0].tokenAPrice
+            }
+            : {
+                nextInput: this.pools[0].tokenA,
+                price: this.pools[0].tokenBPrice
+            }).price;
+        return (this._midPrice = new fractions_1.Price(this.input, this.output, price.denominator, price.numerator));
+    }
+}
+exports.Route = Route;

package/build/entities/tick.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tick = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const utils_1 = require("../utils");
+class Tick {
+    constructor({ id, liquidityGross, liquidityNet, feeGrowthOutsideAX64 = 0, feeGrowthOutsideBX64 = 0, tickCumulativeOutside = 0, secondsOutside = 0, secondsPerLiquidityOutsideX64 = 0, }) {
+        (0, tiny_invariant_1.default)(id >= utils_1.TickMath.MIN_TICK && id <= utils_1.TickMath.MAX_TICK, "TICK");
+        this.id = id;
+        this.liquidityGross = jsbi_1.default.BigInt(liquidityGross);
+        this.liquidityNet = jsbi_1.default.BigInt(liquidityNet);
+        this.feeGrowthOutsideAX64 = jsbi_1.default.BigInt(feeGrowthOutsideAX64);
+        this.feeGrowthOutsideBX64 = jsbi_1.default.BigInt(feeGrowthOutsideBX64);
+        this.tickCumulativeOutside = jsbi_1.default.BigInt(tickCumulativeOutside);
+        this.secondsOutside = jsbi_1.default.BigInt(secondsOutside);
+        this.secondsPerLiquidityOutsideX64 = jsbi_1.default.BigInt(secondsPerLiquidityOutsideX64);
+    }
+}
+exports.Tick = Tick;

package/build/entities/tickDataProvider.js

@@ -0,0 +1,30 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoTickDataProvider = void 0;
+/**
+ * This tick data provider does not know how to fetch any tick data. It throws whenever it is required. Useful if you
+ * do not need to load tick data for your use case.
+ */
+class NoTickDataProvider {
+    getTick(_tick) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error(NoTickDataProvider.ERROR_MESSAGE);
+        });
+    }
+    nextInitializedTickWithinOneWord(_tick, _lte, _tickSpacing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error(NoTickDataProvider.ERROR_MESSAGE);
+        });
+    }
+}
+exports.NoTickDataProvider = NoTickDataProvider;
+NoTickDataProvider.ERROR_MESSAGE = "No tick data provider was given";

package/build/entities/tickListDataProvider.js

@@ -0,0 +1,35 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TickListDataProvider = void 0;
+const tickList_1 = require("../utils/tickList");
+const tick_1 = require("./tick");
+/**
+ * A data provider for ticks that is backed by an in-memory array of ticks.
+ */
+class TickListDataProvider {
+    constructor(ticks, tickSpacing) {
+        const ticksMapped = ticks.map((t) => t instanceof tick_1.Tick ? t : new tick_1.Tick(t));
+        tickList_1.TickList.validateList(ticksMapped, tickSpacing);
+        this.ticks = ticksMapped;
+    }
+    getTick(tick) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return tickList_1.TickList.getTick(this.ticks, tick);
+        });
+    }
+    nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return tickList_1.TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
+        });
+    }
+}
+exports.TickListDataProvider = TickListDataProvider;

package/build/entities/token.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const baseCurrency_1 = require("./baseCurrency");
+const eos_common_1 = require("eos-common");
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+class Token extends baseCurrency_1.BaseCurrency {
+    /**
+     * @param contract {@link BaseCurrency#contract}
+     * @param decimals {@link BaseCurrency#decimals}
+     * @param symbol {@link BaseCurrency#symbol}
+     * @param id {@link BaseCurrency#id}
+     */
+    constructor(contract, decimals, symbol, id) {
+        super(contract, decimals, symbol, id);
+    }
+    get name() {
+        console.warn('Token.name is deprecated, use token.id');
+        return this.symbol.toLowerCase() + '-' + this.contract;
+    }
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same contract and symbol.
+     * @param other other token to compare
+     */
+    equals(other) {
+        return (this.contract === other.contract &&
+            this.symbol === other.symbol &&
+            this.decimals === other.decimals);
+    }
+    /**
+     * 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 contract and symbol
+     */
+    sortsBefore(other) {
+        if (this.contract === other.contract) {
+            (0, tiny_invariant_1.default)(this.symbol !== other.symbol, "SYMBOLS");
+            const token0Symbol = (0, eos_common_1.symbol)(this.symbol, this.decimals);
+            const token1Symbol = (0, eos_common_1.symbol)(other.symbol, other.decimals);
+            return token0Symbol.raw().lt(token1Symbol.raw());
+        }
+        else {
+            return (0, eos_common_1.name)(this.contract).raw().lt((0, eos_common_1.name)(other.contract).raw());
+        }
+    }
+}
+exports.Token = Token;