@alcorexchange/alcor-swap-sdk 1.0.0

package/src/entities/fractions/fraction.ts

@@ -0,0 +1,190 @@
+import JSBI from "jsbi";
+import invariant from "tiny-invariant";
+import toFormat from "toformat";
+import _Decimal from "decimal.js-light";
+import _Big, { RoundingMode } from "big.js";
+
+import { BigintIsh, Rounding } from "../../internalConstants";
+
+const Decimal = toFormat(_Decimal);
+const Big = toFormat(_Big);
+
+const toSignificantRounding = {
+  [Rounding.ROUND_DOWN]: Decimal.ROUND_DOWN,
+  [Rounding.ROUND_HALF_UP]: Decimal.ROUND_HALF_UP,
+  [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 = {
+  [Rounding.ROUND_DOWN]: 0,
+  [Rounding.ROUND_HALF_UP]: 1,
+  [Rounding.ROUND_UP]: 3,
+};
+
+export class Fraction {
+  public readonly numerator: JSBI;
+  public readonly denominator: JSBI;
+
+  public constructor(
+    numerator: BigintIsh,
+    denominator: BigintIsh = JSBI.BigInt(1)
+  ) {
+    this.numerator = JSBI.BigInt(numerator);
+    this.denominator = JSBI.BigInt(denominator);
+  }
+
+  private static tryParseFraction(fractionish: BigintIsh | Fraction): Fraction {
+    if (
+      fractionish instanceof JSBI ||
+      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
+  public get quotient(): JSBI {
+    return JSBI.divide(this.numerator, this.denominator);
+  }
+
+  // remainder after floor division
+  public get remainder(): Fraction {
+    return new Fraction(
+      JSBI.remainder(this.numerator, this.denominator),
+      this.denominator
+    );
+  }
+
+  public invert(): Fraction {
+    return new Fraction(this.denominator, this.numerator);
+  }
+
+  public add(other: Fraction | BigintIsh): Fraction {
+    const otherParsed = Fraction.tryParseFraction(other);
+    if (JSBI.equal(this.denominator, otherParsed.denominator)) {
+      return new Fraction(
+        JSBI.add(this.numerator, otherParsed.numerator),
+        this.denominator
+      );
+    }
+    return new Fraction(
+      JSBI.add(
+        JSBI.multiply(this.numerator, otherParsed.denominator),
+        JSBI.multiply(otherParsed.numerator, this.denominator)
+      ),
+      JSBI.multiply(this.denominator, otherParsed.denominator)
+    );
+  }
+
+  public subtract(other: Fraction | BigintIsh): Fraction {
+    const otherParsed = Fraction.tryParseFraction(other);
+    if (JSBI.equal(this.denominator, otherParsed.denominator)) {
+      return new Fraction(
+        JSBI.subtract(this.numerator, otherParsed.numerator),
+        this.denominator
+      );
+    }
+    return new Fraction(
+      JSBI.subtract(
+        JSBI.multiply(this.numerator, otherParsed.denominator),
+        JSBI.multiply(otherParsed.numerator, this.denominator)
+      ),
+      JSBI.multiply(this.denominator, otherParsed.denominator)
+    );
+  }
+
+  public lessThan(other: Fraction | BigintIsh): boolean {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return JSBI.lessThan(
+      JSBI.multiply(this.numerator, otherParsed.denominator),
+      JSBI.multiply(otherParsed.numerator, this.denominator)
+    );
+  }
+
+  public equalTo(other: Fraction | BigintIsh): boolean {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return JSBI.equal(
+      JSBI.multiply(this.numerator, otherParsed.denominator),
+      JSBI.multiply(otherParsed.numerator, this.denominator)
+    );
+  }
+
+  public greaterThan(other: Fraction | BigintIsh): boolean {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return JSBI.greaterThan(
+      JSBI.multiply(this.numerator, otherParsed.denominator),
+      JSBI.multiply(otherParsed.numerator, this.denominator)
+    );
+  }
+
+  public multiply(other: Fraction | BigintIsh): Fraction {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return new Fraction(
+      JSBI.multiply(this.numerator, otherParsed.numerator),
+      JSBI.multiply(this.denominator, otherParsed.denominator)
+    );
+  }
+
+  public divide(other: Fraction | BigintIsh): Fraction {
+    const otherParsed = Fraction.tryParseFraction(other);
+    return new Fraction(
+      JSBI.multiply(this.numerator, otherParsed.denominator),
+      JSBI.multiply(this.denominator, otherParsed.numerator)
+    );
+  }
+
+  public toSignificant(
+    significantDigits: number,
+    format: object = { groupSeparator: "" },
+    rounding: Rounding = Rounding.ROUND_HALF_UP
+  ): string {
+    invariant(
+      Number.isInteger(significantDigits),
+      `${significantDigits} is not an integer.`
+    );
+    invariant(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);
+  }
+
+  public toFixed(
+    decimalPlaces: number,
+    format: object = { groupSeparator: "" },
+    rounding: Rounding = Rounding.ROUND_HALF_UP
+  ): string {
+    invariant(
+      Number.isInteger(decimalPlaces),
+      `${decimalPlaces} is not an integer.`
+    );
+    invariant(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
+   */
+  public get asFraction(): Fraction {
+    return new Fraction(this.numerator, this.denominator);
+  }
+}

package/src/entities/fractions/index.ts

@@ -0,0 +1,4 @@
+export { CurrencyAmount } from "./currencyAmount";
+export { Fraction } from "./fraction";
+export { Percent } from "./percent";
+export { Price } from "./price";

package/src/entities/fractions/percent.ts

@@ -0,0 +1,54 @@
+import JSBI from "jsbi";
+import { BigintIsh, Rounding } from "../../internalConstants";
+import { Fraction } from "./fraction";
+
+const ONE_HUNDRED = new Fraction(JSBI.BigInt(100));
+
+/**
+ * Converts a fraction to a percent
+ * @param fraction the fraction to convert
+ */
+function toPercent(fraction: Fraction): Percent {
+  return new Percent(fraction.numerator, fraction.denominator);
+}
+
+export class Percent extends Fraction {
+  /**
+   * This boolean prevents a fraction from being interpreted as a Percent
+   */
+  public readonly isPercent: true = true;
+
+  add(other: Fraction | BigintIsh): Percent {
+    return toPercent(super.add(other));
+  }
+
+  subtract(other: Fraction | BigintIsh): Percent {
+    return toPercent(super.subtract(other));
+  }
+
+  multiply(other: Fraction | BigintIsh): Percent {
+    return toPercent(super.multiply(other));
+  }
+
+  divide(other: Fraction | BigintIsh): Percent {
+    return toPercent(super.divide(other));
+  }
+
+  public toSignificant(
+    significantDigits: number = 5,
+    format?: object,
+    rounding?: Rounding
+  ): string {
+    return super
+      .multiply(ONE_HUNDRED)
+      .toSignificant(significantDigits, format, rounding);
+  }
+
+  public toFixed(
+    decimalPlaces: number = 2,
+    format?: object,
+    rounding?: Rounding
+  ): string {
+    return super.multiply(ONE_HUNDRED).toFixed(decimalPlaces, format, rounding);
+  }
+}

package/src/entities/fractions/price.ts

@@ -0,0 +1,127 @@
+import JSBI from "jsbi";
+import invariant from "tiny-invariant";
+
+import { BigintIsh, Rounding } from "../../internalConstants";
+import { Currency } from "../currency";
+import { Fraction } from "./fraction";
+import { CurrencyAmount } from "./currencyAmount";
+
+export class Price<
+  TBase extends Currency,
+  TQuote extends Currency
+> extends Fraction {
+  public readonly baseCurrency: TBase; // input i.e. denominator
+  public readonly quoteCurrency: TQuote; // output i.e. numerator
+  public readonly scalar: Fraction; // used to adjust the raw fraction w/r/t the decimals of the {base,quote}Token
+
+  /**
+   * Construct a price, either with the base and quote currency amount, or the
+   * @param args
+   */
+  public constructor(
+    ...args:
+      | [TBase, TQuote, BigintIsh, BigintIsh]
+      | [
+          {
+            baseAmount: CurrencyAmount<TBase>;
+            quoteAmount: CurrencyAmount<TQuote>;
+          }
+        ]
+  ) {
+    let baseCurrency: TBase,
+      quoteCurrency: TQuote,
+      denominator: BigintIsh,
+      numerator: BigintIsh;
+
+    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(
+      JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(baseCurrency.decimals)),
+      JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(quoteCurrency.decimals))
+    );
+  }
+
+  /**
+   * Flip the price, switching the base and quote currency
+   */
+  public invert(): Price<TQuote, TBase> {
+    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
+   */
+  public multiply<TOtherQuote extends Currency>(
+    other: Price<TQuote, TOtherQuote>
+  ): Price<TBase, TOtherQuote> {
+    invariant(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
+   */
+  public quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote> {
+    invariant(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+    const result = super.multiply(currencyAmount);
+    return CurrencyAmount.fromFractionalAmount(
+      this.quoteCurrency,
+      result.numerator,
+      result.denominator
+    );
+  }
+
+  /**
+   * Get the value scaled by decimals for formatting
+   * @private
+   */
+  private get adjustedForDecimals(): Fraction {
+    return super.multiply(this.scalar);
+  }
+
+  public toSignificant(
+    significantDigits: number = 6,
+    format?: object,
+    rounding?: Rounding
+  ): string {
+    return this.adjustedForDecimals.toSignificant(
+      significantDigits,
+      format,
+      rounding
+    );
+  }
+
+  public toFixed(
+    decimalPlaces: number = 4,
+    format?: object,
+    rounding?: Rounding
+  ): string {
+    return this.adjustedForDecimals.toFixed(decimalPlaces, format, rounding);
+  }
+}

package/src/entities/index.ts

@@ -0,0 +1,11 @@
+export * from "./fractions";
+
+export * from "./tick";
+export * from "./tickDataProvider";
+export * from "./tickListDataProvider";
+export * from "./currency";
+export * from "./token";
+export * from "./pool";
+export * from "./position";
+export * from "./route";
+export * from "./trade";