@marko00/routing-finder-mare 1.0.0

package/dist/utils/math/log-exp.js

@@ -0,0 +1,385 @@
+"use strict";
+// Ported from Solidity:
+// https://github.com/balancer-labs/balancer-core-v2/blob/70843e6a61ad11208c1cfabf5cfe15be216ca8d3/pkg/solidity-utils/contracts/math/LogExpMath.sol
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ln = exports.log = exports.exp = exports.pow = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+// All fixed point multiplications and divisions are inlined
+// This means we need to divide by ONE when multiplying two numbers, and multiply by ONE when dividing them
+// All arguments and return values are 18 decimal fixed point numbers
+const ONE_18 = new bignumber_js_1.default("1000000000000000000"); // 1e18
+// Internally, intermediate values are computed with higher precision as 20 decimal fixed point numbers, and in the case of ln36, 36 decimals
+const ONE_20 = new bignumber_js_1.default("100000000000000000000"); // 1e20
+const ONE_36 = new bignumber_js_1.default("1000000000000000000000000000000000000"); // 1e36
+// The domain of natural exponentiation is bound by the word size and number of decimals used
+// Because internally the result will be stored using 20 decimals, the largest possible result is
+// (2^255 - 1) / 10^20, which makes the largest exponent ln((2^255 - 1) / 10^20) = 130.700829182905140221
+// The smallest possible result is 10^(-18), which makes largest negative argument
+// ln(10^(-18)) = -41.446531673892822312.
+// We use 130.0 and -41.0 to have some safety margin
+const MAX_NATURAL_EXPONENT = new bignumber_js_1.default("130000000000000000000"); // 130e18
+const MIN_NATURAL_EXPONENT = new bignumber_js_1.default("-41000000000000000000"); // (-41)e18
+// Bounds for ln_36's argument
+// Both ln(0.9) and ln(1.1) can be represented with 36 decimal places in a fixed point 256 bit integer
+const LN_36_LOWER_BOUND = ONE_18.minus(new bignumber_js_1.default("100000000000000000")); // 1e18 - 1e17
+const LN_36_UPPER_BOUND = ONE_18.plus(new bignumber_js_1.default("100000000000000000")); // 1e18 + 1e17
+const MILD_EXPONENT_BOUND = new bignumber_js_1.default(2).pow(254).idiv(ONE_20);
+// 18 decimal constants
+const x0 = new bignumber_js_1.default("128000000000000000000"); // 2ˆ7
+const a0 = new bignumber_js_1.default("38877084059945950922200000000000000000000000000000000000"); // eˆ(x0) (no decimals)
+const x1 = new bignumber_js_1.default("64000000000000000000"); // 2ˆ6
+const a1 = new bignumber_js_1.default("6235149080811616882910000000"); // eˆ(x1) (no decimals)
+// 20 decimal constants
+const x2 = new bignumber_js_1.default("3200000000000000000000"); // 2ˆ5
+const a2 = new bignumber_js_1.default("7896296018268069516100000000000000"); // eˆ(x2)
+const x3 = new bignumber_js_1.default("1600000000000000000000"); // 2ˆ4
+const a3 = new bignumber_js_1.default("888611052050787263676000000"); // eˆ(x3)
+const x4 = new bignumber_js_1.default("800000000000000000000"); // 2ˆ3
+const a4 = new bignumber_js_1.default("298095798704172827474000"); // eˆ(x4)
+const x5 = new bignumber_js_1.default("400000000000000000000"); // 2ˆ2
+const a5 = new bignumber_js_1.default("5459815003314423907810"); // eˆ(x5)
+const x6 = new bignumber_js_1.default("200000000000000000000"); // 2ˆ1
+const a6 = new bignumber_js_1.default("738905609893065022723"); // eˆ(x6)
+const x7 = new bignumber_js_1.default("100000000000000000000"); // 2ˆ0
+const a7 = new bignumber_js_1.default("271828182845904523536"); // eˆ(x7)
+const x8 = new bignumber_js_1.default("50000000000000000000"); // 2ˆ(-1)
+const a8 = new bignumber_js_1.default("164872127070012814685"); // eˆ(x8)
+const x9 = new bignumber_js_1.default("25000000000000000000"); // 2ˆ(-2)
+const a9 = new bignumber_js_1.default("128402541668774148407"); // eˆ(x9)
+const x10 = new bignumber_js_1.default("12500000000000000000"); // 2ˆ(-3)
+const a10 = new bignumber_js_1.default("113314845306682631683"); // eˆ(x10)
+const x11 = new bignumber_js_1.default("6250000000000000000"); // 2ˆ(-4)
+const a11 = new bignumber_js_1.default("106449445891785942956"); // eˆ(x11)
+const pow = (x, y) => {
+    if (y.isZero()) {
+        // We solve the 0^0 indetermination by making it equal one.
+        return ONE_18;
+    }
+    if (x.isZero()) {
+        return new bignumber_js_1.default(0);
+    }
+    // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
+    // arrive at that result. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
+    // x^y = exp(y * ln(x)).
+    // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
+    if (x.gte(new bignumber_js_1.default(2).pow(255))) {
+        throw new Error("X_OUT_OF_BOUNDS");
+    }
+    // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In
+    // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
+    // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
+    if (y.gte(MILD_EXPONENT_BOUND)) {
+        throw new Error("Y_OUT_OF_BOUNDS");
+    }
+    let logx_times_y;
+    if (LN_36_LOWER_BOUND.lt(x) && x.lt(LN_36_UPPER_BOUND)) {
+        let ln_36_x = _ln_36(x);
+        // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
+        // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
+        // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
+        // (downscaled) last 18 decimals.
+        logx_times_y = ln_36_x
+            .idiv(ONE_18)
+            .times(y)
+            .plus(ln_36_x.mod(ONE_18).times(y).idiv(ONE_18));
+    }
+    else {
+        logx_times_y = _ln(x).times(y);
+    }
+    logx_times_y = logx_times_y.idiv(ONE_18);
+    // Finally, we compute exp(y * ln(x)) to arrive at x^y
+    if (logx_times_y.lt(MIN_NATURAL_EXPONENT) ||
+        logx_times_y.gt(MAX_NATURAL_EXPONENT)) {
+        throw new Error("PRODUCT_OUT_OF_BOUNDS");
+    }
+    return (0, exports.exp)(logx_times_y);
+};
+exports.pow = pow;
+const exp = (x) => {
+    if (x.lt(MIN_NATURAL_EXPONENT) || x.gt(MAX_NATURAL_EXPONENT)) {
+        throw new Error("INVALID_EXPONENT");
+    }
+    if (x.lt(0)) {
+        // We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since it
+        // fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).
+        // Fixed point division requires multiplying by ONE_18.
+        return ONE_18.times(ONE_18).idiv((0, exports.exp)(x.negated()));
+    }
+    // First, we use the fact that e^(x+y) = e^x * e^y to decompose x into a sum of powers of two, which we call x_n,
+    // where x_n == 2^(7 - n), and e^x_n = a_n has been precomputed. We choose the first x_n, x0, to equal 2^7
+    // because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the
+    // decomposition.
+    // At the end of this process we will have the product of all e^x_n = a_n that apply, and the remainder of this
+    // decomposition, which will be lower than the smallest x_n.
+    // exp(x) = k_0 * a_0 * k_1 * a_1 * ... + k_n * a_n * exp(remainder), where each k_n equals either 0 or 1.
+    // We mutate x by subtracting x_n, making it the remainder of the decomposition.
+    // The first two a_n (e^(2^7) and e^(2^6)) are too large if stored as 18 decimal numbers, and could cause
+    // intermediate overflows. Instead we store them as plain integers, with 0 decimals.
+    // Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in the
+    // decomposition.
+    // For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so deduct
+    // it and compute the accumulated product.
+    let firstAN;
+    if (x.gte(x0)) {
+        x = x.minus(x0);
+        firstAN = a0;
+    }
+    else if (x.gte(x1)) {
+        x = x.minus(x1);
+        firstAN = a1;
+    }
+    else {
+        firstAN = new bignumber_js_1.default(1); // One with no decimal places
+    }
+    // We now transform x into a 20 decimal fixed point number, to have enhanced precision when computing the
+    // smaller terms.
+    x = x.times(100);
+    // `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed point
+    // one. Recall that fixed point multiplication requires dividing by ONE_20.
+    let product = ONE_20;
+    if (x.gte(x2)) {
+        x = x.minus(x2);
+        product = product.times(a2).idiv(ONE_20);
+    }
+    if (x.gte(x3)) {
+        x = x.minus(x3);
+        product = product.times(a3).idiv(ONE_20);
+    }
+    if (x.gte(x4)) {
+        x = x.minus(x4);
+        product = product.times(a4).idiv(ONE_20);
+    }
+    if (x.gte(x5)) {
+        x = x.minus(x5);
+        product = product.times(a5).idiv(ONE_20);
+    }
+    if (x.gte(x6)) {
+        x = x.minus(x6);
+        product = product.times(a6).idiv(ONE_20);
+    }
+    if (x.gte(x7)) {
+        x = x.minus(x7);
+        product = product.times(a7).idiv(ONE_20);
+    }
+    if (x.gte(x8)) {
+        x = x.minus(x8);
+        product = product.times(a8).idiv(ONE_20);
+    }
+    if (x.gte(x9)) {
+        x = x.minus(x9);
+        product = product.times(a9).idiv(ONE_20);
+    }
+    // x10 and x11 are unnecessary here since we have high enough precision already.
+    // Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor series
+    // expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).
+    let seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places.
+    let term; // Each term in the sum, where the nth term is (x^n / n!).
+    // The first term is simply x.
+    term = x;
+    seriesSum = seriesSum.plus(term);
+    // Each term (x^n / n!) equals the previous one times x, divided by n. Since x is a fixed point number,
+    // multiplying by it requires dividing by ONE_20, but dividing by the non-fixed point n values does not.
+    term = term.times(x).idiv(ONE_20).idiv(2);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(3);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(4);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(5);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(6);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(7);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(8);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(9);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(10);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(11);
+    seriesSum = seriesSum.plus(term);
+    term = term.times(x).idiv(ONE_20).idiv(12);
+    seriesSum = seriesSum.plus(term);
+    // 12 Taylor terms are sufficient for 18 decimal precision.
+    // We now have the first a_n (with no decimals), and the product of all other a_n present, and the Taylor
+    // approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to multiply
+    // all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer multiplication),
+    // and then drop two digits to return an 18 decimal value.
+    return product.times(seriesSum).idiv(ONE_20).times(firstAN).idiv(100);
+};
+exports.exp = exp;
+const log = (arg, base) => {
+    // This performs a simple base change: log(arg, base) = ln(arg) / ln(base).
+    // Both logBase and logArg are computed as 36 decimal fixed point numbers, either by using ln_36, or by
+    // upscaling.
+    let logBase;
+    if (LN_36_LOWER_BOUND.lt(base) && base.lt(LN_36_UPPER_BOUND)) {
+        logBase = _ln_36(base);
+    }
+    else {
+        logBase = _ln(base).times(ONE_18);
+    }
+    let logArg;
+    if (LN_36_LOWER_BOUND.lt(arg) && arg.lt(LN_36_UPPER_BOUND)) {
+        logArg = _ln_36(arg);
+    }
+    else {
+        logArg = _ln(arg).times(ONE_18);
+    }
+    // When dividing, we multiply by ONE_18 to arrive at a result with 18 decimal places
+    return logArg.times(ONE_18).idiv(logBase);
+};
+exports.log = log;
+const ln = (a) => {
+    // The real natural logarithm is not defined for negative numbers or zero.
+    if (a.lte(0)) {
+        throw new Error("OUT_OF_BOUNDS");
+    }
+    if (LN_36_LOWER_BOUND.lt(a) && a.lt(LN_36_UPPER_BOUND)) {
+        return _ln_36(a).idiv(ONE_18);
+    }
+    else {
+        return _ln(a);
+    }
+};
+exports.ln = ln;
+const _ln = (a) => {
+    if (a.lt(ONE_18)) {
+        // Since ln(a^k) = k * ln(a), we can compute ln(a) as ln(a) = ln((1/a)^(-1)) = - ln((1/a))
+        // If a is less than one, 1/a will be greater than one, and this if statement will not be entered in the recursive call
+        // Fixed point division requires multiplying by ONE_18
+        return _ln(ONE_18.times(ONE_18).idiv(a)).negated();
+    }
+    // First, we use the fact that ln^(a * b) = ln(a) + ln(b) to decompose ln(a) into a sum of powers of two, which
+    // we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n (that is,
+    // ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers cannot
+    // be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.
+    // At the end of this process we will have the sum of all x_n = ln(a_n) that apply, and the remainder of this
+    // decomposition, which will be lower than the smallest a_n.
+    // ln(a) = k_0 * x_0 + k_1 * x_1 + ... + k_n * x_n + ln(remainder), where each k_n equals either 0 or 1
+    // We mutate a by subtracting a_n, making it the remainder of the decomposition
+    // For reasons related to how `exp` works, the first two a_n (e^(2^7) and e^(2^6)) are not stored as fixed point
+    // numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply them by
+    // ONE_18 to convert them to fixed point.
+    // For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so divide
+    // by it and compute the accumulated sum.
+    let sum = new bignumber_js_1.default(0);
+    if (a.gte(a0.times(ONE_18))) {
+        a = a.idiv(a0); // Integer, not fixed point division
+        sum = sum.plus(x0);
+    }
+    if (a.gte(a1.times(ONE_18))) {
+        a = a.idiv(a1); // Integer, not fixed point division
+        sum = sum.plus(x1);
+    }
+    // All other a_n and x_n are stored as 20 digit fixed point numbers, so we convert the sum and a to this format.
+    sum = sum.times(100);
+    a = a.times(100);
+    // Because further a_n are  20 digit fixed point numbers, we multiply by ONE_20 when dividing by them.
+    if (a.gte(a2)) {
+        a = a.times(ONE_20).idiv(a2);
+        sum = sum.plus(x2);
+    }
+    if (a.gte(a3)) {
+        a = a.times(ONE_20).idiv(a3);
+        sum = sum.plus(x3);
+    }
+    if (a.gte(a4)) {
+        a = a.times(ONE_20).idiv(a4);
+        sum = sum.plus(x4);
+    }
+    if (a.gte(a5)) {
+        a = a.times(ONE_20).idiv(a5);
+        sum = sum.plus(x5);
+    }
+    if (a.gte(a6)) {
+        a = a.times(ONE_20).idiv(a6);
+        sum = sum.plus(x6);
+    }
+    if (a.gte(a7)) {
+        a = a.times(ONE_20).idiv(a7);
+        sum = sum.plus(x7);
+    }
+    if (a.gte(a8)) {
+        a = a.times(ONE_20).idiv(a8);
+        sum = sum.plus(x8);
+    }
+    if (a.gte(a9)) {
+        a = a.times(ONE_20).idiv(a9);
+        sum = sum.plus(x9);
+    }
+    if (a.gte(a10)) {
+        a = a.times(ONE_20).idiv(a10);
+        sum = sum.plus(x10);
+    }
+    if (a.gte(a11)) {
+        a = a.times(ONE_20).idiv(a11);
+        sum = sum.plus(x11);
+    }
+    // a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor series
+    // that converges rapidly for values of `a` close to one - the same one used in ln_36.
+    // Let z = (a - 1) / (a + 1).
+    // ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))
+    // Recall that 20 digit fixed point division requires multiplying by ONE_20, and multiplication requires
+    // division by ONE_20.
+    const z = a.minus(ONE_20).times(ONE_20).idiv(a.plus(ONE_20));
+    const z_squared = z.times(z).idiv(ONE_20);
+    // num is the numerator of the series: the z^(2 * n + 1) term
+    let num = z;
+    // seriesSum holds the accumulated sum of each term in the series, starting with the initial z
+    let seriesSum = num;
+    // In each step, the numerator is multiplied by z^2
+    num = num.times(z_squared).idiv(ONE_20);
+    seriesSum = seriesSum.plus(num.idiv(3));
+    num = num.times(z_squared).idiv(ONE_20);
+    seriesSum = seriesSum.plus(num.idiv(5));
+    num = num.times(z_squared).idiv(ONE_20);
+    seriesSum = seriesSum.plus(num.idiv(7));
+    num = num.times(z_squared).idiv(ONE_20);
+    seriesSum = seriesSum.plus(num.idiv(9));
+    num = num.times(z_squared).idiv(ONE_20);
+    seriesSum = seriesSum.plus(num.idiv(11));
+    // 6 Taylor terms are sufficient for 36 decimal precision.
+    // Finally, we multiply by 2 (non fixed point) to compute ln(remainder)
+    seriesSum = seriesSum.times(2);
+    // We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder (both
+    // with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18 decimal
+    // value.
+    return sum.plus(seriesSum).idiv(100);
+};
+const _ln_36 = (x) => {
+    // Since ln(1) = 0, a value of x close to one will yield a very small result, which makes using 36 digits worthwhile
+    // First, we transform x to a 36 digit fixed point value
+    x = x.times(ONE_18);
+    // We will use the following Taylor expansion, which converges very rapidly. Let z = (x - 1) / (x + 1)
+    // ln(x) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))
+    // Recall that 36 digit fixed point division requires multiplying by ONE_36, and multiplication requires division by ONE_36
+    const z = x.minus(ONE_36).times(ONE_36).idiv(x.plus(ONE_36));
+    const z_squared = z.times(z).idiv(ONE_36);
+    // num is the numerator of the series: the z^(2 * n + 1) term
+    let num = z;
+    // seriesSum holds the accumulated sum of each term in the series, starting with the initial z
+    let seriesSum = num;
+    // In each step, the numerator is multiplied by z^2
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(3));
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(5));
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(7));
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(9));
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(11));
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(13));
+    num = num.times(z_squared).idiv(ONE_36);
+    seriesSum = seriesSum.plus(num.idiv(15));
+    // 8 Taylor terms are sufficient for 36 decimal precision
+    // All that remains is multiplying by 2 (non fixed point)
+    return seriesSum.times(2);
+};

