@swapkit/helpers 1.0.0-rc.2 → 1.0.0-rc.21

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

@@ -6,62 +6,65 @@ 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,
-        from: 6,
-        to: 8,
+        from: 8,
+        to: 6,
       });
 
-      expect(shiftedSkNumber.value).toBe('100');
-      expect(shiftedSkNumber.bigIntValue).toBe(10000000000n);
+      expect(shiftedSkNumber.getValue('string')).toBe('1');
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(1000000n);
     });
 
-    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,131 @@ 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);
+    });
+
+    test('shift eth from 18 to 8', () => {
+      const skNumber = new SwapKitNumber({ value: '0.2', decimal: 18 });
+
+      const shiftedSkNumber = SwapKitNumber.shiftDecimals({
+        value: skNumber,
+        from: 18,
+        to: 8,
+      });
+
+      expect(shiftedSkNumber.getValue('string')).toBe('0.2');
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(20000000n);
+    });
+  });
+
+  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');
+      });
+    });
+  });
+
+  describe('toAbbreviation', () => {
+    test('returns abbreviation with up to 3 integer digits', () => {
+      const skNumber = new SwapKitNumber(1234.5678);
+      expect(skNumber.toAbbreviation()).toBe('1.23K');
+
+      const skNumber2 = new SwapKitNumber(1234567.5678);
+      expect(skNumber2.toAbbreviation()).toBe('1.23M');
+
+      const skNumber3 = new SwapKitNumber(1234567890.5678);
+      expect(skNumber3.toAbbreviation()).toBe('1.23B');
+
+      const skNumber4 = new SwapKitNumber(1234567890123.5678);
+      expect(skNumber4.toAbbreviation()).toBe('1.23T');
+
+      const skNumber5 = new SwapKitNumber(1234567890123456.5678);
+      expect(skNumber5.toAbbreviation()).toBe('1.23Q');
+
+      const skNumber6 = new SwapKitNumber(1234567890123456789.5678);
+      expect(skNumber6.toAbbreviation()).toBe('1.23Qi');
+
+      const skNumber7 = new SwapKitNumber(1234567890123456789012.5678);
+      expect(skNumber7.toAbbreviation()).toBe('1.23S');
+
+      const skNumber8 = new SwapKitNumber(1234.5678);
+      expect(skNumber8.toAbbreviation(0)).toBe('1K');
+
+      const skNumber9 = new SwapKitNumber(1234.5678);
+      expect(skNumber9.toAbbreviation(1)).toBe('1.2K');
+
+      const skNumber10 = new SwapKitNumber(123456.78);
+      expect(skNumber10.toAbbreviation()).toBe('123.46K');
     });
   });
 
@@ -81,23 +207,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 +234,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 +251,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 +265,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 +303,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 +315,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 +356,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 +367,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 +378,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 +387,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);
     });
   });