@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/lib/factory/bigNum.js

@@ -10,6 +10,13 @@ class BigNum {
         this.val = new anchor_1.BN(val);
         this.precision = new anchor_1.BN(precisionVal);
     }
+    static setLocale(locale) {
+        BigNum.delim = (1.1).toLocaleString(locale).slice(1, 2) || '.';
+        BigNum.spacer = (1000).toLocaleString(locale).slice(1, 2) || ',';
+    }
+    bigNumFromParam(bn) {
+        return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
+    }
     add(bn) {
         (0, assert_1.assert)(bn.precision.eq(this.precision), 'Adding unequal precisions');
         return BigNum.from(this.val.add(bn.val), this.precision);
@@ -19,7 +26,7 @@ class BigNum {
         return BigNum.from(this.val.sub(bn.val), this.precision);
     }
     mul(bn) {
-        const mulVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const mulVal = this.bigNumFromParam(bn);
         return BigNum.from(this.val.mul(mulVal.val), this.precision.add(mulVal.precision));
     }
     /**
@@ -28,12 +35,12 @@ class BigNum {
      * @returns
      */
     scalarMul(bn) {
-        if (bn instanceof anchor_1.BN)
+        if (anchor_1.BN.isBN(bn))
             return BigNum.from(this.val.mul(bn), this.precision);
         return BigNum.from(this.val.mul(bn.val), this.precision.add(bn.precision)).shift(bn.precision.neg());
     }
     div(bn) {
-        if (bn instanceof anchor_1.BN)
+        if (anchor_1.BN.isBN(bn))
             return BigNum.from(this.val.div(bn), this.precision);
         return BigNum.from(this.val.div(bn.val), this.precision.sub(bn.precision));
     }
@@ -73,35 +80,35 @@ class BigNum {
             .toPrecision(precision);
     }
     gt(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.gt(comparisonVal.val);
     }
     lt(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.lt(comparisonVal.val);
     }
     gte(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.gte(comparisonVal.val);
     }
     lte(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
         return this.val.lte(comparisonVal.val);
     }
     eq(bn, ignorePrecision) {
-        const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+        const comparisonVal = this.bigNumFromParam(bn);
         if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
             (0, assert_1.assert)(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
         }
@@ -134,7 +141,8 @@ class BigNum {
      */
     print() {
         (0, assert_1.assert)(this.precision.gte(numericConstants_1.ZERO), 'Tried to print a BN with precision lower than zero');
-        const plainString = this.toString();
+        const isNeg = this.isNeg();
+        const plainString = this.abs().toString();
         const precisionNum = this.precision.toNumber();
         // make a string with at least the precisionNum number of zeroes
         let printString = [
@@ -151,6 +159,9 @@ class BigNum {
         // add zero if leading delim
         if (printString[0] === BigNum.delim)
             printString = `0${printString}`;
+        // Add minus if negative
+        if (isNeg)
+            printString = `-${printString}`;
         // remove trailing delim
         if (printString[printString.length - 1] === BigNum.delim)
             printString = printString.slice(0, printString.length - 1);
@@ -182,6 +193,8 @@ class BigNum {
             : useTradePrecision
                 ? this.toTradePrecision()
                 : this.print();
+        if (!printVal.includes(BigNum.delim))
+            return printVal;
         return printVal.replace(/0+$/g, '').replace(/\.$/, '').replace(/,$/, '');
     }
     debug() {
@@ -192,7 +205,10 @@ class BigNum {
      * @param fixedPrecision
      * @returns
      */
-    toFixed(fixedPrecision) {
+    toFixed(fixedPrecision, rounded = false) {
+        if (rounded) {
+            return this.toRounded(fixedPrecision).toFixed(fixedPrecision);
+        }
         const printString = this.print();
         const [leftSide, rightSide] = printString.split(BigNum.delim);
         const filledRightSide = [
@@ -203,14 +219,47 @@ class BigNum {
             .join('');
         return `${leftSide}${BigNum.delim}${filledRightSide}`;
     }
+    getZeroes(count) {
+        return new Array(Math.max(count, 0)).fill('0').join('');
+    }
+    toRounded(roundingPrecision) {
+        const printString = this.toString();
+        let shouldRoundUp = false;
+        const roundingDigitChar = printString[roundingPrecision];
+        if (roundingDigitChar) {
+            const roundingDigitVal = Number(roundingDigitChar);
+            if (roundingDigitVal >= 5)
+                shouldRoundUp = true;
+        }
+        if (shouldRoundUp) {
+            const valueWithRoundedPrecisionAdded = this.add(BigNum.from(new anchor_1.BN(10).pow(new anchor_1.BN(printString.length - roundingPrecision)), this.precision));
+            const roundedUpPrintString = valueWithRoundedPrecisionAdded.toString().slice(0, roundingPrecision) +
+                this.getZeroes(printString.length - roundingPrecision);
+            return BigNum.from(roundedUpPrintString, this.precision);
+        }
+        else {
+            const roundedDownPrintString = printString.slice(0, roundingPrecision) +
+                this.getZeroes(printString.length - roundingPrecision);
+            return BigNum.from(roundedDownPrintString, this.precision);
+        }
+    }
     /**
      * Pretty print to the specified number of significant figures
      * @param fixedPrecision
      * @returns
      */
-    toPrecision(fixedPrecision, trailingZeroes = false) {
+    toPrecision(fixedPrecision, trailingZeroes = false, rounded = false) {
+        if (rounded) {
+            return this.toRounded(fixedPrecision).toPrecision(fixedPrecision, trailingZeroes);
+        }
         const printString = this.print();
         let precisionPrintString = printString.slice(0, fixedPrecision + 1);
+        const thisString = this.toString();
+        if (!printString.includes(BigNum.delim) &&
+            thisString.length < fixedPrecision) {
+            const precisionMismatch = fixedPrecision - thisString.length;
+            return BigNum.from(thisString + this.getZeroes(precisionMismatch), precisionMismatch).toPrecision(fixedPrecision, trailingZeroes);
+        }
         if (!precisionPrintString.includes(BigNum.delim) ||
             precisionPrintString[precisionPrintString.length - 1] === BigNum.delim) {
             precisionPrintString = printString.slice(0, fixedPrecision);
@@ -251,8 +300,8 @@ class BigNum {
         }
         return precisionPrintString;
     }
-    toTradePrecision() {
-        return this.toPrecision(6, true);
+    toTradePrecision(rounded = false) {
+        return this.toPrecision(6, true, rounded);
     }
     /**
      * Print dollar formatted value. Defaults to fixed decimals two unless a given precision is given.
@@ -261,18 +310,41 @@ class BigNum {
      * @returns
      */
     toNotional(useTradePrecision, precisionOverride) {
+        var _a;
         const prefix = `${this.lt(BigNum.zero()) ? `-` : ``}$`;
-        const val = useTradePrecision || precisionOverride
+        const usingCustomPrecision = true && (useTradePrecision || precisionOverride);
+        let val = usingCustomPrecision
             ? this.prettyPrint(useTradePrecision, precisionOverride)
             : BigNum.fromPrint(this.toFixed(2), new anchor_1.BN(2)).prettyPrint();
+        // Append two trailing zeroes if not using custom precision
+        if (!usingCustomPrecision) {
+            const [_, rightSide] = val.split(BigNum.delim);
+            const trailingLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
+            if (trailingLength < 2) {
+                const numHasDecimals = this.print().includes(BigNum.delim);
+                // Handle case where pretty print won't include the decimal point
+                if (trailingLength === 0 && numHasDecimals) {
+                    val = `${val}.00`;
+                }
+                else {
+                    val = `${val}${new Array(2 - trailingLength).fill('0').join('')}`;
+                }
+            }
+        }
         return `${prefix}${val.replace('-', '')}`;
     }
-    toMillified(precision = 3) {
+    toMillified(precision = 3, rounded = false) {
+        if (rounded) {
+            return this.toRounded(precision).toMillified(precision);
+        }
         const stringVal = this.print();
         const [leftSide] = stringVal.split(BigNum.delim);
         if (!leftSide) {
             return this.shift(new anchor_1.BN(precision)).toPrecision(precision, true);
         }
+        if (leftSide.length <= precision) {
+            return this.toPrecision(precision);
+        }
         if (leftSide.length <= 3) {
             return this.shift(new anchor_1.BN(precision)).toPrecision(precision, true);
         }
@@ -313,7 +385,21 @@ class BigNum {
      * @returns
      */
     toNum() {
-        return parseFloat(this.print());
+        let printedValue = this.print();
+        // Must convert any non-US delimiters and spacers to US format before using parseFloat
+        if (BigNum.delim !== '.' || BigNum.spacer !== ',') {
+            printedValue = printedValue
+                .split('')
+                .map((char) => {
+                if (char === BigNum.delim)
+                    return '.';
+                if (char === BigNum.spacer)
+                    return ',';
+                return char;
+            })
+                .join('');
+        }
+        return parseFloat(printedValue);
     }
     static fromJSON(json) {
         return BigNum.from(new anchor_1.BN(json.val), new anchor_1.BN(json.precision));
@@ -339,10 +425,14 @@ class BigNum {
         // Handle empty number edge cases
         if (!val)
             return BigNum.from(numericConstants_1.ZERO, precisionShift);
-        if (!val.replace(BigNum.delim, ''))
+        if (!val.replace(BigNum.delim, '')) {
             return BigNum.from(numericConstants_1.ZERO, precisionShift);
-        const [leftSide, rightSide] = val.split(BigNum.delim);
-        const rawBn = new anchor_1.BN(`${leftSide !== null && leftSide !== void 0 ? leftSide : ''}${rightSide !== null && rightSide !== void 0 ? rightSide : ''}`);
+        }
+        const sides = val.split(BigNum.delim);
+        const rightSide = sides[1];
+        const leftSide = sides[0].replace(/\D/g, '');
+        const bnInput = `${leftSide !== null && leftSide !== void 0 ? leftSide : ''}${rightSide !== null && rightSide !== void 0 ? rightSide : ''}`;
+        const rawBn = new anchor_1.BN(bnInput);
         const rightSideLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
         const totalShift = precisionShift
             ? precisionShift.sub(new anchor_1.BN(rightSideLength))