package/dist/utils/math/math.d.ts

@@ -0,0 +1,12 @@
+import BigNumber from "bignumber.js";
+export declare const ZERO: BigNumber;
+export declare const ONE: BigNumber;
+export declare const TWO: BigNumber;
+export declare const add: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const sub: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const max: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const min: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const mul: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const div: (a: BigNumber, b: BigNumber, roundUp: boolean) => BigNumber;
+export declare const divDown: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const divUp: (a: BigNumber, b: BigNumber) => BigNumber;

package/dist/utils/math/math.js

@@ -0,0 +1,50 @@
+"use strict";
+// Ported from Solidity:
+// https://github.com/balancer-labs/balancer-v2-monorepo/blob/ce70f7663e0ac94b25ed60cb86faaa8199fd9e13/pkg/solidity-utils/contracts/math/Math.sol
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.divUp = exports.divDown = exports.div = exports.mul = exports.min = exports.max = exports.sub = exports.add = exports.TWO = exports.ONE = exports.ZERO = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+exports.ZERO = new bignumber_js_1.default(0);
+exports.ONE = new bignumber_js_1.default(1);
+exports.TWO = new bignumber_js_1.default(2);
+const add = (a, b) => {
+    return a.plus(b);
+};
+exports.add = add;
+const sub = (a, b) => {
+    if (b.gt(a))
+        throw new Error("SUB_OVERFLOW");
+    return a.minus(b);
+};
+exports.sub = sub;
+const max = (a, b) => {
+    return a.gte(b) ? a : b;
+};
+exports.max = max;
+const min = (a, b) => {
+    return a.lt(b) ? a : b;
+};
+exports.min = min;
+const mul = (a, b) => {
+    return a.times(b);
+};
+exports.mul = mul;
+const div = (a, b, roundUp) => {
+    return roundUp ? (0, exports.divUp)(a, b) : (0, exports.divDown)(a, b);
+};
+exports.div = div;
+const divDown = (a, b) => {
+    if (b.isZero())
+        throw new Error("ZERO_DIVISION");
+    return a.idiv(b);
+};
+exports.divDown = divDown;
+const divUp = (a, b) => {
+    if (b.isZero())
+        throw new Error("ZERO_DIVISION");
+    return a.isZero() ? exports.ZERO : exports.ONE.plus(a.minus(exports.ONE).idiv(b));
+};
+exports.divUp = divUp;

