@nadohq/shared 0.1.0-alpha.9 → 0.1.0

package/src/utils/math/decimalAdjustment.ts

@@ -1,4 +1,5 @@
-import { BigDecimal, BigDecimalish, toBigDecimal } from './bigDecimal';
+import BigNumber from 'bignumber.js';
+import { BigNumberish, toBigNumber } from './bigNumber';
 
 /**
  * All Nado balances have 18 decimals. Ex. 1e18 = 1.0
@@ -10,10 +11,10 @@ export const NADO_PRODUCT_DECIMALS = 18;
  *
  * - If `T` is `undefined`, the result is `undefined`.
  * - If `T` is a `number`, the result is a `number`.
- * - Otherwise, the result is a `BigDecimal`.
+ * - Otherwise, the result is a `BigNumber`.
  */
-type AdjustDecimalsResult<T extends BigDecimalish | undefined> =
-  T extends undefined ? undefined : T extends number ? number : BigDecimal;
+type AdjustDecimalsResult<T extends BigNumberish | undefined> =
+  T extends undefined ? undefined : T extends number ? number : BigNumber;
 
 /**
  * Adds the specified # of decimals to the number. For example, value = 1, decimals = 2, returns 100.
@@ -22,7 +23,7 @@ type AdjustDecimalsResult<T extends BigDecimalish | undefined> =
  * @param decimals number of decimal places to add, defaults to 18, which is the standard within Nado
  */
 
