@pear-protocol/utils 0.0.1

package/dist/asset/asset.types.d.ts

@@ -0,0 +1,9 @@
+import type { InstrumentId } from '@pear-protocol/types';
+import BigNumber from 'bignumber.js';
+export type AssetPnL = {
+    id: InstrumentId;
+    signedQuantity: BigNumber;
+    entryPrice: BigNumber;
+    currentPrice: BigNumber;
+    pnl: BigNumber;
+};

package/dist/asset/asset.types.js

@@ -0,0 +1 @@
+import 'bignumber.js';

package/dist/asset/compute.d.ts

@@ -0,0 +1,25 @@
+import type { InstrumentId } from '@pear-protocol/types';
+import BigNumber from 'bignumber.js';
+import type { Fill } from '../fills/fill.types';
+import type { AssetPnL } from './asset.types';
+type ExposureMap = Record<InstrumentId, string>;
+type PriceMap = Record<InstrumentId, string>;
+/**
+ * Entry notional for a SINGLE asset.
+ *
+ * Formula: |quantity| × weightedAverageEntryPrice
+ */
+export declare function computeAssetEntryNotional(signedQuantity: BigNumber, fills: Fill[]): BigNumber;
+/**
+ * Compute unrealized PnL for a SINGLE asset.
+ *
+ * Formula: signedQty × (currentPrice − entryPrice)
+ */
+export declare function computeAssetUPnL(signedQuantity: BigNumber, currentPrice: BigNumber, fills: Fill[]): BigNumber;
+/**
+ * Compute unrealized PnL for an entire position.
+ *
+ * Formula: Σ(signedQty × (currentPrice − entryPrice))
+ */
+export declare function computeAssetPnLs(exposureMap: ExposureMap, priceMap: PriceMap, fills: Fill[]): AssetPnL[];
+export {};

package/dist/asset/compute.js

@@ -0,0 +1,41 @@
+import BigNumber from 'bignumber.js';
+import { computeEntryPriceForAsset } from '../fills/compute';
+import { ZERO } from '../math';
+
+function computeAssetEntryNotional(signedQuantity, fills) {
+  if (signedQuantity.isZero()) return ZERO;
+  const entryPrice = computeEntryPriceForAsset(fills);
+  if (entryPrice.isZero()) return ZERO;
+  const unsignedQuantity = signedQuantity.abs();
+  return unsignedQuantity.multipliedBy(entryPrice);
+}
+function computeAssetUPnL(signedQuantity, currentPrice, fills) {
+  if (signedQuantity.isZero()) return ZERO;
+  const entryPrice = computeEntryPriceForAsset(fills);
+  if (entryPrice.isZero()) return ZERO;
+  const deltaPrice = currentPrice.minus(entryPrice);
+  return signedQuantity.multipliedBy(deltaPrice);
+}
+function computeAssetPnLs(exposureMap, priceMap, fills) {
+  const result = [];
+  for (const [id, signedQtyString] of Object.entries(exposureMap)) {
+    const priceString = priceMap[id];
+    if (!priceString) continue;
+    const signedQuantity = new BigNumber(signedQtyString);
+    if (signedQuantity.isZero()) continue;
+    const currentPrice = new BigNumber(priceString);
+    const assetFills = fills.filter((f) => f.symbol === id);
+    const entryPrice = computeEntryPriceForAsset(assetFills);
+    const pnl = signedQuantity.multipliedBy(currentPrice.minus(entryPrice));
+    result.push({
+      id,
+      signedQuantity,
+      entryPrice,
+      currentPrice,
+      pnl
+    });
+  }
+  return result;
+}
+
+export { computeAssetEntryNotional, computeAssetPnLs, computeAssetUPnL };

package/dist/asset/index.d.ts

@@ -0,0 +1,2 @@
+export type { AssetPnL } from './asset.types';
+export * from './compute';

package/dist/asset/index.js

@@ -0,0 +1 @@
+export * from './compute';

package/dist/basket/basket.types.d.ts

@@ -0,0 +1,10 @@
+import type { InstrumentId, Side } from '@pear-protocol/types';
+export type BasketLeg = {
+    symbol: InstrumentId;
+    side: Side;
+    weight: number;
+};
+export type BasketIndexLeg = {
+    symbol: InstrumentId;
+    weight: number;
+};

package/dist/basket/basket.types.js

@@ -0,0 +1 @@
+

package/dist/basket/compute.d.ts