package/dist/utils/types/types.d.ts

@@ -0,0 +1,51 @@
+import Web3 from "web3";
+export interface ResponseType {
+    isSuccess: boolean;
+    txHash: string;
+    errorMessage: string;
+}
+export interface DEXGraphFunctionality {
+    setEndpoint: (chainId: number, graphApiKey: string) => void;
+    getTopPools: (numPools: number) => Promise<PoolInfo[]>;
+    getPoolsWithTokenPair: (tokenA: string, tokenB: string, first: number) => Promise<PoolInfo[]>;
+    getPoolsWithToken: (token: string, first: number) => Promise<PoolInfo[]>;
+    getAdditionalPoolDataFromSolidity: (poolInfos: PoolInfo[], rpcProvider: Web3) => Promise<Pool[]>;
+}
+export type Token = {
+    _address: string;
+    decimals: number;
+    name?: string;
+};
+export type PoolInfo = {
+    poolId: string;
+    dexId: string;
+    tokens: Token[];
+};
+export declare abstract class Pool {
+    poolId: string;
+    dexId: string;
+    tokens: Token[];
+    protected constructor(poolId: string, dexId: string, tokens: Token[]);
+    abstract calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint;
+    abstract reset(): void;
+    abstract update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void;
+    containsToken(token: string): boolean;
+    getToken0(): Token;
+    getToken1(): Token;
+}
+export type SwapStep = {
+    poolId: string;
+    dexId: string;
+    tokenIn: string;
+    tokenOut: string;
+};
+export type Route = {
+    swaps: SwapStep[];
+    amountIn: bigint;
+    percentage: number;
+    quote: bigint;
+};
+export type Quote = {
+    routes: Route[];
+    quote: bigint;
+};

