@swapkit/helpers 1.0.0-rc.0 → 1.0.0-rc.10

package/src/modules/__tests__/swapKitNumber.test.ts

@@ -6,47 +6,50 @@ describe('SwapKitNumber', () => {
   describe('constructors', () => {
     test('creates numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(1);
-      expect(skNumber1.value).toBe('1');
-      expect(skNumber1.bigIntValue).toBe(100000000n);
+      expect(skNumber1.getValue('string')).toBe('1');
+      expect(skNumber1.getValue('number')).toBe(1);
+      expect(skNumber1.getBaseValue('bigint')).toBe(100000000n);
 
       const skNumber2 = new SwapKitNumber('1');
-      expect(skNumber2.value).toBe('1');
-      expect(skNumber2.bigIntValue).toBe(100000000n);
+      expect(skNumber2.getValue('string')).toBe('1');
+      expect(skNumber2.getBaseValue('bigint')).toBe(100000000n);
 
+      /**
+       * because by default we have 8 decimals - it will be rounded to 0 on base value
+       */
       const skNumber3 = new SwapKitNumber('0.0000000001');
-      expect(skNumber3.value).toBe('0.0000000001');
-      expect(skNumber3.bigIntValue).toBe(1n);
-
-      const skNumber4 = new SwapKitNumber(0.000000001);
-      expect(skNumber4.value).toBe('0.000000001');
-      expect(skNumber4.bigIntValue).toBe(1n);
-
-      const skNumber6 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
-      expect(skNumber6.value).toBe('0.101');
-      expect(skNumber6.bigIntValue).toBe(10050000n);
-
-      const skNumber7 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
-      expect(skNumber7.value).toBe('-0.101');
-      expect(skNumber7.bigIntValue).toBe(-10050000n);
-      expect(skNumber7.decimal).toBe(3);
-      expect(skNumber7.unsafeNumber).toBe(0);
-      expect(skNumber7.decimalMultiplier).toBe(100000000n);
-      expect(skNumber7.toString()).toBe('-0.101');
+      expect(skNumber3.getValue('string')).toBe('0.0000000001');
+      expect(skNumber3.getBaseValue('bigint')).toBe(0n);
+
+      const skNumber4 = new SwapKitNumber({ value: '0.0000000001', decimal: 10 });
+      expect(skNumber4.getValue('string')).toBe('0.0000000001');
+      expect(skNumber4.getBaseValue('bigint')).toBe(1n);
+
+      const skNumber5 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
+      expect(skNumber5.getValue('string')).toBe('0.101');
+      expect(skNumber5.getBaseValue('bigint')).toBe(100n);
+
+      const skNumber6 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
+      expect(skNumber6.getValue('string')).toBe('-0.101');
+      expect(skNumber6.getBaseValue('bigint')).toBe(-100n);
+      expect(skNumber6.decimal).toBe(3);
+      expect(skNumber6.getValue('number')).toBe(-0.101);
+      expect(skNumber6.decimalMultiplier).toBe(100000000n);
     });
 
     test('creates SwapKitInstance from BigInt: (12.345678901234, decimals: 12)', () => {
       const skNumber = SwapKitNumber.fromBigInt(12345678901234n, 12);
 
-      expect(skNumber.value).toBe('12.345678901234');
-      expect(skNumber.bigIntValue).toBe(12345678901234n);
+      expect(skNumber.getValue('string')).toBe('12.345678901234');
+      expect(skNumber.getBaseValue('bigint')).toBe(12345678901234n);
     });
   });
 
   describe('shiftDecimals', () => {
     test('shifts up and bumps number', () => {
       const skNumber = new SwapKitNumber(1);
-      expect(skNumber.value).toBe('1');
-      expect(skNumber.bigIntValue).toBe(100000000n);
+      expect(skNumber.getValue('string')).toBe('1');
+      expect(skNumber.getBaseValue('bigint')).toBe(100000000n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -54,14 +57,14 @@ describe('SwapKitNumber', () => {
         to: 8,
       });
 
-      expect(shiftedSkNumber.value).toBe('100');
-      expect(shiftedSkNumber.bigIntValue).toBe(10000000000n);
+      expect(shiftedSkNumber.getValue('string')).toBe('100');
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(10000000000n);
     });
 
-    test.skip('shifts down and rounds down number', () => {
+    test('shifts down and rounds down number', () => {
       const skNumber = new SwapKitNumber(2.12345678);
-      expect(skNumber.value).toBe('2.12345678');
-      expect(skNumber.bigIntValue).toBe(212345678n);
+      expect(skNumber.getValue('string')).toBe('2.12345678');
+      expect(skNumber.getBaseValue('bigint')).toBe(212345678n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -69,8 +72,84 @@ describe('SwapKitNumber', () => {
         to: 6,
       });
 
-      expect(shiftedSkNumber.value).toBe('2.123456');
-      expect(shiftedSkNumber.bigIntValue).toBe(2123456n);
+      expect(shiftedSkNumber.getValue('string')).toBe('2.123456');
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(2123456n);
+    });
+  });
+
+  describe('getValue', () => {
+    describe('string', () => {
+      test('returns string value', () => {
+        const skNumber = new SwapKitNumber(1);
+        expect(skNumber.getValue('string')).toBe('1');
+      });
+
+      test('returns string value with decimals', () => {
+        const skNumber = new SwapKitNumber(0.01);
+        expect(skNumber.getValue('string')).toBe('0.01');
+      });
+    });
+
+    describe('number', () => {
+      test('returns number value', () => {
+        const skNumber = new SwapKitNumber(1);
+        expect(skNumber.getValue('number')).toBe(1);
+      });
+
+      test('returns number value with decimals', () => {
+        const skNumber = new SwapKitNumber(0.01);
+        expect(skNumber.getValue('number')).toBe(0.01);
+      });
+    });
+
+    describe('bigint', () => {
+      test('returns bigint value', () => {
+        const skNumber = new SwapKitNumber(1);
+        expect(skNumber.getBaseValue('bigint')).toBe(100000000n);
+      });
+    });
+  });
+
+  describe('toSignificant', () => {
+    describe('normal cases', () => {
+      test('returns first significant number of digits', () => {
+        const usdLikeNumber = new SwapKitNumber(1234.5678);
+        expect(usdLikeNumber.toSignificant(2)).toBe('1200');
+        expect(usdLikeNumber.toSignificant(3)).toBe('1230');
+        expect(usdLikeNumber.toSignificant(4)).toBe('1234');
+        expect(usdLikeNumber.toSignificant(5)).toBe('1234.5');
+        expect(usdLikeNumber.toSignificant(6)).toBe('1234.56');
+        expect(usdLikeNumber.toSignificant(7)).toBe('1234.567');
+        expect(usdLikeNumber.toSignificant(8)).toBe('1234.5678');
+
+        const btcLikeNumber = new SwapKitNumber(0.00005678);
+        expect(btcLikeNumber.toSignificant(2)).toBe('0.000056');
+        expect(btcLikeNumber.toSignificant(3)).toBe('0.0000567');
+        expect(btcLikeNumber.toSignificant(4)).toBe('0.00005678');
+        expect(btcLikeNumber.toSignificant(5)).toBe('0.00005678');
+        expect(btcLikeNumber.toSignificant(8)).toBe('0.00005678');
+      });
+    });
+
+    describe('custom decimals', () => {
+      test('returns first significant number of digits', () => {
+        const usdLikeNumber = new SwapKitNumber({ value: 1234.5678, decimal: 2 });
+        expect(usdLikeNumber.toSignificant(2)).toBe('1200');
+        expect(usdLikeNumber.toSignificant(3)).toBe('1230');
+        expect(usdLikeNumber.toSignificant(4)).toBe('1234');
+        expect(usdLikeNumber.toSignificant(5)).toBe('1234.5');
+        expect(usdLikeNumber.toSignificant(6)).toBe('1234.57');
+        expect(usdLikeNumber.toSignificant(7)).toBe('1234.57');
+        expect(usdLikeNumber.toSignificant(8)).toBe('1234.57');
+
+        const ethLikeNumber = new SwapKitNumber({ value: 0.00005678, decimal: 18 });
+        expect(ethLikeNumber.toSignificant(2)).toBe('0.000056');
+        expect(ethLikeNumber.toSignificant(3)).toBe('0.0000567');
+        expect(ethLikeNumber.toSignificant(4)).toBe('0.00005678');
+        expect(ethLikeNumber.toSignificant(5)).toBe('0.00005678');
+        expect(ethLikeNumber.toSignificant(8)).toBe('0.00005678');
+        expect(ethLikeNumber.toSignificant(18)).toBe('0.00005678');
+      });
     });
   });
 
@@ -81,23 +160,23 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber('0.5');
       const result = skNumber1.add(skNumber2, skNumber3);
 
-      expect(result.value).toBe('15.5');
-      expect(result.bigIntValue).toBe(1550000000n);
+      expect(result.getValue('string')).toBe('15.5');
+      expect(result.getBaseValue('bigint')).toBe(1550000000n);
     });
 
     test('adds different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
       const result = skNumber1.add(6, '0.5');
 
-      expect(result.value).toBe('16.5');
-      expect(result.bigIntValue).toBe(1650000000n);
+      expect(result.getValue('string')).toBe('16.5');
+      expect(result.getBaseValue('bigint')).toBe(1650000000n);
     });
 
     test('adds large decimal numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(0.0000000001);
       const result = skNumber1.add(6.000000000001, '0.0000000000000005');
-      expect(result.value).toBe('6.0000000001010005');
-      expect(result.bigIntValue).toBe(60000000001010005n);
+      expect(result.getValue('string')).toBe('6.0000000001010005');
+      expect(result.getBaseValue('bigint')).toBe(600000000n);
     });
   });
 