@@ -0,0 +1,16 @@
+import type { InstrumentId } from '@pear-protocol/types';
+import BigNumber from 'bignumber.js';
+import type { BasketIndexLeg, BasketLeg } from './basket.types';
+type PriceMap = Record<InstrumentId, string>;
+/**
+ * Synthetic basket price:
+ *
+ *   Π(priceᵢ ^ (sign · weightᵢ))
+ *
+ * Computed in log-space:
+ *
+ *   exp( Σ(sign · weight · ln(price)) )
+ */
+export declare function computeBasketWeightedRatioV1(basket: BasketLeg[], priceMap: PriceMap): BigNumber | null;
+export declare function computeBasketIndexV1(basket: BasketIndexLeg[], priceMap: PriceMap): BigNumber | null;
+export {};

package/dist/basket/compute.js

@@ -0,0 +1,28 @@
+import 'bignumber.js';
+import { exponentiate } from '../math';
+
+function computeBasketWeightedRatioV1(basket, priceMap) {
+  let logSum = 0;
+  for (const leg of basket) {
+    const price = priceMap[leg.symbol];
+    if (!price) return null;
+    const priceNum = Number(price);
+    if (priceNum <= 0) return null;
+    const sign = leg.side === "BUY" ? 1 : -1;
+    logSum += sign * leg.weight * Math.log(priceNum);
+  }
+  return exponentiate(logSum);
+}
+function computeBasketIndexV1(basket, priceMap) {
+  let logSum = 0;
+  for (const leg of basket) {
+    const price = priceMap[leg.symbol];
+    if (!price) return null;
+    const priceNum = Number(price);
+    if (priceNum <= 0) return null;
+    logSum += leg.weight * Math.log(priceNum);
+  }
+  return exponentiate(logSum);
+}
+
+export { computeBasketIndexV1, computeBasketWeightedRatioV1 };

package/dist/basket/index.d.ts

@@ -0,0 +1 @@
+export * from './compute';

package/dist/basket/index.js

@@ -0,0 +1 @@
+export * from './compute';

package/dist/contract-size.d.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+/**
+ * Converts a quantity from contract units to base asset units.
+ * For most exchanges contractSize is 1 (1:1 mapping), but some (e.g., OKX) use fractional contract sizes.
+ */
+export declare function contractsToBase(contracts: BigNumber.Value, contractSize: number): BigNumber;
+/**
+ * Converts a quantity from base asset units to contract units.
+ * For most exchanges contractSize is 1 (1:1 mapping), but some (e.g., OKX) use fractional contract sizes.
+ */
+export declare function baseToContracts(base: BigNumber.Value, contractSize: number): BigNumber;

package/dist/contract-size.js

@@ -0,0 +1,10 @@
+import BigNumber from 'bignumber.js';
+
+function contractsToBase(contracts, contractSize) {
+  return new BigNumber(contracts).times(contractSize);
+}
+function baseToContracts(base, contractSize) {
+  return new BigNumber(base).div(contractSize);
+}
+
+export { baseToContracts, contractsToBase };

package/dist/fills/compute.d.ts

@@ -0,0 +1,9 @@
+import BigNumber from 'bignumber.js';
+import type { Fill } from './fill.types';
+/**
+ * Compute weighted average entry price for a SINGLE INSTRUMENT.
+ *
+ * - Handles flips automatically
+ * - Uses ONLY active fills since last flip
+ */
+export declare function computeEntryPriceForAsset(fills: Fill[]): BigNumber;

package/dist/fills/compute.js

@@ -0,0 +1,18 @@
+import BigNumber from 'bignumber.js';
+import { ZERO } from '../math';
+import { getActiveFillsSinceLastFlip } from './flips';
+
+function computeEntryPriceForAsset(fills) {
+  const activeFills = getActiveFillsSinceLastFlip(fills);
+  let weightedSum = ZERO;
+  let totalQty = ZERO;
+  for (const fill of activeFills) {
+    const price = new BigNumber(fill.price);
+    const qty = new BigNumber(fill.quantity);
+    weightedSum = weightedSum.plus(price.times(qty));
+    totalQty = totalQty.plus(qty);
+  }
+  return totalQty.isZero() ? ZERO : weightedSum.div(totalQty);
+}
+
+export { computeEntryPriceForAsset };

package/dist/fills/fill.types.d.ts

@@ -0,0 +1,10 @@
+import type { InstrumentId, Side } from '@pear-protocol/types';
+export type Fill = {
+    id: string;
+    cloid?: string | null;
+    symbol: InstrumentId;
+    price: string;
+    quantity: string;
+    side: Side;
+    reduceOnly: boolean;
+};