package/dist/utils/types/types.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pool = void 0;
+// we get from Solidity (extra info)
+class Pool {
+    constructor(poolId, dexId, tokens) {
+        this.poolId = poolId;
+        this.dexId = dexId;
+        this.tokens = tokens.map((token) => ({
+            _address: token._address.toLowerCase(),
+            decimals: token.decimals,
+            name: token.name,
+        }));
+    }
+    containsToken(token) {
+        return this.tokens.some((t) => t._address.toLowerCase() === token.toLowerCase());
+    }
+    getToken0() {
+        return this.tokens[0];
+    }
+    getToken1() {
+        return this.tokens[1];
+    }
+}
+exports.Pool = Pool;

package/dist/utils/utils.d.ts

@@ -0,0 +1,20 @@
+import { Quote, SwapStep } from "./types/types";
+export declare function prepareSwapParams(quote: Quote, slippagePercentage: number, deadlineInMinutes: number, tokenIn: string, tokenOut: string, amountIn: bigint, recipient: string): {
+    adjustedQuote: {
+        swaps: {
+            data: string;
+            dexId: number;
+        }[];
+        amountIn: bigint;
+    }[];
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    minAmountOut: bigint;
+    recipient: string;
+    deadline: number;
+};
+export declare function generateCalldata(quote: Quote, slippagePercentage: number, deadlineInMinutes: number, tokenIn: string, tokenOut: string, amountIn: bigint, recipient: string): string;
+export declare function transferQuoteWithBalancerPoolIdToAddress(quote: Quote): Quote;
+export declare function hashStringToInt(dexName: string): number;
+export declare function encodeSwapData(swap: SwapStep): string;

