@nadohq/shared 0.1.0-alpha.4

package/src/utils/orders/appendix/unpackOrderAppendix.ts

@@ -0,0 +1,90 @@
+import { OrderAppendix } from '../../../types/orderAppendixTypes';
+import { BigDecimalish, toBigInt } from '../../math';
+import { unpackTWAPOrderAppendixValue } from './appendixTWAPValue';
+import { bitMaskValue } from './bitMaskValue';
+import { PackedOrderAppendixBits } from './types';
+
+function mapBitValuesToAppendix(bits: PackedOrderAppendixBits): OrderAppendix {
+  const triggerType = (() => {
+    switch (bits.trigger) {
+      case 1:
+        return 'price';
+      case 2:
+        return 'twap';
+      case 3:
+        return 'twap_custom_amounts';
+      default:
+        return undefined;
+    }
+  })();
+  const orderExecutionType = (() => {
+    switch (bits.orderType) {
+      case 0:
+        return 'default';
+      case 1:
+        return 'ioc';
+      case 2:
+        return 'fok';
+      case 3:
+        return 'post_only';
+      default:
+        throw new Error(
+          `[mapBitValuesToAppendix] Unknown order type: ${bits.orderType}`,
+        );
+    }
+  })();
+  const isolatedFields = (() => {
+    if (bits.isolated) {
+      return { margin: bits.value };
+    }
+    return undefined;
+  })();
+  const twapFields = (() => {
+    if (triggerType === 'twap' || triggerType === 'twap_custom_amounts') {
+      return unpackTWAPOrderAppendixValue(bits.value);
+    }
+  })();
+
+  return {
+    reduceOnly: !!bits.reduceOnly,
+    orderExecutionType,
+    triggerType,
+    isolated: isolatedFields,
+    twap: twapFields,
+  };
+}
+
+/**
+ * Unpack the OrderAppendix fields from a packed bigint.
+ * @param packed
+ */
+export function unpackOrderAppendix(packed: BigDecimalish): OrderAppendix {
+  let temp = toBigInt(packed);
+  // Bitmasks lowest 8 bits for version
+  const version = Number(bitMaskValue(temp, 8));
+  // Shift out the version bits
+  temp >>= 8n;
+  // Repeat for the rest of the fields
+  const isolated = Number(bitMaskValue(temp, 1));
+  temp >>= 1n;
+  const orderType = Number(bitMaskValue(temp, 2));
+  temp >>= 2n;
+  const reduceOnly = Number(bitMaskValue(temp, 1));
+  temp >>= 1n;
+  const trigger = Number(bitMaskValue(temp, 2));
+  temp >>= 2n;
+  const reserved = Number(bitMaskValue(temp, 18));
+  temp >>= 18n;
+  // The remaining bits are the value, which should be 96 bits
+  const value = bitMaskValue(temp, 96);
+
+  return mapBitValuesToAppendix({
+    value,
+    reserved,
+    trigger,
+    reduceOnly,
+    orderType,
+    isolated,
+    version,
+  });
+}

package/src/utils/orders/index.ts

@@ -0,0 +1,3 @@
+export * from './orderNonce';
+export * from './recvTime';
+export * from './appendix';

package/src/utils/orders/orderNonce.ts

@@ -0,0 +1,32 @@
+import { toIntegerString } from '../math/toIntegerString';
+import { getDefaultRecvTime } from './recvTime';
+
+/**
+ * Generates an order nonce based on recvTime in milliseconds, defaulting to Date.now() + 90 seconds
+ * @param recvTimeMillis
+ * @param randomInt a random integer to avoid hash collisions
+ */
+export function getOrderNonce(
+  recvTimeMillis: number = getDefaultRecvTime(),
+  randomInt: number = Math.floor(Math.random() * 1000),
+): string {
+  return toIntegerString(getOrderNonceBigInt(recvTimeMillis, randomInt));
+}
+
+/**
+ * Gets the recvTime in millis from an order nonce
+ *
+ * @param orderNonce
+ */
+export function getRecvTimeFromOrderNonce(orderNonce: string): number {
+  // Right shift by 20 to remove the random int portion
+  const bigIntRecvTime = BigInt(orderNonce) >> 20n;
+  return Number(bigIntRecvTime.toString());
+}
+
+function getOrderNonceBigInt(
+  recvTimeMillis: number,
+  randomInt: number,
+): bigint {
+  return (BigInt(recvTimeMillis) << 20n) + BigInt(randomInt);
+}

package/src/utils/orders/recvTime.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates a default recvTime based on the time given in milliseconds.
+ * The default recvTime is 90 seconds from the current time.
+ *
+ * @param currentTimeMillis defaults to Date.now()
+ */
+export function getDefaultRecvTime(currentTimeMillis: number = Date.now()) {
+  return currentTimeMillis + 90 * 1000;
+}

package/src/utils/productTypeFilter.ts

@@ -0,0 +1,23 @@
+import { Balance, PerpBalance, SpotBalance } from '../types/balanceTypes';
+import {
+  ProductEngineType,
+  PerpProduct,
+  SpotProduct,
+  Product,
+} from '../types/productTypes';
+
+export function isSpotProduct(product: Product): product is SpotProduct {
+  return product.type === ProductEngineType.SPOT;
+}
+
+export function isSpotBalance(balance: Balance): balance is SpotBalance {
+  return balance.type === ProductEngineType.SPOT;
+}
+
+export function isPerpProduct(product: Product): product is PerpProduct {
+  return product.type === ProductEngineType.PERP;
+}
+
+export function isPerpBalance(balance: Balance): balance is PerpBalance {
+  return balance.type === ProductEngineType.PERP;
+}

package/src/utils/time.ts

@@ -0,0 +1,21 @@
+export enum TimeInSeconds {
+  MINUTE = 60,
+  HOUR = 3600,
+  DAY = 86400,
+  YEAR = 31536000,
+}
+
+/**
+ * Converts timestamp in milliseconds to seconds
+ * @param millis
+ */
+export function millisToSeconds(millis: number) {
+  return Math.floor(millis / 1000);
+}
+
+/**
+ * Current time in seconds
+ */
+export function nowInSeconds() {
+  return millisToSeconds(Date.now());
+}

package/src/utils/toPrintableObject.ts

@@ -0,0 +1,25 @@
+import { BigDecimal } from './math/bigDecimal';
+
+/**
+ * Util for converting any BigDecimal types into a string so that it can be logged nicely
+ */
+export function toPrintableObject(obj: unknown): unknown {
+  if (obj == null) {
+    return null;
+  }
+  if (obj instanceof BigDecimal || typeof obj === 'bigint') {
+    return obj.toString();
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(toPrintableObject);
+  }
+  if (typeof obj === 'object') {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        toPrintableObject(value),
+      ]),
+    );
+  }
+  return obj;
+}