package/dist/fills/fill.types.js

@@ -0,0 +1 @@
+

package/dist/fills/flips.d.ts

@@ -0,0 +1,5 @@
+import type { Fill } from './fill.types';
+/**
+ * Returns only the fills contributing to the CURRENT exposure.
+ */
+export declare function getActiveFillsSinceLastFlip(fills: Fill[]): Fill[];

package/dist/fills/flips.js

@@ -0,0 +1,23 @@
+import BigNumber from 'bignumber.js';
+import { sign } from '../math';
+
+function getActiveFillsSinceLastFlip(fills) {
+  const lastFlipIndex = detectLastFlipIndex(fills);
+  return fills.slice(lastFlipIndex + 1);
+}
+function detectLastFlipIndex(fills) {
+  let runningExposure = new BigNumber(0);
+  let lastFlipIndex = -1;
+  fills.forEach((fill, i) => {
+    const qty = new BigNumber(fill.quantity);
+    const signedQty = fill.side === "BUY" ? qty : qty.negated();
+    const nextExposure = runningExposure.plus(signedQty);
+    if (!runningExposure.isZero() && sign(runningExposure) !== sign(nextExposure)) {
+      lastFlipIndex = i;
+    }
+    runningExposure = nextExposure;
+  });
+  return lastFlipIndex;
+}
+
+export { getActiveFillsSinceLastFlip };

package/dist/fills/index.d.ts

@@ -0,0 +1 @@
+export * from './compute';

package/dist/fills/index.js

@@ -0,0 +1 @@
+export * from './compute';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './asset';
+export * from './basket';
+export * from './contract-size';
+export * from './fills';
+export { countDecimals, exponentiate } from './math';
+export * from './position';
+export * from './precise-price';
+export * from './precise-quantity';
+export * from './validate-leverage';
+export * from './validate-quantity';

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from './asset';
+export * from './basket';
+export * from './contract-size';
+export * from './fills';
+export { countDecimals, exponentiate } from './math';
+export * from './position';
+export * from './precise-price';
+export * from './precise-quantity';
+export * from './validate-leverage';
+export * from './validate-quantity';

package/dist/math/index.d.ts

@@ -0,0 +1,23 @@
+import BigNumber from 'bignumber.js';
+export declare const ZERO: BigNumber;
+export declare const BIPS: BigNumber;
+/**
+ * Compute exponent using native Math.exp, returned as BigNumber. This
+ * is intentionally numeric (not arbitrary precision) and meant for
+ * index / basket calculations where log-space stability matters more
+ * than exactness.
+ *
+ * @param value - The number to exponentiate.
+ * @returns The exponentiated value.
+ */
+export declare function exponentiate(value: number): BigNumber;
+/**
+ * Compute the sign of a BigNumber.
+ * @param value - The value to compute the sign of.
+ * @returns The sign of the value.
+ */
+export declare function sign(value: BigNumber): 1 | -1 | 0;
+/**
+ * Count decimal places in a numeric string (e.g. "0.001" → 3, "1" → 0).
+ */
+export declare function countDecimals(value: string): number;

package/dist/math/index.js

@@ -0,0 +1,18 @@
+import BigNumber from 'bignumber.js';
+
+const ZERO = new BigNumber(0);
+const BIPS = new BigNumber(1e4);
+function exponentiate(value) {
+  const result = Math.exp(value);
+  return new BigNumber(result);
+}
+function sign(value) {
+  if (value.isZero()) return 0;
+  return value.isPositive() ? 1 : -1;
+}
+function countDecimals(value) {
+  const parts = value.split(".");
+  return parts[1]?.length ?? 0;
+}
+
+export { BIPS, ZERO, countDecimals, exponentiate, sign };

package/dist/position/compute.d.ts