@@ -108,16 +187,16 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber(0.5);
       const result = skNumber1.sub(skNumber2, skNumber3);
 
-      expect(result.value).toBe('4.5');
-      expect(result.bigIntValue).toBe(450000000n);
+      expect(result.getValue('string')).toBe('4.5');
+      expect(result.getBaseValue('bigint')).toBe(450000000n);
     });
 
     test('subtracts different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
       const result = skNumber1.sub(6, '0.5');
 
-      expect(result.value).toBe('3.5');
-      expect(result.bigIntValue).toBe(350000000n);
+      expect(result.getValue('string')).toBe('3.5');
+      expect(result.getBaseValue('bigint')).toBe(350000000n);
     });
 
     test('can process negative results', () => {
@@ -125,10 +204,10 @@ describe('SwapKitNumber', () => {
       const result0 = skNumber1.sub(10);
       const resultMinus = result0.sub('10');
 
-      expect(result0.value).toBe('0');
-      expect(resultMinus.value).toBe('-10');
-      expect(result0.bigIntValue).toBe(0n);
-      expect(resultMinus.bigIntValue).toBe(-1000000000n);
+      expect(result0.getValue('string')).toBe('0');
+      expect(resultMinus.getValue('string')).toBe('-10');
+      expect(result0.getBaseValue('bigint')).toBe(0n);
+      expect(resultMinus.getBaseValue('bigint')).toBe(-1000000000n);
     });
   });
 