package/dist/utils/utils.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSwapParams = prepareSwapParams;
+exports.generateCalldata = generateCalldata;
+exports.transferQuoteWithBalancerPoolIdToAddress = transferQuoteWithBalancerPoolIdToAddress;
+exports.hashStringToInt = hashStringToInt;
+exports.encodeSwapData = encodeSwapData;
+const RateXAbi_1 = require("../contracts/abi/RateXAbi");
+const ethers_1 = require("ethers");
+function prepareSwapParams(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient) {
+    const quoteWithAddressPoolId = transferQuoteWithBalancerPoolIdToAddress(quote);
+    const HUNDRED = BigInt(100);
+    const slippageBigInt = BigInt(slippagePercentage) * HUNDRED;
+    const minAmountOut = (quoteWithAddressPoolId.quote * (HUNDRED - slippageBigInt)) / HUNDRED;
+    const adjustedQuote = quoteWithAddressPoolId.routes.map((route) => ({
+        swaps: route.swaps.map((swap) => ({
+            data: encodeSwapData(swap), // Encode swap data
+            dexId: hashStringToInt(swap.dexId), // Convert dexId to uint32
+        })),
+        amountIn: route.amountIn,
+    }));
+    const deadline = Math.floor(Date.now() / 1000) + 60 * deadlineInMinutes;
+    // Return the parameters as a plain object
+    return {
+        adjustedQuote,
+        tokenIn,
+        tokenOut,
+        amountIn,
+        minAmountOut,
+        recipient,
+        deadline,
+    };
+}
+function generateCalldata(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient) {
+    const params = prepareSwapParams(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient);
+    const abiCoder = new ethers_1.ethers.AbiCoder();
+    const calldata = new ethers_1.ethers.Interface(RateXAbi_1.RateXAbi).encodeFunctionData("swap", [
+        params.adjustedQuote,
+        params.tokenIn,
+        params.tokenOut,
+        params.amountIn,
+        params.minAmountOut,
+        params.recipient,
+        params.deadline,
+    ]);
+    // Return swap calldata
+    return calldata;
+}
+function transferQuoteWithBalancerPoolIdToAddress(quote) {
+    quote.routes.forEach((route) => route.swaps.forEach((swap) => {
+        if (swap.poolId.length === 66) {
+            swap.poolId = swap.poolId.slice(0, 42); // Convert to address format
+        }
+    }));
+    return quote;
+}
+function hashStringToInt(dexName) {
+    const hash = (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(dexName));
+    return parseInt(hash.slice(2, 10), 16);
+}
+function encodeSwapData(swap) {
+    const abiCoder = new ethers_1.ethers.AbiCoder();
+    if (swap.dexId === "BALANCER_V2" ||
+        swap.dexId === "UNI_V3") {
+        // For DEXes like Balancer, Curve, UniswapV3: encode poolId, tokenIn, and tokenOut
+        return abiCoder.encode(["address", "address", "address"], [swap.poolId, swap.tokenIn, swap.tokenOut]);
+    }
+    else {
+        // For other DEXes: encode only tokenIn and tokenOut
+        return abiCoder.encode(["address", "address"], [swap.tokenIn, swap.tokenOut]);
+    }
+}