@@ -0,0 +1,59 @@
+import type { InstrumentId } from '@pear-protocol/types';
+import BigNumber from 'bignumber.js';
+import type { AssetPnL } from '../asset/asset.types';
+import type { Fill } from '../fills/fill.types';
+import type { PositionPnL } from './position.types';
+type ExposureMap = Record<InstrumentId, string>;
+type PriceMap = Record<InstrumentId, string>;
+/**
+ * Current position notional (mark value).
+ *
+ * Formula: Σ(|quantity| × currentPrice)
+ */
+export declare function computePositionMarkNotional(assetPnLs: AssetPnL[]): BigNumber;
+/**
+ * Compute the position entry notional.
+ *
+ * Formula: Σ(|quantity| × entryPrice)
+ */
+export declare function computePositionEntryNotional(assetPnLs: AssetPnL[]): BigNumber;
+/**
+ * Compute the position unrealized PnL.
+ *
+ * Formula: Σ(pnl)
+ */
+export declare function computePositionUPnL(assetPnLs: AssetPnL[]): BigNumber;
+/**
+ * Compute the position PnL in basis points.
+ *
+ * Formula: UPnL bips = upnl / entryNotional × 10_000
+ */
+export declare function computePositionUPnLBips(upnl: BigNumber, entryNotional: BigNumber): BigNumber | null;
+/**
+ * Compute the average entry price of the current net position.
+ *
+ * This is equivalent to the weighted average price of the current basket,
+ * where the weights are the absolute quantities per asset.
+ *
+ * Formula: Σ(|quantity| × entryPrice) / Σ(|quantity|)
+ */
+export declare function computePositionEntryPrice(assetPnLs: AssetPnL[]): BigNumber | null;
+/**
+ * Compute the current (mark) price of the current net position.
+ *
+ * This is the weighted average mark price of the current basket,
+ * where the weights are the absolute quantities per asset.
+ *
+ * Formula: Σ(|quantity| × currentPrice) / Σ(|quantity|)
+ */
+export declare function computePositionCurrentPrice(assetPnLs: AssetPnL[]): BigNumber | null;
+/**
+ * Compute the position PnL from fills.
+ *
+ * @param exposureMap - The exposure map of the position.
+ * @param priceMap - The price map of the position.
+ * @param fills - The fills of the position.
+ * @returns The position PnL.
+ */
+export declare function computePositionFromFills(exposureMap: ExposureMap, priceMap: PriceMap, fills: Fill[]): PositionPnL;
+export {};

package/dist/position/compute.js

@@ -0,0 +1,81 @@
+import 'bignumber.js';
+import { computeAssetPnLs } from '../asset';
+import { ZERO, BIPS } from '../math';
+
+function computePositionMarkNotional(assetPnLs) {
+  return assetPnLs.reduce((acc, asset) => {
+    if (asset.signedQuantity.isZero()) return acc;
+    return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.currentPrice));
+  }, ZERO);
+}
+function computePositionEntryNotional(assetPnLs) {
+  return assetPnLs.reduce((acc, asset) => {
+    if (asset.signedQuantity.isZero()) return acc;
+    return acc.plus(asset.signedQuantity.abs().multipliedBy(asset.entryPrice));
+  }, ZERO);
+}
+function computePositionUPnL(assetPnLs) {
+  return assetPnLs.reduce((acc, asset) => acc.plus(asset.pnl), ZERO);
+}
+function computePositionUPnLBips(upnl, entryNotional) {
+  if (entryNotional.isZero()) return null;
+  return upnl.div(entryNotional).multipliedBy(BIPS);
+}
+function computePositionEntryPrice(assetPnLs) {
+  const { totalWeightedPrice, totalWeight } = assetPnLs.reduce(
+    (acc, { signedQuantity, entryPrice }) => {
+      const absQuantity = signedQuantity.abs();
+      return {
+        totalWeightedPrice: acc.totalWeightedPrice.plus(absQuantity.multipliedBy(entryPrice)),
+        totalWeight: acc.totalWeight.plus(absQuantity)
+      };
+    },
+    {
+      totalWeightedPrice: ZERO,
+      totalWeight: ZERO
+    }
+  );
+  if (totalWeight.isZero()) {
+    return null;
+  }
+  return totalWeightedPrice.dividedBy(totalWeight);
+}
+function computePositionCurrentPrice(assetPnLs) {
+  const { totalWeightedPrice, totalWeight } = assetPnLs.reduce(
+    (acc, { signedQuantity, currentPrice }) => {
+      const absQuantity = signedQuantity.abs();
+      return {
+        totalWeightedPrice: acc.totalWeightedPrice.plus(absQuantity.multipliedBy(currentPrice)),
+        totalWeight: acc.totalWeight.plus(absQuantity)
+      };
+    },
+    {
+      totalWeightedPrice: ZERO,
+      totalWeight: ZERO
+    }
+  );
+  if (totalWeight.isZero()) {
+    return null;
+  }
+  return totalWeightedPrice.dividedBy(totalWeight);
+}
+function computePositionFromFills(exposureMap, priceMap, fills) {
+  const assets = computeAssetPnLs(exposureMap, priceMap, fills);
+  const entryPrice = computePositionEntryPrice(assets);
+  const entryNotional = computePositionEntryNotional(assets);
+  const markPrice = computePositionCurrentPrice(assets);
+  const markNotional = computePositionMarkNotional(assets);
+  const upnl = computePositionUPnL(assets);
+  const upnlBips = computePositionUPnLBips(upnl, entryNotional);
+  return {
+    assets,
+    entryPrice,
+    entryNotional,
+    markPrice,
+    markNotional,
+    upnl,
+    upnlBips
+  };
+}
+
+export { computePositionCurrentPrice, computePositionEntryNotional, computePositionEntryPrice, computePositionFromFills, computePositionMarkNotional, computePositionUPnL, computePositionUPnLBips };