@@ -139,36 +218,36 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber(0.5);
       const result = skNumber1.mul(skNumber2, skNumber3);
 
-      expect(result.value).toBe('25');
-      expect(result.bigIntValue).toBe(2500000000n);
+      expect(result.getValue('string')).toBe('25');
+      expect(result.getBaseValue('bigint')).toBe(2500000000n);
     });
 
     test('multiplies different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
       const result = skNumber1.mul(6, '0.5');
 
-      expect(result.value).toBe('30');
-      expect(result.bigIntValue).toBe(3000000000n);
+      expect(result.getValue('string')).toBe('30');
+      expect(result.getBaseValue('bigint')).toBe(3000000000n);
     });
 
     test('multiplies numbers correctly if decimals of SKN is lower than number multiplied with', () => {
       const skNumber1 = new SwapKitNumber({ value: 1000000, decimal: 4 });
       const result = skNumber1.mul('0.00001');
 
-      expect(result.value).toBe('10');
-      expect(result.bigIntValue).toBe(1000000000n);
+      expect(result.getValue('string')).toBe('10');
+      expect(result.getBaseValue('bigint')).toBe(100000n);
     });
 
     test('should correctly round the result of multiplication', () => {
-      const skNumber1 = new SwapKitNumber({ decimal: 2, value: 1.23 });
+      const skNumber1 = new SwapKitNumber({ decimal: 3, value: 1.23 });
       const skNumber2 = new SwapKitNumber({ decimal: 4, value: 4.56 });
 
       const result = skNumber1.mul(skNumber2);
 
       // The exact result of 1.23 * 4.56 is 5.6088
       // If we round it to 2 decimal places, we should get 5.61
-      expect(result.value).toBe('5.61');
-      expect(result.bigIntValue).toBe(560880000n);
+      expect(result.getValue('string')).toBe('5.609');
+      expect(result.getBaseValue('bigint')).toBe(5608n);
 
       const skNumber3 = new SwapKitNumber({ decimal: 2, value: 1.23 });
       const skNumber4 = new SwapKitNumber(-1.234567891);
@@ -177,8 +256,8 @@ describe('SwapKitNumber', () => {
 
       // The exact result of 1.23 * -1.234567891 is -1,518518505
       // If we round it to 2 decimal places, we should get 5.61
-      expect(result2.value).toBe('-1.52');
-      expect(result2.bigIntValue).toBe(-1518518505n);
+      expect(result2.getValue('string')).toBe('-1.52');
+      expect(result2.getBaseValue('bigint')).toBe(-151n);
     });
   });
 
