feat: convert numbers

Author: Ho3einWave

src/index.ts

@@ -1 +1,8 @@
+// Client
 export * from './core/client';
+
+// Utils
+export * from './utils/index';
+
+// Types
+export type * from './types/index';

src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './assets';
+export * from './client';
+export * from './router';
+export * from './swap';

src/utils/convert.test.ts

@@ -0,0 +1,79 @@
+import { test, describe, expect } from 'bun:test';
+import { fromNano, toNano } from './convert';
+
+const stringCases: { nano: string; real: string }[] = [
+    { real: '1', nano: '1000000000' },
+    { real: '10', nano: '10000000000' },
+    { real: '0.1', nano: '100000000' },
+    { real: '0.33', nano: '330000000' },
+    { real: '0.000000001', nano: '1' },
+    { real: '10.000000001', nano: '10000000001' },
+    { real: '1000000.000000001', nano: '1000000000000001' },
+    { real: '100000000000', nano: '100000000000000000000' },
+];
+
+const numberCases: { nano: string; real: number }[] = [
+    { real: -0, nano: '0' },
+    { real: 0, nano: '0' },
+    {
+        real: 1e64,
+        nano: '10000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+    { real: 1, nano: '1000000000' },
+    { real: 10, nano: '10000000000' },
+    { real: 0.1, nano: '100000000' },
+    { real: 0.33, nano: '330000000' },
+    { real: 0.000000001, nano: '1' },
+    { real: 10.000000001, nano: '10000000001' },
+    { real: 1000000.000000001, nano: '1000000000000001' },
+    { real: 100000000000, nano: '100000000000000000000' },
+];
+
+test('convert numbers', () => {});
+
+describe('Convert numbers', () => {
+    test('should throw an error for NaN', () => {
+        expect(() => toNano(NaN)).toThrow();
+    });
+
+    test('should throw an error for Infinity', () => {
+        expect(() => toNano(Infinity)).toThrow();
+    });
+
+    test('should throw an error for -Infinity', () => {
+        expect(() => toNano(-Infinity)).toThrow();
+    });
+
+    test('should throw an error due to insufficient precision of number', () => {
+        expect(() => toNano(10000000.000000001)).toThrow();
+    });
+
+    test('should convert numbers toNano', () => {
+        for (let r of numberCases) {
+            let c = toNano(r.real);
+            expect(c).toBe(BigInt(r.nano));
+        }
+    });
+
+    test('should convert strings toNano', () => {
+        for (let r of stringCases) {
+            let c = toNano(r.real);
+            expect(c).toBe(BigInt(r.nano));
+        }
+    });
+
+    test('should convert with custom decimals', () => {
+        expect(toNano(1, 6)).toEqual(1000000n);
+    });
+
+    test('should convert fromNano', () => {
+        for (let r of stringCases) {
+            let c = fromNano(r.nano);
+            expect(c).toEqual(r.real);
+        }
+    });
+
+    test('should convert fromNano with custom decimals', () => {
+        expect(fromNano(1000000, 6)).toEqual('1');
+    });
+});

src/utils/convert.ts

@@ -0,0 +1,87 @@
+export function toNano(src: number | string | bigint, decimals: number = 9): bigint {
+    if (typeof src === 'bigint') {
+        return src * 10n ** BigInt(decimals);
+    } else {
+        if (typeof src === 'number') {
+            if (!Number.isFinite(src)) {
+                throw Error('Invalid number');
+            }
+
+            if (Math.log10(src) <= 6) {
+                src = src.toLocaleString('en', { minimumFractionDigits: 9, useGrouping: false });
+            } else if (src - Math.trunc(src) === 0) {
+                src = src.toLocaleString('en', { maximumFractionDigits: 0, useGrouping: false });
+            } else {
+                throw Error('Not enough precision for a number value. Use string value instead');
+            }
+        }
+
+        // Check sign
+        let neg = false;
+        while (src.startsWith('-')) {
+            neg = !neg;
+            src = src.slice(1);
+        }
+
+        // Split string
+        if (src === '.') {
+            throw Error('Invalid number');
+        }
+        let parts = src.split('.');
+        if (parts.length > 2) {
+            throw Error('Invalid number');
+        }
+
+        // Prepare parts
+        let whole = parts[0];
+        let frac = parts[1];
+        if (!whole) {
+            whole = '0';
+        }
+        if (!frac) {
+            frac = '0';
+        }
+        if (frac.length > 9) {
+            throw Error('Invalid number');
+        }
+        while (frac.length < 9) {
+            frac += '0';
+        }
+
+        // Convert
+        let r = BigInt(whole) * 10n ** BigInt(decimals) + BigInt(frac);
+        if (neg) {
+            r = -r;
+        }
+        return r;
+    }
+}
+
+export function fromNano(src: bigint | number | string, decimals: number = 9) {
+    let v = BigInt(src);
+    let neg = false;
+    if (v < 0) {
+        neg = true;
+        v = -v;
+    }
+
+    // Convert fraction
+    let frac = v % 10n ** BigInt(decimals);
+    let facStr = frac.toString();
+    while (facStr.length < 9) {
+        facStr = '0' + facStr;
+    }
+    facStr = facStr.match(/^([0-9]*[1-9]|0)(0*)/)![1];
+
+    // Convert whole
+    let whole = v / 10n ** BigInt(decimals);
+    let wholeStr = whole.toString();
+
+    // Value
+    let value = `${wholeStr}${facStr === '0' ? '' : `.${facStr}`}`;
+    if (neg) {
+        value = '-' + value;
+    }
+
+    return value;
+}

src/utils/index.ts

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