package/dist/position/index.d.ts

@@ -0,0 +1 @@
+export * from './compute';

package/dist/position/index.js

@@ -0,0 +1 @@
+export * from './compute';

package/dist/position/position.types.d.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+import type { AssetPnL } from '../asset/asset.types';
+export type PositionPnL = {
+    assets: AssetPnL[];
+    entryPrice: BigNumber | null;
+    entryNotional: BigNumber;
+    markPrice: BigNumber | null;
+    markNotional: BigNumber;
+    upnl: BigNumber;
+    upnlBips: BigNumber | null;
+};

package/dist/position/position.types.js

@@ -0,0 +1 @@
+import 'bignumber.js';

package/dist/precise-price.d.ts

@@ -0,0 +1,3 @@
+import type { Connector, InstrumentPrecision, Side } from '@pear-protocol/types';
+import BigNumber from 'bignumber.js';
+export declare function precisePrice(connector: Connector, raw: BigNumber.Value, precision: InstrumentPrecision, side?: Side, slippageToleranceBps?: number): string;

package/dist/precise-price.js

@@ -0,0 +1,63 @@
+import BigNumber from 'bignumber.js';
+
+BigNumber.config({
+  DECIMAL_PLACES: 30,
+  ROUNDING_MODE: BigNumber.ROUND_DOWN
+});
+function precisePrice(connector, raw, precision, side = "BUY", slippageToleranceBps = 0) {
+  const normalized = normalizePrice(raw);
+  const effectiveRaw = withSlippageTolerance(normalized, slippageToleranceBps, side);
+  switch (connector) {
+    case "hyperliquid":
+      return preciseHyperliquidPrice(effectiveRaw, precision, side);
+    case "binanceusdm":
+    case "bybit":
+    case "okx":
+      return preciseTickGridPrice(effectiveRaw, precision, side);
+  }
+}
+function withSlippageTolerance(normalized, slippageToleranceBps, side) {
+  if (slippageToleranceBps === 0) {
+    return normalized;
+  }
+  const bps = new BigNumber(slippageToleranceBps);
+  const factor = bps.div(1e4);
+  return side === "BUY" ? normalized.times(new BigNumber(1).plus(factor)) : normalized.times(new BigNumber(1).minus(factor));
+}
+function preciseHyperliquidPrice(price, precision, side) {
+  const maxDecimals = precision.price.decimals;
+  const maxSigFigs = precision.price.sigFigs ?? 5;
+  const rounding = side === "BUY" ? BigNumber.ROUND_FLOOR : BigNumber.ROUND_CEIL;
+  price = price.decimalPlaces(maxDecimals, rounding);
+  price = clampSigFigs(price, maxSigFigs, maxDecimals, rounding);
+  return price.toFixed();
+}
+function preciseTickGridPrice(price, precision, side) {
+  const tick = precision.price.tick ?? 1e-4;
+  const rounding = side === "BUY" ? BigNumber.ROUND_FLOOR : BigNumber.ROUND_CEIL;
+  const tickBN = new BigNumber(tick);
+  const scaled = price.div(tickBN);
+  const snapped = scaled.integerValue(rounding).times(tickBN);
+  const maxDecimals = precision.price.decimals;
+  const final = snapped.decimalPlaces(maxDecimals, rounding);
+  return final.toFixed();
+}
+function clampSigFigs(price, maxSigFigs, maxDecimals, rounding) {
+  const countSigFigs = (x) => x.toFixed().replace(".", "").replace(/^0+/, "").length;
+  if (countSigFigs(price) <= maxSigFigs) {
+    return price;
+  }
+  for (let d = maxDecimals; d >= 0; d--) {
+    const candidate = price.decimalPlaces(d, rounding);
+    if (countSigFigs(candidate) <= maxSigFigs) {
+      return candidate;
+    }
+  }
+  return price;
+}
+function normalizePrice(value) {
+  const bn = new BigNumber(value);
+  return new BigNumber(bn.toFixed());
+}
+
+export { precisePrice };