-export function addDecimals<T extends BigDecimalish | undefined>(
+export function addDecimals<T extends BigNumberish | undefined>(
   value: T,
   decimals: number = NADO_PRODUCT_DECIMALS,
 ): AdjustDecimalsResult<T> {
@@ -31,8 +32,8 @@ export function addDecimals<T extends BigDecimalish | undefined>(
       return undefined;
     }
 
-    const adjustedValue = toBigDecimal(value).multipliedBy(
-      toBigDecimal(10).pow(decimals),
+    const adjustedValue = toBigNumber(value).multipliedBy(
+      toBigNumber(10).pow(decimals),
     );
     return typeof value === 'number' ? adjustedValue.toNumber() : adjustedValue;
   };
@@ -46,7 +47,7 @@ export function addDecimals<T extends BigDecimalish | undefined>(
  * @param value can be undefined for better developer experience. If undefined, returns undefined.
  * @param decimals number of decimal places to remove, defaults to 18, which is the standard within Nado
  */
-export function removeDecimals<T extends BigDecimalish | undefined>(
+export function removeDecimals<T extends BigNumberish | undefined>(
   value: T,
   decimals: number = NADO_PRODUCT_DECIMALS,
 ): AdjustDecimalsResult<T> {
@@ -55,8 +56,8 @@ export function removeDecimals<T extends BigDecimalish | undefined>(
       return undefined;
     }
 
-    const adjustedValue = toBigDecimal(value).dividedBy(
-      toBigDecimal(10).pow(decimals),
+    const adjustedValue = toBigNumber(value).dividedBy(
+      toBigNumber(10).pow(decimals),
     );
     return typeof value === 'number' ? adjustedValue.toNumber() : adjustedValue;
   };

package/src/utils/math/index.ts

@@ -1,7 +1,7 @@
-export * from './bigDecimal';
-export * from './toIntegerString';
-export * from './toBigInt';
+export * from './bigNumber';
+export * from './BigNumbers';
 export * from './clamp';
-export * from './sumBigDecimalBy';
 export * from './decimalAdjustment';
-export * from './BigDecimals';
+export * from './sumBigNumberBy';
+export * from './toBigInt';
+export * from './toIntegerString';

package/src/utils/math/sumBigNumberBy.ts

@@ -0,0 +1,18 @@
+import BigNumber from 'bignumber.js';
+import { BigNumbers } from './BigNumbers';
+
+/**
+ * Util function to sum BigNumber values, inspired by Lodash
+ * @param collection
+ * @param iteratee
+ */
+export function sumBigNumberBy<T>(
+  collection: T[] | null | undefined,
+  iteratee: (value: T) => BigNumber.Value,
+): BigNumber {
+  return (
+    collection?.reduce((total, item) => {
+      return total.plus(iteratee(item));
+    }, BigNumbers.ZERO) ?? BigNumbers.ZERO
+  );
+}

package/src/utils/math/toBigInt.ts

@@ -1,11 +1,11 @@
-import { BigDecimalish } from './bigDecimal';
+import { BigNumberish } from './bigNumber';
 import { toIntegerString } from './toIntegerString';
 
 /**
- * Converts a BigDecimalish value to bigint
+ * Converts a BigNumberish value to bigint
  *
  * @param val
  */
-export function toBigInt(val: BigDecimalish): bigint {
+export function toBigInt(val: BigNumberish): bigint {
   return BigInt(toIntegerString(val));
 }

package/src/utils/math/toIntegerString.ts

@@ -1,11 +1,11 @@
-import { BigDecimalish, toBigDecimal } from './bigDecimal';
+import { BigNumberish, toBigNumber } from './bigNumber';
 
 /**
- * Converts a BigDecimalish value to string
+ * Converts a BigNumberish value to string
  *
  * @param val
  */
-export function toIntegerString(val: BigDecimalish): string {
+export function toIntegerString(val: BigNumberish): string {
   // toFixed is required as toString gives values with `e`
-  return toBigDecimal(val).toFixed(0);
+  return toBigNumber(val).toFixed(0);
 }

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

@@ -0,0 +1,49 @@
+import { OrderAppendixIsolatedFields } from '../../../types';
+import {
+  addDecimals,
+  NADO_PRODUCT_DECIMALS,
+  removeDecimals,
+  toBigInt,
+} from '../../math';
+import { bitMaskValue } from './bitMaskValue';
+
+const APPENDIX_V1_ISO_MARGIN_DECIMALS = 6;
+
+/* Appendix v1 uses x6 precision, so we need to adjust precision to/from SDK's usual precision */
+const MARGIN_DECIMAL_ADJUSTMENT =
+  NADO_PRODUCT_DECIMALS - APPENDIX_V1_ISO_MARGIN_DECIMALS;
+
+/**
+ * Packs the provided margin into a single 64-bit bigint.
+ *
+ * Bit layout (MSB → LSB):
+ * | margin_x6 |
+ * |-----------|
+ * | 63..0     |
+ * | 64 bits   |
+ *
+ */
+export function packIsolatedOrderAppendixValue({
+  margin,
+}: OrderAppendixIsolatedFields): bigint {
+  return bitMaskValue(
+    toBigInt(removeDecimals(margin, MARGIN_DECIMAL_ADJUSTMENT)),
+    64,
+  );
+}
+
+/**
+ * Unpacks a 64-bit bigint into its component fields for Isolated orders.
+ *
+ * @param value 64-bit bigint to unpack
+ * @returns Object with:
+ *   - margin_x6: bigint, from bits 63..0
+ */
+export function unpackIsolatedOrderAppendixValue(
+  value: bigint,
+): OrderAppendixIsolatedFields {
+  const margin = bitMaskValue(value, 64);
+  return {
+    margin: toBigInt(addDecimals(margin, MARGIN_DECIMAL_ADJUSTMENT)),
+  };
+}

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

@@ -2,17 +2,16 @@ import { OrderAppendixTwapFields } from '../../../types/orderAppendixTypes';
 import { addDecimals, removeDecimals, toBigInt } from '../../math';
 
 /**
- * Packs the provided fields into a single 96-bit bigint.
+ * Packs the provided fields into a single 64-bit bigint.
  *
  * Bit layout (MSB → LSB):
- * |   times   | slippage_x6 | reserved |
- * |-----------|-------------|----------|
- * | 95..64    | 63..32      | 31..0    |
- * | 32 bits   | 32 bits     | 32 bits  |
+ * |   times   | slippage_x6 |
+ * |-----------|-------------|
+ * | 63..32    | 31..0       |
+ * | 32 bits   | 32 bits     |
  *
- * - `times` occupies bits 95..64 (most significant 32 bits)
- * - `slippage_x6` occupies bits 63..32 (middle 32 bits)
- * - `reserved` occupies bits 31..0 (least significant 32 bits)
+ * - `times` occupies bits 63..32 (most significant 32 bits)
+ * - `slippage_x6` occupies bits 31..0 (least significant 32 bits)
  */
 export function packTwapOrderAppendixValue({
   numOrders,
@@ -22,27 +21,23 @@ export function packTwapOrderAppendixValue({
   const slippageX6BigInt = toBigInt(addDecimals(slippageFrac, 6));
 
   return (
-    ((numOrdersBigInt & 0xffffffffn) << 64n) |
-    ((slippageX6BigInt & 0xffffffffn) << 32n) |
-    // The last reserved 32 bits are set to 0
-    (0n & 0xffffffffn)
+    ((numOrdersBigInt & 0xffffffffn) << 32n) | (slippageX6BigInt & 0xffffffffn)
   );
 }
 
 /**
- * Unpacks a 96-bit bigint into its component fields for TWAP orders.
+ * Unpacks a 64-bit bigint into its component fields for TWAP orders.
  *
- * @param value 96-bit bigint to unpack
+ * @param value 64-bit bigint to unpack
  * @returns Object with:
- *   - times: number, from bits 95..64
- *   - slippage_x6: number, from bits 63..32
- *   - reserved: number, from bits 31..0
+ *   - times: number, from bits 63..32
+ *   - slippage_x6: number, from bits 31..0
  */
 export function unpackTwapOrderAppendixValue(
   value: bigint,
 ): OrderAppendixTwapFields {
-  const numOrders = (value >> 64n) & 0xffffffffn;
-  const slippageX6 = (value >> 32n) & 0xffffffffn;
+  const numOrders = (value >> 32n) & 0xffffffffn;
+  const slippageX6 = value & 0xffffffffn;
 
   return {
     numOrders: Number(numOrders),

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

@@ -1,5 +1,5 @@
 export * from './appendixTwapValue';
-export * from './unpackOrderAppendix';
+export * from './bitMaskValue';
 export * from './packOrderAppendix';
 export * from './types';
-export * from './bitMaskValue';
+export * from './unpackOrderAppendix';

package/src/utils/orders/appendix/orderAppendix.test.ts

@@ -11,7 +11,7 @@ describe('OrderAppendix packing/unpacking', () => {
     };
     const packed = packOrderAppendix(appendix);
     const unpacked = unpackOrderAppendix(packed);
-    expect(packed).toBe(4096n);
+    expect(packed).toBe(4097n);
     expect(unpacked.orderExecutionType).toBe(appendix.orderExecutionType);
     expect(unpacked.triggerType).toBe(appendix.triggerType);
     expect(unpacked.reduceOnly).toBeFalsy();
@@ -25,7 +25,7 @@ describe('OrderAppendix packing/unpacking', () => {
     };
     const packed = packOrderAppendix(appendix);
     const unpacked = unpackOrderAppendix(packed);
-    expect(packed).toBe(6144n);
+    expect(packed).toBe(6145n);
     expect(unpacked.reduceOnly).toBe(true);
   });
 
@@ -60,12 +60,12 @@ describe('OrderAppendix packing/unpacking', () => {
       orderExecutionType: 'default',
       triggerType: 'price',
 
-      isolated: { margin: 123456789012345678901234n },
+      isolated: { margin: 12345678901000000000000n },
     };
     const packed = packOrderAppendix(appendix);
     const unpacked = unpackOrderAppendix(packed);
-    expect(packed).toBe(530242871277196831127717244047616n);
-    expect(unpacked.isolated?.margin).toBe(123456789012345678901234n);
+    expect(packed).toBe(227737579102942800187821658369n);
+    expect(unpacked.isolated?.margin).toBe(appendix.isolated?.margin);
   });
 
   it('should handle TWAP fields', () => {
@@ -77,7 +77,7 @@ describe('OrderAppendix packing/unpacking', () => {
     };
     const packed = packOrderAppendix(appendix);
     const unpacked = unpackOrderAppendix(packed);
-    expect(packed).toBe(792281717376363744483197591552n);
+    expect(packed).toBe(792281717376363744483197591553n);
     expect(unpacked.twap).toMatchObject({ numOrders: 10, slippageFrac: 0.005 });
   });
 
@@ -86,16 +86,16 @@ describe('OrderAppendix packing/unpacking', () => {
       orderExecutionType: 'post_only',
       triggerType: undefined,
       reduceOnly: true,
-      isolated: { margin: 79228162514264337593543950335n }, // 2^96-1
+      isolated: { margin: 18446744073709551615n }, // 2^64-1
     };
     const packed = packOrderAppendix(appendix);
     const unpacked = unpackOrderAppendix(packed);
     expect(unpacked.orderExecutionType).toBe(appendix.orderExecutionType);
     expect(unpacked.triggerType).toBe(appendix.triggerType);
     expect(unpacked.reduceOnly).toBe(appendix.reduceOnly);
-    expect(unpacked.isolated?.margin).toBe(79228162514264337593543950335n);
+    expect(unpacked.isolated?.margin).toBe(18446744000000000000n);
     expect(unpacked.twap).toBe(undefined);
-    expect(packed).toBe(340282366920938463463374607427473248000n);
+    expect(packed).toBe(340282365561237229015142145n);
   });
 
   it('should handle max values for all fields for TWAP orders', () => {
@@ -104,7 +104,6 @@ describe('OrderAppendix packing/unpacking', () => {
       triggerType: 'twap_custom_amounts',
       reduceOnly: true,
       twap: {
-        // max 32-bit unsigned int
         numOrders: 4294967295,
         slippageFrac: 0.000001,
       },
@@ -116,6 +115,64 @@ describe('OrderAppendix packing/unpacking', () => {
     expect(unpacked.reduceOnly).toBe(appendix.reduceOnly);
     expect(unpacked.twap?.slippageFrac).toBe(0.000001);
     expect(unpacked.twap?.numOrders).toBe(4294967295);
-    expect(packed).toBe(340282366841710300967557013911933828608n);
+    expect(packed).toBe(340282366841710300967557013911933828609n);
+  });
+
+  it('should handle builder fields', () => {
+    const appendix: OrderAppendix = {
+      orderExecutionType: 'default',
+      builder: { builderId: 123, builderFeeRate: 500 },
+    };
+    const packed = packOrderAppendix(appendix);
+    const unpacked = unpackOrderAppendix(packed);
+    expect(unpacked.builder?.builderId).toBe(123);
+    expect(unpacked.builder?.builderFeeRate).toBe(500);
+  });
+
+  it('should handle builder with zero fee rate', () => {
+    const appendix: OrderAppendix = {
+      orderExecutionType: 'default',
+      builder: { builderId: 42, builderFeeRate: 0 },
+    };
+    const packed = packOrderAppendix(appendix);
+    const unpacked = unpackOrderAppendix(packed);
+    expect(unpacked.builder?.builderId).toBe(42);
+    expect(unpacked.builder?.builderFeeRate).toBe(0);
+  });
+
+  it('should handle builder with max values', () => {
+    const appendix: OrderAppendix = {
+      orderExecutionType: 'default',
+      builder: { builderId: 65535, builderFeeRate: 1023 }, // 16 bits, 10 bits max
+    };
+    const packed = packOrderAppendix(appendix);
+    const unpacked = unpackOrderAppendix(packed);
+    expect(unpacked.builder?.builderId).toBe(65535);
+    expect(unpacked.builder?.builderFeeRate).toBe(1023);
+  });
+
+  it('should handle builder combined with other flags', () => {
+    const appendix: OrderAppendix = {
+      orderExecutionType: 'ioc',
+      reduceOnly: true,
+      triggerType: 'price',
+      builder: { builderId: 5, builderFeeRate: 100 },
+    };
+    const packed = packOrderAppendix(appendix);
+    const unpacked = unpackOrderAppendix(packed);
+    expect(unpacked.orderExecutionType).toBe('ioc');
+    expect(unpacked.reduceOnly).toBe(true);
+    expect(unpacked.triggerType).toBe('price');
+    expect(unpacked.builder?.builderId).toBe(5);
+    expect(unpacked.builder?.builderFeeRate).toBe(100);
+  });
+
+  it('should not return builder fields when builderId is 0', () => {
+    const appendix: OrderAppendix = {
+      orderExecutionType: 'default',
+    };
+    const packed = packOrderAppendix(appendix);
+    const unpacked = unpackOrderAppendix(packed);
+    expect(unpacked.builder).toBeUndefined();
   });
 });

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

@@ -1,5 +1,5 @@
 import { OrderAppendix } from '../../../types/orderAppendixTypes';
-import { toBigInt } from '../../math/toBigInt';
+import { packIsolatedOrderAppendixValue } from './appendixIsolatedValue';
 import { packTwapOrderAppendixValue } from './appendixTwapValue';
 import { bitMaskValue } from './bitMaskValue';
 import { PackedOrderAppendixBits } from './types';
@@ -12,7 +12,7 @@ function mapOrderAppendixToBitValues(
       return packTwapOrderAppendixValue(appendix.twap);
     }
     if (appendix.isolated) {
-      return toBigInt(appendix.isolated.margin);
+      return packIsolatedOrderAppendixValue(appendix.isolated);
     }
     return 0n;
   })();
@@ -43,12 +43,14 @@ function mapOrderAppendixToBitValues(
 
   return {
     value,
+    builderId: appendix.builder?.builderId ?? 0,
+    builderFeeRate: appendix.builder?.builderFeeRate ?? 0,
     reserved: 0,
     trigger,
     reduceOnly: appendix.reduceOnly ? 1 : 0,
     orderType,
     isolated: appendix.isolated ? 1 : 0,
-    version: 0,
+    version: 1,
   };
 }
 
@@ -59,9 +61,11 @@ function mapOrderAppendixToBitValues(
 export function packOrderAppendix(appendix: OrderAppendix): bigint {
   const bits = mapOrderAppendixToBitValues(appendix);
 
-  // Ensure value is within 96 bits
-  let packed = bitMaskValue(bits.value, 96);
-  packed = (packed << 18n) | bitMaskValue(bits.reserved, 18);
+  // Ensure value is within 64 bits
+  let packed = bitMaskValue(bits.value, 64);
+  packed = (packed << 16n) | bitMaskValue(bits.builderId, 16);
+  packed = (packed << 10n) | bitMaskValue(bits.builderFeeRate, 10);
+  packed = (packed << 24n) | bitMaskValue(bits.reserved, 24);
   packed = (packed << 2n) | bitMaskValue(bits.trigger, 2);
   packed = (packed << 1n) | bitMaskValue(bits.reduceOnly, 1);
   packed = (packed << 2n) | bitMaskValue(bits.orderType, 2);

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

@@ -1,17 +1,19 @@
 /**
  * Bit layout for OrderAppendix packing (MSB → LSB):
  *
- * |   value   | reserved | trigger | reduceOnly | orderType | isolated | version |
- * |-----------|----------|---------|------------|-----------|----------|---------|
- * | 127..32   | 31..14   | 13..12  | 11         | 10..9     | 8        | 7..0    |
- * |  96 bits  | 18 bits  | 2 bits  | 1 bit      | 2 bits    | 1 bit    | 8 bits  |
+ * |   value   | builderId | builderFeeRate | reserved | trigger | reduceOnly | orderType | isolated | version |
+ * |-----------|-----------|----------------|----------|---------|------------|-----------|----------|---------|
+ * | 127..64   | 63..48    | 47..38         | 37..14   | 13..12  | 11         | 10..9     | 8        | 7..0    |
+ * |  64 bits  | 16 bits   | 10 bits        | 24 bits  | 2 bits  | 1 bit      | 2 bits    | 1 bit    | 8 bits  |
  */
 export interface PackedOrderAppendixBits {
-  value: bigint; // 96 bits
-  reserved: number; // 18 bits, set to 0
+  value: bigint; // 64 bits
+  builderId: number; // 16 bits
+  builderFeeRate: number; // 10 bits
+  reserved: number; // 24 bits, set to 0
   trigger: number; // 2 bits
   reduceOnly: number; // 1 bit
   orderType: number; // 2 bits
   isolated: number; // 1 bit
-  version: number; // 8 bits, set to 0
+  version: number; // 8 bits, set to 1
 }

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

@@ -1,5 +1,6 @@
 import { OrderAppendix } from '../../../types/orderAppendixTypes';
-import { BigDecimalish, toBigInt } from '../../math';
+import { BigNumberish, toBigInt } from '../../math';
+import { unpackIsolatedOrderAppendixValue } from './appendixIsolatedValue';
 import { unpackTwapOrderAppendixValue } from './appendixTwapValue';
 import { bitMaskValue } from './bitMaskValue';
 import { PackedOrderAppendixBits } from './types';
@@ -35,7 +36,7 @@ function mapBitValuesToAppendix(bits: PackedOrderAppendixBits): OrderAppendix {
   })();
   const isolatedFields = (() => {
     if (bits.isolated) {
-      return { margin: bits.value };
+      return unpackIsolatedOrderAppendixValue(bits.value);
     }
     return undefined;
   })();
@@ -44,6 +45,15 @@ function mapBitValuesToAppendix(bits: PackedOrderAppendixBits): OrderAppendix {
       return unpackTwapOrderAppendixValue(bits.value);
     }
   })();
+  const builderFields = (() => {
+    if (bits.builderId) {
+      return {
+        builderId: bits.builderId,
+        builderFeeRate: bits.builderFeeRate,
+      };
+    }
+    return undefined;
+  })();
 
   return {
     reduceOnly: !!bits.reduceOnly,
@@ -51,6 +61,7 @@ function mapBitValuesToAppendix(bits: PackedOrderAppendixBits): OrderAppendix {
     triggerType,
     isolated: isolatedFields,
     twap: twapFields,
+    builder: builderFields,
   };
 }
 
@@ -58,7 +69,7 @@ function mapBitValuesToAppendix(bits: PackedOrderAppendixBits): OrderAppendix {
  * Unpack the OrderAppendix fields from a packed bigint.
  * @param packed
  */
-export function unpackOrderAppendix(packed: BigDecimalish): OrderAppendix {
+export function unpackOrderAppendix(packed: BigNumberish): OrderAppendix {
   let temp = toBigInt(packed);
   // Bitmasks lowest 8 bits for version
   const version = Number(bitMaskValue(temp, 8));
@@ -73,13 +84,19 @@ export function unpackOrderAppendix(packed: BigDecimalish): OrderAppendix {
   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);
+  const reserved = Number(bitMaskValue(temp, 24));
+  temp >>= 24n;
+  const builderFeeRate = Number(bitMaskValue(temp, 10));
+  temp >>= 10n;
+  const builderId = Number(bitMaskValue(temp, 16));
+  temp >>= 16n;
+  // The remaining bits are the value, which should be 64 bits
+  const value = bitMaskValue(temp, 64);
 
   return mapBitValuesToAppendix({
     value,
+    builderId,
+    builderFeeRate,
     reserved,
     trigger,
     reduceOnly,

package/src/utils/orders/index.ts

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

package/src/utils/productTypeFilter.ts

@@ -1,9 +1,9 @@
 import { Balance, PerpBalance, SpotBalance } from '../types/balanceTypes';
 import {
-  ProductEngineType,
   PerpProduct,
-  SpotProduct,
   Product,
+  ProductEngineType,
+  SpotProduct,
 } from '../types/productTypes';
 
 export function isSpotProduct(product: Product): product is SpotProduct {

package/src/utils/toPrintableObject.ts

@@ -1,25 +1,45 @@
-import { BigDecimal } from './math/bigDecimal';
+import BigNumber from 'bignumber.js';
 
 /**
- * Util for converting any BigDecimal types into a string so that it can be logged nicely
+ * Util for converting any BigNumber types into a string so that it can be logged nicely.
+ * Handles cyclic references by returning '[Circular]' for already-visited objects.
  */
-export function toPrintableObject(obj: unknown): unknown {
-  if (obj == null) {
+export function toPrintableObject(
+  obj: null | undefined,
+  seen?: WeakSet<object>,
+): null;
+export function toPrintableObject(
+  obj: BigNumber | bigint,
+  seen?: WeakSet<object>,
+): string;
+export function toPrintableObject(obj: unknown, seen?: WeakSet<object>): object;
+export function toPrintableObject(obj: unknown, seen = new WeakSet()): unknown {
+  if (obj === null || obj === undefined) {
     return null;
   }
-  if (obj instanceof BigDecimal || typeof obj === 'bigint') {
+  if (obj instanceof BigNumber || typeof obj === 'bigint') {
     return obj.toString();
   }
   if (Array.isArray(obj)) {
-    return obj.map(toPrintableObject);
+    return obj.map((item) => toPrintableObject(item, seen));
   }
   if (typeof obj === 'object') {
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [
-        key,
-        toPrintableObject(value),
-      ]),
-    );
+    // Detect cyclic references
+    if (seen.has(obj)) {
+      return '[Circular]';
+    }
+    seen.add(obj);
+
+    try {
+      return Object.fromEntries(
+        Object.entries(obj).map(([key, value]) => [
+          key,
+          toPrintableObject(value, seen),
+        ]),
+      );
+    } catch {
+      return { error: '[Unserializable Object]' };
+    }
   }
   return obj;
 }

package/dist/chunk-TUJ4HQKF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../node_modules/@jest/globals/build/index.js"],"sourcesContent":["/*!\n * /**\n *  * Copyright (c) Meta Platforms, Inc. and affiliates.\n *  *\n *  * This source code is licensed under the MIT license found in the\n *  * LICENSE file in the root directory of this source tree.\n *  * /\n */\n/******/ (() => { // webpackBootstrap\n/******/ \t\"use strict\";\nvar __webpack_exports__ = {};\n\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\n\nthrow new Error('Do not import `@jest/globals` outside of the Jest test environment');\nmodule.exports = __webpack_exports__;\n/******/ })()\n;"],"mappings":";;;;;AAAA;AAAA;AAAA;AAQS,KAAC,MAAM;AACN;AACV,UAAI,sBAAsB,CAAC;AAY3B,YAAM,IAAI,MAAM,oEAAoE;AACpF,aAAO,UAAU;AAAA,IACR,GAAG;AAAA;AAAA;","names":[]}

package/dist/deployments/core/deployment.InkSepolia.json

@@ -1,13 +0,0 @@
-{
-  "nodeUrl": "https://rpc-gel-sepolia.inkonchain.com",
-  "explorerUrl": "https://explorer-sepolia.inkonchain.com",
-  "startBlock": 27233833,
-  "deployer": "0x8177A1b5bFaAa10A4b1178c6D42aDaa4b75c8146",
-  "quote": "0x5F65358d61A9a281ea3BB930d05889ACa21E3f4f",
-  "querier": "0x5A62e748b2630560Ffe9E928780cF9Fe0e086A21",
-  "clearinghouse": "0x5E9b4336104069467E57E843033e62c79C667F8F",
-  "endpoint": "0xf8963f7860aF7DE9b94893EDb9A3b5c155e1Fc0c",
-  "spotEngine": "0x61AA7A636df5e72eBe34c70a340eB76ABB3A15bE",
-  "perpEngine": "0x3D6Ac7105cA399884739a8CC19cAdB4178844466",
-  "withdrawPool": "0xa59613a3e4ce46E20d83b0632E3D857e3f116F66"
-}

package/dist/deployments/core/deployment.arbitrumOne.json

@@ -1,18 +0,0 @@
-{
-  "nodeUrl": "https://arb1.arbitrum.io/rpc",
-  "explorerUrl": "https://explorer.arbitrum.io",
-  "subgraphCoreUrl": "https://api.thegraph.com/subgraphs/name/nado-protocol/nado-prod-core",
-  "subgraphMarketsUrl": "https://api.thegraph.com/subgraphs/name/nado-protocol/nado-prod-markets",
-  "subgraphCandleSticksUrl": "https://api.thegraph.com/subgraphs/name/nado-protocol/nado-prod-candlesticks",
-  "startBlock": 67108377,
-  "deployer": "0xB746472C10f9F128FF9F5029f424cC91bb1D8C3a",
-  "quote": "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
-  "querier": "0x1693273B443699bee277eCbc60e2C8027E91995d",
-  "feeCalculator": "0x2259440579447D0625a5E28dfF3E743d207e8890",
-  "clearinghouse": "0xAE1ec28d6225dCE2ff787dcb8CE11cF6D3AE064f",
-  "clearinghouseLiq": "0xca007C51Fc14eEA88252Cc4FD71e91E44026F020",
-  "endpoint": "0xbbEE07B3e8121227AfCFe1E2B82772246226128e",
-  "spotEngine": "0x32d91Af2B17054D575A7bF1ACfa7615f41CCEfaB",
-  "perpEngine": "0xb74C78cca0FADAFBeE52B2f48A67eE8c834b5fd1",
-  "withdrawPool": "0x3567a1f8d79046A7e93Fd76d71104A978cDC6d05"
-}

package/dist/utils/math/BigDecimals.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/math/BigDecimals.ts"],"sourcesContent":["import { toBigDecimal } from './bigDecimal';\n\nexport const BigDecimals = Object.freeze({\n  ZERO: toBigDecimal(0),\n  ONE: toBigDecimal(1),\n  INF: toBigDecimal(Infinity),\n  MAX_I128: toBigDecimal('170141183460469231731687303715884105727'),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA6B;AAEtB,IAAM,cAAc,OAAO,OAAO;AAAA,EACvC,UAAM,gCAAa,CAAC;AAAA,EACpB,SAAK,gCAAa,CAAC;AAAA,EACnB,SAAK,gCAAa,QAAQ;AAAA,EAC1B,cAAU,gCAAa,yCAAyC;AAClE,CAAC;","names":[]}

package/dist/utils/math/BigDecimals.d.cts

@@ -1,8 +0,0 @@
-declare const BigDecimals: Readonly<{
-    ZERO: BigNumber;
-    ONE: BigNumber;
-    INF: BigNumber;
-    MAX_I128: BigNumber;
-}>;
-
-export { BigDecimals };