package/index.ts

@@ -0,0 +1,50 @@
+import Web3 from "web3"
+import { findRoute } from "./routing/main"
+import { fetchPoolsData } from "./swap/graph_communication"
+import { Pool, Quote} from "./utils/types/types";
+import { generateCalldata, prepareSwapParams } from "./utils/utils";
+
+export interface RateXConfig {
+    rpcUrl: string;
+    chainId: number;
+    dexes?: Array<Dexes>;
+    graphApiKey: string;
+  }
+  
+export enum Dexes {
+    UNISWAP_V2 = "UniswapV2",
+    UNISWAP_V3 = "UniswapV3",
+    SUSHISWAP_V2 = "Sushiswap",
+    BALANCER = "Balancer",
+    CAMELOT = "Camelot",
+}
+
+export class RateX {
+    rpcProvider: Web3
+    chainId: number
+    graphApiKey: string
+    dexes: Array<Dexes>
+
+    constructor(config: RateXConfig) {
+        this.rpcProvider = new Web3(new Web3.providers.HttpProvider(config.rpcUrl))
+        this.chainId = config.chainId
+        this.graphApiKey = config.graphApiKey
+        this.dexes = config.dexes || [Dexes.SUSHISWAP_V2, Dexes.UNISWAP_V2, Dexes.UNISWAP_V3, Dexes.BALANCER, Dexes.CAMELOT]
+    };
+
+    async getQuote(tokenIn: string, tokenOut: string, amountIn: bigint): Promise<Quote> {
+        const pools: Pool[] = await fetchPoolsData(tokenIn, tokenOut, 5, 5, this.chainId, this.rpcProvider, this.graphApiKey, this.dexes)
+        const route = await findRoute(tokenIn, tokenOut, amountIn, pools, this.chainId)
+        return route
+    }
+
+    async getSwapCalldata(tokenIn: string, tokenOut: string, amountIn: bigint, slippagePercentage: number, recipient: string, deadlineInMinutes: number): Promise<string> {
+        let quote = await this.getQuote(tokenIn, tokenOut, amountIn);
+        return generateCalldata(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient);
+    }
+    
+    async getSwapParameters(tokenIn: string, tokenOut: string, amountIn: bigint, slippagePercentage: number, recipient: string, deadlineInMinutes: number): Promise<ReturnType<typeof prepareSwapParams>> {
+        let quote = await this.getQuote(tokenIn, tokenOut, amountIn);
+        return prepareSwapParams(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient);
+    }    
+}