@@ -189,38 +268,38 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber(0.5);
       const result = skNumber1.div(skNumber2, skNumber3);
 
-      expect(result.value).toBe('4');
-      expect(result.bigIntValue).toBe(400000000n);
+      expect(result.getValue('string')).toBe('4');
+      expect(result.getBaseValue('bigint')).toBe(400000000n);
 
       const skNumber4 = new SwapKitNumber(10.12);
       const result2 = skNumber4.div(0.0001);
 
-      expect(result2.value).toBe('101200');
-      expect(result2.bigIntValue).toBe(10120000000000n);
+      expect(result2.getValue('string')).toBe('101200');
+      expect(result2.getBaseValue('bigint')).toBe(10120000000000n);
     });
 
     test('divides different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(20);
       const result = skNumber1.div(5, '0.5');
 
-      expect(result.value).toBe('8');
-      expect(result.bigIntValue).toBe(800000000n);
+      expect(result.getValue('string')).toBe('8');
+      expect(result.getBaseValue('bigint')).toBe(800000000n);
     });
 
     test('divides different type numbers correctly when decimal is set', () => {
       const skNumber1 = new SwapKitNumber({ value: '1.2', decimal: 2 });
       const result = skNumber1.div(0.001);
 
-      expect(result.value).toBe('1200');
-      expect(result.bigIntValue).toBe(120000000000n);
+      expect(result.getValue('string')).toBe('1200');
+      expect(result.getBaseValue('bigint')).toBe(120000n);
     });
 
     test('divides smaller number by larger number', () => {
       const skNumber1 = new SwapKitNumber(1);
       const result = skNumber1.div(2);
 
-      expect(result.value).toBe('0.5');
-      expect(result.bigIntValue).toBe(50000000n);
+      expect(result.getValue('string')).toBe('0.5');
+      expect(result.getBaseValue('bigint')).toBe(50000000n);
     });
 
     test('divides a number with 18 decimals by a negative number with less decimals', () => {
@@ -230,8 +309,8 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(skNumber2);
 
       // The exact result of 1.000000000000000010 / -2 is -0.500000000000000005
-      expect(result.value).toBe('-0.500000000000000005');
-      expect(result.bigIntValue).toBe(-500000000000000005n);
+      expect(result.getValue('string')).toBe('-0.500000000000000005');
+      expect(result.getBaseValue('bigint')).toBe(-500000000000000005n);
     });
 
     test('divides a number with 2 decimals by a negative number with more decimals', () => {
@@ -241,8 +320,8 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(skNumber2);
 
       // The exact result of 2 / -0.000005 is -400000
-      expect(result.value).toBe('-400000');
-      expect(result.bigIntValue).toBe(-40000000000000n);
+      expect(result.getValue('string')).toBe('-400000');
+      expect(result.getBaseValue('bigint')).toBe(-40000000n);
     });
   });
 