package/dist/precise-quantity.d.ts

@@ -0,0 +1,3 @@
+import type { Connector, InstrumentPrecision, Side } from '@pear-protocol/types';
+import BigNumber from 'bignumber.js';
+export declare function preciseQuantity(connector: Connector, raw: BigNumber.Value, precision: InstrumentPrecision, side: Side): string;

package/dist/precise-quantity.js

@@ -0,0 +1,36 @@
+import BigNumber from 'bignumber.js';
+import { baseToContracts } from './contract-size';
+
+BigNumber.config({
+  DECIMAL_PLACES: 30,
+  ROUNDING_MODE: BigNumber.ROUND_DOWN
+});
+function preciseQuantity(connector, raw, precision, side) {
+  switch (connector) {
+    case "hyperliquid":
+      return preciseHyperliquidQuantity(raw, precision, side);
+    case "binanceusdm":
+    case "bybit":
+    case "okx":
+      return preciseStepGridQuantity(raw, precision, side);
+  }
+}
+function preciseHyperliquidQuantity(raw, precision, side) {
+  const decimals = precision.quantity.decimals;
+  const qty = new BigNumber(raw);
+  const rounded = qty.decimalPlaces(decimals, side === "BUY" ? BigNumber.ROUND_FLOOR : BigNumber.ROUND_CEIL);
+  return rounded.toFixed();
+}
+function preciseStepGridQuantity(raw, precision, side) {
+  const step = precision.quantity.step;
+  const qty = baseToContracts(raw, precision.quantity.contractSize);
+  const stepBN = new BigNumber(step);
+  const scaled = qty.div(stepBN);
+  const rounded = side === "BUY" ? scaled.integerValue(BigNumber.ROUND_FLOOR) : scaled.integerValue(BigNumber.ROUND_CEIL);
+  const result = rounded.times(stepBN);
+  const maxDecimals = precision.quantity.decimals;
+  const final = result.decimalPlaces(maxDecimals, side === "BUY" ? BigNumber.ROUND_FLOOR : BigNumber.ROUND_CEIL);
+  return final.toFixed();
+}
+
+export { preciseQuantity };

package/dist/validate-leverage.d.ts

@@ -0,0 +1,2 @@
+import type { Instrument } from '@pear-protocol/types';
+export declare function validateLeverage(leverage: number, instrument: Instrument): boolean;

package/dist/validate-leverage.js

@@ -0,0 +1,7 @@
+function validateLeverage(leverage, instrument) {
+  if (leverage < 1 || leverage > 100) return false;
+  if (leverage > instrument.leverage) return false;
+  return true;
+}
+
+export { validateLeverage };

package/dist/validate-quantity.d.ts

@@ -0,0 +1,2 @@
+import type { InstrumentPrecision } from '@pear-protocol/types';
+export declare function validateQuantity(quantity: string, price: string, precision: InstrumentPrecision): boolean;

package/dist/validate-quantity.js

@@ -0,0 +1,22 @@
+import BigNumber from 'bignumber.js';
+import { contractsToBase } from './contract-size';
+
+function validateQuantity(quantity, price, precision) {
+  const q = new BigNumber(quantity);
+  if (!q.isFinite() || q.lte(0)) return false;
+  const p = new BigNumber(price);
+  if (!p.isFinite() || p.lte(0)) return false;
+  const step = new BigNumber(precision.quantity.step);
+  const scaled = q.div(step);
+  if (!scaled.isInteger()) return false;
+  const notional = contractsToBase(q, precision.quantity.contractSize).times(p);
+  if (precision.notional?.min !== void 0 && precision.notional.min !== null && precision.notional.min > 0) {
+    if (notional.lt(new BigNumber(precision.notional.min))) return false;
+  }
+  if (precision.notional?.max !== void 0 && precision.notional.max !== null && precision.notional.max > 0) {
+    if (notional.gt(new BigNumber(precision.notional.max))) return false;
+  }
+  return true;
+}
+
+export { validateQuantity };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@pear-protocol/utils",
+  "version": "0.0.1",
+  "description": "Pear Protocol Utility functions",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist .turbo",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@pear-protocol/types": "0.0.1",
+    "bignumber.js": "9.3.1"
+  },
+  "devDependencies": {
+    "@backend/typescript-config": "workspace:*",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3"
+  }
+}