@gera2ld/lib-trading 0.0.1

package/dist/common.d.ts

@@ -0,0 +1,19 @@
+import type { IBalance, IBaseOrder, ICalcOptions, IFeeMode } from './types.ts';
+export declare function getOrderCost(price: number, quantity: number, options?: ICalcOptions): number;
+export declare function calcOrderDelta(order: IBaseOrder, options?: ICalcOptions): {
+    deltaA: number;
+    deltaB: number;
+};
+export declare function calcBalance(balance: IBalance, options?: ICalcOptions): {
+    balanceA: number;
+    balanceB: number;
+    totalAsA: number;
+    totalAsB: number;
+};
+export declare function normalizeFeeOptions(options?: {
+    feeMode?: IFeeMode;
+    feeRate?: number;
+}): {
+    feeMode: IFeeMode;
+    feeRate: number;
+};

package/dist/grid.d.ts

@@ -0,0 +1,40 @@
+import type { IBaseOrder, ICalcOptions } from './types.ts';
+export interface IGrid {
+    index: number;
+    price: number;
+    sellPrice: number;
+}
+export declare function createGrids(config: {
+    startPrice: number;
+    stopPrice: number;
+    minDifference: number;
+    minRatio: number;
+    maxCount: number;
+    precision: number;
+}): IGrid[];
+export declare function getGridRange(grids: IGrid[], options: {
+    enabledStartPrice?: number;
+    enabledStopPrice?: number;
+    placesPerSide?: number;
+    firstSellIndex?: number;
+}): {
+    startIndex: number;
+    stopIndex: number;
+    actualStartIndex: number;
+    actualStopIndex: number;
+};
+export declare function getFirstSellIndex(grids: IGrid[], price: number): number;
+export declare function getProfitRate(price: number, sellPrice: number, feeRate: number): number;
+export declare function getGridProfit(buy: IBaseOrder | undefined, sell: IBaseOrder | undefined, options?: ICalcOptions): {
+    profitA: number;
+    profitB: number;
+};
+export declare function getBuyQuantity(quantity: number, options: ICalcOptions & {
+    precisionA?: number;
+}): number;
+export declare function getSellQuantity(quantity: number, options: ICalcOptions & {
+    precisionA?: number;
+}): number;
+export declare function matchOrders<T extends {
+    price: number;
+}>(grids: IGrid[], firstSellIndex: number, buyOrders: T[], sellOrders: T[]): T[];

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './grid';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,180 @@
+import a from "bignumber.js";
+function S(e, t, r) {
+  const o = r?.unitSize ?? 1;
+  let l = new a(o * t).abs();
+  return l = l[r?.marketType === "future-c" ? "div" : "times"](e), l.toNumber();
+}
+function w(e, t) {
+  let r = Math.sign(e.quantity);
+  t?.marketType === "future-c" && t?.positionSide === "short" && (r = -r);
+  const o = new a(e.quantity).abs().times(r), l = new a(
+    -r * S(e.price, e.quantity, t)
+  );
+  let n, c;
+  t?.marketType === "future-c" ? (n = l, c = o) : (n = o, c = l);
+  const { feeMode: i, feeRate: u } = P({
+    ...t,
+    ...e
+  });
+  return i === "A" || i === "buy" && r > 0 ? n = n.minus(n.abs().times(u)) : (i === "B" || i === "buy" && r < 0) && (c = c.minus(c.abs().times(u))), {
+    deltaA: n.toNumber(),
+    deltaB: c.toNumber()
+  };
+}
+function B(e, t) {
+  const r = t?.unitSize ?? 1;
+  let o = 0, l = 0;
+  if (e.price) {
+    const n = t?.positionSide === "short" ? -1 : 1;
+    let c, i = new a(e.balanceB);
+    t?.marketType === "future-c" ? (i = i.plus(e.balanceA * e.price / r), c = i.times(r).div(e.price)) : (i = i.plus(n * S(e.price, e.balanceA, t)), c = i.div(r).div(e.price).times(n)), o = c.toNumber(), l = i.toNumber();
+  }
+  return {
+    balanceA: e.balanceA,
+    balanceB: e.balanceB,
+    totalAsA: o,
+    totalAsB: l
+  };
+}
+function P(e) {
+  return {
+    feeMode: e?.feeMode ?? "buy",
+    feeRate: e?.feeRate ?? 0
+  };
+}
+function C(e) {
+  const {
+    startPrice: t,
+    stopPrice: r,
+    minDifference: o,
+    minRatio: l,
+    maxCount: n,
+    precision: c
+  } = e;
+  if (!o && l === 1 && !n)
+    throw new Error("Invalid grid config");
+  const i = {
+    totalCount: 0,
+    arithmeticCount: 0,
+    geometricStartPrice: new a(t)
+  };
+  let u = new a(t), s = !o;
+  for (; n && i.totalCount < n; ) {
+    let m = u.times(l);
+    if (!s) {
+      const p = u.plus(o);
+      p.lte(m) ? (s = !0, i.geometricStartPrice = u) : m = p;
+    }
+    if (m.gt(r)) break;
+    s || (i.arithmeticCount += 1), i.totalCount += 1, u = m;
+  }
+  s ? u.isEqualTo(t) || (i.geometricStartPrice = i.geometricStartPrice.minus(t).div(u.minus(t)).times(r - t).plus(t)) : i.geometricStartPrice = new a(r);
+  const h = [], x = i.arithmeticCount ? i.geometricStartPrice.minus(t).div(i.arithmeticCount) : 0, A = i.totalCount > i.arithmeticCount ? Math.pow(
+    r / i.geometricStartPrice.toNumber(),
+    1 / (i.totalCount - i.arithmeticCount)
+  ) : 0;
+  let d = 0, f = new a(t);
+  for (; d < i.arithmeticCount; ) {
+    const m = +f.toFixed(c);
+    f = f.plus(x);
+    const p = +f.toFixed(c), g = {
+      index: d,
+      price: m,
+      sellPrice: p
+    };
+    h.push(g), d += 1;
+  }
+  for (; d < i.totalCount; ) {
+    const m = +f.toFixed(c);
+    f = f.times(A);
+    const p = +f.toFixed(c), g = {
+      index: d,
+      price: m,
+      sellPrice: p
+    };
+    h.push(g), d += 1;
+  }
+  return h;
+}
+function N(e, t) {
+  const { enabledStartPrice: r, enabledStopPrice: o, placesPerSide: l, firstSellIndex: n } = {
+    enabledStartPrice: 0,
+    enabledStopPrice: e.length,
+    firstSellIndex: -1,
+    ...t
+  };
+  let c = 0, i = e.length;
+  for (; c < e.length && e[c].price < r; )
+    c += 1;
+  if (o)
+    for (; i >= 0 && e[i].sellPrice > o; )
+      i -= 1;
+  let u = c, s = i;
+  return n >= 0 && l && (u = Math.max(
+    u,
+    n - l
+  ), s = Math.min(s, n + l)), { startIndex: c, stopIndex: i, actualStartIndex: u, actualStopIndex: s };
+}
+function y(e, t) {
+  let r = e.findIndex((o) => o.sellPrice >= t);
+  return r < 0 && (r = e.length), r;
+}
+function R(e, t, r) {
+  return t / e * (1 - r) - 1 / (1 - r);
+}
+function F(e, t, r) {
+  const o = e ? w(e, r) : { deltaA: 0, deltaB: 0 }, l = t ? w(t, r) : { deltaA: 0, deltaB: 0 };
+  return {
+    profitA: new a(o.deltaA).plus(l.deltaA).toNumber(),
+    profitB: new a(o.deltaB).plus(l.deltaB).toNumber()
+  };
+}
+function M(e, t) {
+  const { feeMode: r, feeRate: o } = P(t);
+  return t.marketType !== "future-c" && ["buy", "A"].includes(r) && (e /= 1 - o), t.precisionA && (e = +new a(e).toFixed(
+    t.precisionA,
+    a.ROUND_UP
+  )), e;
+}
+function I(e, t) {
+  const { feeMode: r, feeRate: o } = P(t);
+  return t.marketType !== "future-c" && r === "A" && (e /= 1 + o), t.precisionA && (e = +new a(e).toFixed(
+    t.precisionA,
+    a.ROUND_DOWN
+  )), e;
+}
+function O(e, t, r, o) {
+  const l = [];
+  r.sort((c, i) => c.price - i.price), o.sort((c, i) => i.price - c.price);
+  let n = 0;
+  for (const c of r) {
+    for (; n < e.length && (e[n].price < c.price || l[n]); )
+      n += 1;
+    if (n >= e.length || n >= t)
+      throw new Error(`Unmatched order: ${JSON.stringify(c)}`);
+    l[n] = c;
+  }
+  n = e.length - 1;
+  for (const c of o) {
+    for (; n >= 0 && (e[n].sellPrice > c.price || l[n]); )
+      n -= 1;
+    if (n < 0 || n < t)
+      throw new Error(`Unmatched order: ${JSON.stringify(c)}`);
+    l[n] = c;
+  }
+  return l;
+}
+export {
+  B as calcBalance,
+  w as calcOrderDelta,
+  C as createGrids,
+  M as getBuyQuantity,
+  y as getFirstSellIndex,
+  F as getGridProfit,
+  N as getGridRange,
+  S as getOrderCost,
+  R as getProfitRate,
+  I as getSellQuantity,
+  O as matchOrders,
+  P as normalizeFeeOptions
+};

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+export type IPositionSide = '' | 'long' | 'short';
+export type IMarketType = 'spot' | 'future-u' | 'future-c';
+export type IFeeMode = 'buy' | 'free' | 'A' | 'B';
+export interface IBaseOrder {
+    price: number;
+    quantity: number;
+}
+export interface ICalcOptions {
+    unitSize?: number;
+    /** Default as 'spot' */
+    marketType?: IMarketType;
+    /** Default as '' for spot, 'long' for futures */
+    positionSide?: IPositionSide;
+    /** Default as 'buy' */
+    feeMode?: IFeeMode;
+    /** Default as 0 */
+    feeRate?: number;
+}
+export interface IBalance {
+    balanceA: number;
+    balanceB: number;
+    price: number;
+    usdValue: number;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@gera2ld/lib-trading",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "bignumber.js": "^9.3.1"
+  },
+  "scripts": {
+    "clean": "del-cli dist tsconfig.tsbuildinfo",
+    "build:types": "tsc",
+    "build:js": "vite build",
+    "build": "pnpm clean && pnpm /^build:/"
+  }
+}