@@ -252,8 +331,8 @@ describe('SwapKitNumber', () => {
       const skNumber2 = new SwapKitNumber({ value: 987_654_321_000, decimal: 18 });
 
       const result = skNumber1.mul(skNumber2);
-      expect(result.value).toBe('987654321000000987654321000');
-      expect(result.bigIntValue).toBe(987654321000000987654321000000000000000000000n);
+      expect(result.getValue('string')).toBe('987654321000000987654321000');
+      expect(result.getBaseValue('bigint')).toBe(987654321000000987654321000000000000000000000n);
     });
 
     test('divide huge numbers', () => {
@@ -261,8 +340,8 @@ describe('SwapKitNumber', () => {
       const skNumber2 = new SwapKitNumber({ value: 987_654_321_000, decimal: 18 });
 
       const result = skNumber1.div(skNumber2);
-      expect(result.value).toBe('1012.4999999873447625');
-      expect(result.bigIntValue).toBe(1012499999987344762500n);
+      expect(result.getValue('string')).toBe('1012.4999999873447625');
+      expect(result.getBaseValue('bigint')).toBe(1012499999987344762500n);
     });
   });
 

package/src/modules/assetValue.ts

@@ -59,6 +59,52 @@ const createAssetValue = async (assetString: string, value: number | string = 0)
 };
 
 export class AssetValue extends BigIntArithmetics {
+  address?: string;
+  chain: Chain;
+  isSynthetic = false;
+  isGasAsset = false;
+  symbol: string;
+  ticker: string;
+  type: ReturnType<typeof getAssetType>;
+
+  constructor(params: AssetValueParams) {
+    super(
+      params.value instanceof BigIntArithmetics
+        ? params.value
+        : { decimal: params.decimal, value: params.value },
+    );
+
+    const identifier =
+      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
+    const assetInfo = getAssetInfo(identifier);
+
+    this.type = getAssetType(assetInfo);
+    this.chain = assetInfo.chain;
+    this.ticker = assetInfo.ticker;
+    this.symbol = assetInfo.symbol;
+    this.address = assetInfo.address;
+    this.isSynthetic = assetInfo.isSynthetic;
+    this.isGasAsset = assetInfo.isGasAsset;
+  }
+
+  get assetValue() {
+    return `${this.getValue('string')} ${this.ticker}`;
+  }
+
+  toString(short = false) {
+    // THOR.RUNE | ETH/ETH
+    const shortFormat = this.isSynthetic ? this.ticker : `${this.chain}.${this.ticker}`;
+
+    return short
+      ? shortFormat
+      : // THOR.ETH/ETH | ETH.USDT-0x1234567890
+        `${this.chain}.${this.symbol}`;
+  }
+
+  eq({ chain, symbol }: { chain: Chain; symbol: string }) {
+    return this.chain === chain && this.symbol === symbol;
+  }
+
   static async fromString(assetString: string, value: number | string = 0) {
     return createAssetValue(assetString, value);
   }
@@ -149,46 +195,6 @@ export class AssetValue extends BigIntArithmetics {
       },
     );
   }
-
-  address?: string;
-  chain: Chain;
-  isSynthetic = false;
-  isGasAsset = false;
-  symbol: string;
-  ticker: string;
-  type: ReturnType<typeof getAssetType>;
-
-  constructor(params: AssetValueParams) {
-    super(
-      params.value instanceof BigIntArithmetics
-        ? params.value
-        : { decimal: params.decimal, value: params.value },
-    );
-
-    const identifier =
-      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
-    const assetInfo = getAssetInfo(identifier);
-
-    this.type = getAssetType(assetInfo);
-    this.chain = assetInfo.chain;
-    this.ticker = assetInfo.ticker;
-    this.symbol = assetInfo.symbol;
-    this.address = assetInfo.address;
-    this.isSynthetic = assetInfo.isSynthetic;
-    this.isGasAsset = assetInfo.isGasAsset;
-  }
-
-  get assetValue() {
-    return `${this.value} ${this.ticker}`;
-  }
-
-  toString() {
-    return `${this.chain}.${this.symbol}`;
-  }
-
-  eq({ chain, symbol }: { chain: Chain; symbol: string }) {
-    return this.chain === chain && this.symbol === symbol;
-  }
 }
 
 export const getMinAmountByChain = (chain: Chain) => {