@alcorexchange/alcor-swap-sdk 1.0.0

package/src/entities/tick.ts

@@ -0,0 +1,48 @@
+import JSBI from "jsbi";
+import invariant from "tiny-invariant";
+import { BigintIsh } from "../internalConstants";
+import { TickMath } from "../utils";
+
+export interface TickConstructorArgs {
+  id: number;
+  liquidityGross: BigintIsh;
+  liquidityNet: BigintIsh;
+  feeGrowthOutsideAX64: BigintIsh;
+  feeGrowthOutsideBX64: BigintIsh;
+  tickCumulativeOutside: BigintIsh;
+  secondsPerLiquidityOutsideX64: BigintIsh;
+  secondsOutside: BigintIsh;
+}
+
+export class Tick {
+  public readonly id: number;
+  public readonly liquidityGross: JSBI;
+  public readonly liquidityNet: JSBI;
+  public readonly feeGrowthOutsideAX64: JSBI;
+  public readonly feeGrowthOutsideBX64: JSBI;
+  public readonly tickCumulativeOutside: JSBI;
+  public readonly secondsOutside: JSBI;
+  public readonly secondsPerLiquidityOutsideX64: JSBI;
+
+  constructor({
+    id,
+    liquidityGross,
+    liquidityNet,
+    feeGrowthOutsideAX64 = 0,
+    feeGrowthOutsideBX64 = 0,
+    tickCumulativeOutside = 0,
+    secondsOutside = 0,
+    secondsPerLiquidityOutsideX64 = 0,
+  }: TickConstructorArgs) {
+    invariant(id >= TickMath.MIN_TICK && id <= TickMath.MAX_TICK, "TICK");
+
+    this.id = id;
+    this.liquidityGross = JSBI.BigInt(liquidityGross);
+    this.liquidityNet = JSBI.BigInt(liquidityNet);
+    this.feeGrowthOutsideAX64 = JSBI.BigInt(feeGrowthOutsideAX64);
+    this.feeGrowthOutsideBX64 = JSBI.BigInt(feeGrowthOutsideBX64);
+    this.tickCumulativeOutside = JSBI.BigInt(tickCumulativeOutside)
+    this.secondsOutside = JSBI.BigInt(secondsOutside);
+    this.secondsPerLiquidityOutsideX64 = JSBI.BigInt(secondsPerLiquidityOutsideX64);
+  }
+}

package/src/entities/tickDataProvider.ts

@@ -0,0 +1,43 @@
+import { Tick } from "./tick";
+
+/**
+ * Provides information about ticks
+ */
+export interface TickDataProvider {
+  /**
+   * Return information corresponding to a specific tick
+   * @param tick the tick to load
+   */
+  getTick(tick: number): Promise<Tick>;
+
+  /**
+   * Return the next tick that is initialized within a single word
+   * @param tick The current tick
+   * @param lte Whether the next tick should be lte the current tick
+   * @param tickSpacing The tick spacing of the pool
+   */
+  nextInitializedTickWithinOneWord(
+    tick: number,
+    lte: boolean,
+    tickSpacing: number
+  ): Promise<[number, boolean]>;
+}
+
+/**
+ * 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.
+ */
+export class NoTickDataProvider implements TickDataProvider {
+  private static ERROR_MESSAGE = "No tick data provider was given";
+  async getTick(_tick: number): Promise<Tick> {
+    throw new Error(NoTickDataProvider.ERROR_MESSAGE);
+  }
+
+  async nextInitializedTickWithinOneWord(
+    _tick: number,
+    _lte: boolean,
+    _tickSpacing: number
+  ): Promise<[number, boolean]> {
+    throw new Error(NoTickDataProvider.ERROR_MESSAGE);
+  }
+}

package/src/entities/tickListDataProvider.ts

@@ -0,0 +1,37 @@
+import { TickList } from "../utils/tickList";
+import { Tick, TickConstructorArgs } from "./tick";
+import { TickDataProvider } from "./tickDataProvider";
+
+/**
+ * A data provider for ticks that is backed by an in-memory array of ticks.
+ */
+export class TickListDataProvider implements TickDataProvider {
+  private ticks: readonly Tick[];
+
+  constructor(ticks: (Tick | TickConstructorArgs)[], tickSpacing: number) {
+    const ticksMapped: Tick[] = ticks.map((t) =>
+      t instanceof Tick ? t : new Tick(t)
+    );
+    TickList.validateList(ticksMapped, tickSpacing);
+    this.ticks = ticksMapped;
+  }
+
+  async getTick(
+    tick: number
+  ): Promise<Tick> {
+    return TickList.getTick(this.ticks, tick);
+  }
+
+  async nextInitializedTickWithinOneWord(
+    tick: number,
+    lte: boolean,
+    tickSpacing: number
+  ): Promise<[number, boolean]> {
+    return TickList.nextInitializedTickWithinOneWord(
+      this.ticks,
+      tick,
+      lte,
+      tickSpacing
+    );
+  }
+}

package/src/entities/token.ts

@@ -0,0 +1,56 @@
+import invariant from "tiny-invariant";
+import { BaseCurrency } from "./baseCurrency";
+import { symbol, name } from "eos-common"
+
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export class Token extends BaseCurrency {
+  /**
+   * @param contract {@link BaseCurrency#contract}
+   * @param decimals {@link BaseCurrency#decimals}
+   * @param symbol {@link BaseCurrency#symbol}
+   * @param id {@link BaseCurrency#id}
+   */
+  public constructor(
+    contract: string,
+    decimals: number,
+    symbol: string,
+    id?: string
+  ) {
+    super(contract, decimals, symbol, id);
+  }
+
+  public get name(): string {
+    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
+   */
+  public equals(other: Token): boolean {
+    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
+   */
+  public sortsBefore(other: Token): boolean {
+    if (this.contract === other.contract) {
+      invariant(this.symbol !== other.symbol, "SYMBOLS");
+      const token0Symbol = symbol(this.symbol, this.decimals);
+      const token1Symbol = symbol(other.symbol, other.decimals);
+      return token0Symbol.raw().lt(token1Symbol.raw());
+    } else {
+        return name(this.contract).raw().lt(name(other.contract).raw());
+    }
+  }
+}