@drift-labs/sdk 0.2.0-master.26 → 0.2.0-master.27

package/src/factory/bigNum.js

@@ -1,161 +1,149 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.BigNum = void 0;
-var anchor_1 = require("@project-serum/anchor");
-var assert_1 = require("../assert/assert");
-var numericConstants_1 = require("./../constants/numericConstants");
-var BigNum = /** @class */ (function () {
-    function BigNum(val, precisionVal) {
-        var _this = this;
-        if (precisionVal === void 0) { precisionVal = new anchor_1.BN(0); }
-        this.toString = function (base, length) {
-            return _this.val.toString(base, length);
-        };
+const anchor_1 = require("@project-serum/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("./../constants/numericConstants");
+class BigNum {
+    constructor(val, precisionVal = new anchor_1.BN(0)) {
+        this.toString = (base, length) => this.val.toString(base, length);
         this.val = new anchor_1.BN(val);
         this.precision = new anchor_1.BN(precisionVal);
     }
-    BigNum.prototype.bigNumFromParam = function (bn) {
+    bigNumFromParam(bn) {
         return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
-    };
-    BigNum.prototype.add = function (bn) {
-        (0, assert_1.assert)(bn.precision.eq(this.precision), 'Adding unequal precisions');
+    }
+    add(bn) {
+        assert_1.assert(bn.precision.eq(this.precision), 'Adding unequal precisions');
         return BigNum.from(this.val.add(bn.val), this.precision);
-    };
-    BigNum.prototype.sub = function (bn) {
-        (0, assert_1.assert)(bn.precision.eq(this.precision), 'Subtracting unequal precisions');
+    }
+    sub(bn) {
+        assert_1.assert(bn.precision.eq(this.precision), 'Subtracting unequal precisions');
         return BigNum.from(this.val.sub(bn.val), this.precision);
-    };
-    BigNum.prototype.mul = function (bn) {
-        var mulVal = this.bigNumFromParam(bn);
+    }
+    mul(bn) {
+        const mulVal = this.bigNumFromParam(bn);
         return BigNum.from(this.val.mul(mulVal.val), this.precision.add(mulVal.precision));
-    };
+    }
     /**
      * Multiplies by another big number then scales the result down by the big number's precision so that we're in the same precision space
      * @param bn
      * @returns
      */
-    BigNum.prototype.scalarMul = function (bn) {
+    scalarMul(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());
-    };
-    BigNum.prototype.div = function (bn) {
+    }
+    div(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));
-    };
+    }
     /**
      * Shift precision up or down
      * @param exponent
      * @param skipAdjustingPrecision
      * @returns
      */
-    BigNum.prototype.shift = function (exponent, skipAdjustingPrecision) {
-        if (skipAdjustingPrecision === void 0) { skipAdjustingPrecision = false; }
-        var shiftVal = typeof exponent === 'number' ? new anchor_1.BN(exponent) : exponent;
+    shift(exponent, skipAdjustingPrecision = false) {
+        const shiftVal = typeof exponent === 'number' ? new anchor_1.BN(exponent) : exponent;
         return BigNum.from(shiftVal.isNeg()
             ? this.val.div(new anchor_1.BN(10).pow(shiftVal))
             : this.val.mul(new anchor_1.BN(10).pow(shiftVal)), skipAdjustingPrecision ? this.precision : this.precision.add(shiftVal));
-    };
+    }
     /**
      * Shift to a target precision
      * @param targetPrecision
      * @returns
      */
-    BigNum.prototype.shiftTo = function (targetPrecision) {
+    shiftTo(targetPrecision) {
         return this.shift(targetPrecision.sub(this.precision));
-    };
+    }
     /**
      * Scale the number by a fraction
      * @param numerator
      * @param denominator
      * @returns
      */
-    BigNum.prototype.scale = function (numerator, denominator) {
+    scale(numerator, denominator) {
         return this.mul(BigNum.from(new anchor_1.BN(numerator))).div(new anchor_1.BN(denominator));
-    };
-    BigNum.prototype.toPercentage = function (denominator, precision) {
+    }
+    toPercentage(denominator, precision) {
         return this.shift(precision)
             .shift(2, true)
             .div(denominator)
             .toPrecision(precision);
-    };
-    BigNum.prototype.gt = function (bn, ignorePrecision) {
-        var comparisonVal = this.bigNumFromParam(bn);
+    }
+    gt(bn, ignorePrecision) {
+        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');
+            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);
-    };
-    BigNum.prototype.lt = function (bn, ignorePrecision) {
-        var comparisonVal = this.bigNumFromParam(bn);
+    }
+    lt(bn, ignorePrecision) {
+        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');
+            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);
-    };
-    BigNum.prototype.gte = function (bn, ignorePrecision) {
-        var comparisonVal = this.bigNumFromParam(bn);
+    }
+    gte(bn, ignorePrecision) {
+        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');
+            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);
-    };
-    BigNum.prototype.lte = function (bn, ignorePrecision) {
-        var comparisonVal = this.bigNumFromParam(bn);
+    }
+    lte(bn, ignorePrecision) {
+        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');
+            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);
-    };
-    BigNum.prototype.eq = function (bn, ignorePrecision) {
-        var comparisonVal = this.bigNumFromParam(bn);
+    }
+    eq(bn, ignorePrecision) {
+        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');
+            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.eq(comparisonVal.val);
-    };
-    BigNum.prototype.eqZero = function () {
+    }
+    eqZero() {
         return this.val.eq(numericConstants_1.ZERO);
-    };
-    BigNum.prototype.gtZero = function () {
+    }
+    gtZero() {
         return this.val.gt(numericConstants_1.ZERO);
-    };
-    BigNum.prototype.ltZero = function () {
+    }
+    ltZero() {
         return this.val.lt(numericConstants_1.ZERO);
-    };
-    BigNum.prototype.gteZero = function () {
+    }
+    gteZero() {
         return this.val.gte(numericConstants_1.ZERO);
-    };
-    BigNum.prototype.lteZero = function () {
+    }
+    lteZero() {
         return this.val.lte(numericConstants_1.ZERO);
-    };
-    BigNum.prototype.abs = function () {
+    }
+    abs() {
         return new BigNum(this.val.abs(), this.precision);
-    };
-    BigNum.prototype.neg = function () {
+    }
+    neg() {
         return new BigNum(this.val.neg(), this.precision);
-    };
+    }
     /**
      * Pretty print the underlying value in human-readable form. Depends on precision being correct for the output string to be correct
      * @returns
      */
-    BigNum.prototype.print = function () {
-        (0, assert_1.assert)(this.precision.gte(numericConstants_1.ZERO), 'Tried to print a BN with precision lower than zero');
-        var isNeg = this.isNeg();
-        var plainString = this.abs().toString();
-        var precisionNum = this.precision.toNumber();
+    print() {
+        assert_1.assert(this.precision.gte(numericConstants_1.ZERO), 'Tried to print a BN with precision lower than zero');
+        const plainString = this.toString();
+        const precisionNum = this.precision.toNumber();
         // make a string with at least the precisionNum number of zeroes
-        var printString = __spreadArray(__spreadArray([], Array(this.precision.toNumber()).fill(0), true), plainString.split(''), true).join('');
+        let printString = [
+            ...Array(this.precision.toNumber()).fill(0),
+            ...plainString.split(''),
+        ].join('');
         // inject decimal
         printString =
             printString.substring(0, printString.length - precisionNum) +
@@ -164,79 +152,88 @@ var BigNum = /** @class */ (function () {
         // remove leading zeroes
         printString = printString.replace(/^0+/, '');
         // add zero if leading delim
-        if (printString[0] === BigNum.delim)
-            printString = "0".concat(printString);
-        // Add minus if negative
-        if (isNeg)
-            printString = "-".concat(printString);
+        if (this.isNeg()) {
+            if (printString[1] === BigNum.delim)
+                printString = printString.replace('-.', '-0.');
+        }
+        else {
+            if (printString[0] === BigNum.delim)
+                printString = `0${printString}`;
+        }
         // remove trailing delim
         if (printString[printString.length - 1] === BigNum.delim)
             printString = printString.slice(0, printString.length - 1);
         return printString;
-    };
-    BigNum.prototype.prettyPrint = function (useTradePrecision, precisionOverride) {
-        var _a = this.printShort(useTradePrecision, precisionOverride).split(BigNum.delim), leftSide = _a[0], rightSide = _a[1];
-        var formattedLeftSide = leftSide;
-        var isNeg = formattedLeftSide.includes('-');
+    }
+    prettyPrint(useTradePrecision, precisionOverride) {
+        const [leftSide, rightSide] = this.printShort(useTradePrecision, precisionOverride).split(BigNum.delim);
+        let formattedLeftSide = leftSide;
+        const isNeg = formattedLeftSide.includes('-');
         if (isNeg) {
             formattedLeftSide = formattedLeftSide.replace('-', '');
         }
-        var index = formattedLeftSide.length - 3;
+        let index = formattedLeftSide.length - 3;
         while (index >= 1) {
-            var formattedLeftSideArray = formattedLeftSide.split('');
+            const formattedLeftSideArray = formattedLeftSide.split('');
             formattedLeftSideArray.splice(index, 0, BigNum.spacer);
             formattedLeftSide = formattedLeftSideArray.join('');
             index -= 3;
         }
-        return "".concat(isNeg ? '-' : '').concat(formattedLeftSide).concat(rightSide ? "".concat(BigNum.delim).concat(rightSide) : '');
-    };
+        return `${isNeg ? '-' : ''}${formattedLeftSide}${rightSide ? `${BigNum.delim}${rightSide}` : ''}`;
+    }
     /**
      * Print and remove unnecessary trailing zeroes
      * @returns
      */
-    BigNum.prototype.printShort = function (useTradePrecision, precisionOverride) {
-        var printVal = precisionOverride
+    printShort(useTradePrecision, precisionOverride) {
+        const printVal = precisionOverride
             ? this.toPrecision(precisionOverride)
             : useTradePrecision
                 ? this.toTradePrecision()
                 : this.print();
         return printVal.replace(/0+$/g, '').replace(/\.$/, '').replace(/,$/, '');
-    };
-    BigNum.prototype.debug = function () {
-        console.log("".concat(this.toString(), " | ").concat(this.print(), " | ").concat(this.precision.toString()));
-    };
+    }
+    debug() {
+        console.log(`${this.toString()} | ${this.print()} | ${this.precision.toString()}`);
+    }
     /**
      * Pretty print with the specified number of decimal places
      * @param fixedPrecision
      * @returns
      */
-    BigNum.prototype.toFixed = function (fixedPrecision) {
-        var printString = this.print();
-        var _a = printString.split(BigNum.delim), leftSide = _a[0], rightSide = _a[1];
-        var filledRightSide = __spreadArray(__spreadArray([], (rightSide !== null && rightSide !== void 0 ? rightSide : '').slice(0, fixedPrecision), true), Array(fixedPrecision).fill('0'), true).slice(0, fixedPrecision)
+    toFixed(fixedPrecision) {
+        const printString = this.print();
+        const [leftSide, rightSide] = printString.split(BigNum.delim);
+        const filledRightSide = [
+            ...(rightSide !== null && rightSide !== void 0 ? rightSide : '').slice(0, fixedPrecision),
+            ...Array(fixedPrecision).fill('0'),
+        ]
+            .slice(0, fixedPrecision)
             .join('');
-        return "".concat(leftSide).concat(BigNum.delim).concat(filledRightSide);
-    };
+        return `${leftSide}${BigNum.delim}${filledRightSide}`;
+    }
     /**
      * Pretty print to the specified number of significant figures
      * @param fixedPrecision
      * @returns
      */
-    BigNum.prototype.toPrecision = function (fixedPrecision, trailingZeroes) {
-        if (trailingZeroes === void 0) { trailingZeroes = false; }
-        var printString = this.print();
-        var precisionPrintString = printString.slice(0, fixedPrecision + 1);
+    toPrecision(fixedPrecision, trailingZeroes = false) {
+        const printString = this.print();
+        let precisionPrintString = printString.slice(0, fixedPrecision + 1);
         if (!precisionPrintString.includes(BigNum.delim) ||
             precisionPrintString[precisionPrintString.length - 1] === BigNum.delim) {
             precisionPrintString = printString.slice(0, fixedPrecision);
         }
-        var pointsOfPrecision = precisionPrintString.replace(BigNum.delim, '').length;
+        const pointsOfPrecision = precisionPrintString.replace(BigNum.delim, '').length;
         if (pointsOfPrecision < fixedPrecision) {
-            precisionPrintString = __spreadArray(__spreadArray([], precisionPrintString.split(''), true), Array(fixedPrecision - pointsOfPrecision).fill('0'), true).join('');
+            precisionPrintString = [
+                ...precisionPrintString.split(''),
+                ...Array(fixedPrecision - pointsOfPrecision).fill('0'),
+            ].join('');
         }
         if (!precisionPrintString.includes(BigNum.delim)) {
-            var delimFullStringLocation = printString.indexOf(BigNum.delim);
-            var skipExponent = false;
+            const delimFullStringLocation = printString.indexOf(BigNum.delim);
+            let skipExponent = false;
             if (delimFullStringLocation === -1) {
                 // no decimal, not missing any precision
                 skipExponent = true;
@@ -250,144 +247,144 @@ var BigNum = /** @class */ (function () {
                 skipExponent = true;
             }
             if (!skipExponent) {
-                var exponent = delimFullStringLocation - fixedPrecision;
+                const exponent = delimFullStringLocation - fixedPrecision;
                 if (trailingZeroes) {
-                    precisionPrintString = "".concat(precisionPrintString).concat(Array(exponent)
+                    precisionPrintString = `${precisionPrintString}${Array(exponent)
                         .fill('0')
-                        .join(''));
+                        .join('')}`;
                 }
                 else {
-                    precisionPrintString = "".concat(precisionPrintString, "e").concat(exponent);
+                    precisionPrintString = `${precisionPrintString}e${exponent}`;
                 }
             }
         }
         return precisionPrintString;
-    };
-    BigNum.prototype.toTradePrecision = function () {
+    }
+    toTradePrecision() {
         return this.toPrecision(6, true);
-    };
+    }
     /**
      * Print dollar formatted value. Defaults to fixed decimals two unless a given precision is given.
      * @param useTradePrecision
      * @param precisionOverride
      * @returns
      */
-    BigNum.prototype.toNotional = function (useTradePrecision, precisionOverride) {
+    toNotional(useTradePrecision, precisionOverride) {
         var _a;
-        var prefix = "".concat(this.lt(BigNum.zero()) ? "-" : "", "$");
-        var usingCustomPrecision = true && (useTradePrecision || precisionOverride);
-        var val = usingCustomPrecision
+        const prefix = `${this.lt(BigNum.zero()) ? `-` : ``}$`;
+        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) {
-            var _b = val.split(BigNum.delim), _1 = _b[0], rightSide = _b[1];
-            var trailingLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
+            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) {
-                var numHasDecimals = this.print().includes(BigNum.delim);
+                const numHasDecimals = this.print().includes(BigNum.delim);
                 // Handle case where pretty print won't include the decimal point
                 if (trailingLength === 0 && numHasDecimals) {
-                    val = "".concat(val, ".00");
+                    val = `${val}.00`;
                 }
                 else {
-                    val = "".concat(val).concat(new Array(2 - trailingLength).fill('0').join(''));
+                    val = `${val}${new Array(2 - trailingLength).fill('0').join('')}`;
                 }
             }
         }
-        return "".concat(prefix).concat(val.replace('-', ''));
-    };
-    BigNum.prototype.toMillified = function (precision) {
-        if (precision === void 0) { precision = 3; }
-        var stringVal = this.print();
-        var leftSide = stringVal.split(BigNum.delim)[0];
+        return `${prefix}${val.replace('-', '')}`;
+    }
+    toMillified(precision = 3) {
+        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 <= 3) {
             return this.shift(new anchor_1.BN(precision)).toPrecision(precision, true);
         }
-        var unitTicks = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
-        var unitNumber = Math.floor((leftSide.length - 1) / 3);
-        var unit = unitTicks[unitNumber];
-        var leadDigits = leftSide.slice(0, precision);
+        const unitTicks = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+        const unitNumber = Math.floor((leftSide.length - 1) / 3);
+        const unit = unitTicks[unitNumber];
+        let leadDigits = leftSide.slice(0, precision);
         if (leadDigits.length < precision) {
-            leadDigits = __spreadArray(__spreadArray([], leadDigits.split(''), true), Array(precision - leadDigits.length).fill('0'), true).join('');
+            leadDigits = [
+                ...leadDigits.split(''),
+                ...Array(precision - leadDigits.length).fill('0'),
+            ].join('');
         }
-        var decimalLocation = leftSide.length - 3 * unitNumber;
-        var leadString = '';
+        const decimalLocation = leftSide.length - 3 * unitNumber;
+        let leadString = '';
         if (decimalLocation >= precision) {
-            leadString = "".concat(leadDigits);
+            leadString = `${leadDigits}`;
         }
         else {
-            leadString = "".concat(leadDigits.slice(0, decimalLocation)).concat(BigNum.delim).concat(leadDigits.slice(decimalLocation));
+            leadString = `${leadDigits.slice(0, decimalLocation)}${BigNum.delim}${leadDigits.slice(decimalLocation)}`;
         }
-        return "".concat(leadString).concat(unit);
-    };
-    BigNum.prototype.toJSON = function () {
+        return `${leadString}${unit}`;
+    }
+    toJSON() {
         return {
             val: this.val.toString(),
-            precision: this.precision.toString()
+            precision: this.precision.toString(),
         };
-    };
-    BigNum.prototype.isNeg = function () {
+    }
+    isNeg() {
         return this.lt(numericConstants_1.ZERO, true);
-    };
-    BigNum.prototype.isPos = function () {
+    }
+    isPos() {
         return !this.isNeg();
-    };
+    }
     /**
      * Get the numerical value of the BigNum. This can break if the BigNum is too large.
      * @returns
      */
-    BigNum.prototype.toNum = function () {
+    toNum() {
         return parseFloat(this.print());
-    };
-    BigNum.fromJSON = function (json) {
+    }
+    static fromJSON(json) {
         return BigNum.from(new anchor_1.BN(json.val), new anchor_1.BN(json.precision));
-    };
+    }
     /**
      * Create a BigNum instance
      * @param val
      * @param precision
      * @returns
      */
-    BigNum.from = function (val, precision) {
-        if (val === void 0) { val = numericConstants_1.ZERO; }
-        (0, assert_1.assert)(new anchor_1.BN(precision).lt(new anchor_1.BN(100)), 'Tried to create a bignum with precision higher than 10^100');
+    static from(val = numericConstants_1.ZERO, precision) {
+        assert_1.assert(new anchor_1.BN(precision).lt(new anchor_1.BN(100)), 'Tried to create a bignum with precision higher than 10^100');
         return new BigNum(val, precision);
-    };
+    }
     /**
      * Create a BigNum instance from a printed BigNum
      * @param val
      * @param precisionOverride
      * @returns
      */
-    BigNum.fromPrint = function (val, precisionShift) {
+    static fromPrint(val, precisionShift) {
         var _a;
         // Handle empty number edge cases
         if (!val)
             return BigNum.from(numericConstants_1.ZERO, precisionShift);
         if (!val.replace(BigNum.delim, ''))
             return BigNum.from(numericConstants_1.ZERO, precisionShift);
-        var _b = val.split(BigNum.delim), leftSide = _b[0], rightSide = _b[1];
-        var rawBn = new anchor_1.BN("".concat(leftSide !== null && leftSide !== void 0 ? leftSide : '').concat(rightSide !== null && rightSide !== void 0 ? rightSide : ''));
-        var rightSideLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
-        var totalShift = 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 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))
             : numericConstants_1.ZERO;
         return BigNum.from(rawBn, precisionShift).shift(totalShift, true);
-    };
-    BigNum.max = function (a, b) {
+    }
+    static max(a, b) {
         return a.gt(b) ? a : b;
-    };
-    BigNum.min = function (a, b) {
+    }
+    static min(a, b) {
         return a.lt(b) ? a : b;
-    };
-    BigNum.zero = function (precision) {
+    }
+    static zero(precision) {
         return BigNum.from(0, precision);
-    };
-    BigNum.delim = '.';
-    BigNum.spacer = ',';
-    return BigNum;
-}());
+    }
+}
 exports.BigNum = BigNum;
+BigNum.delim = '.';
+BigNum.spacer = ',';

package/src/factory/oracleClient.js

@@ -1,20 +1,20 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOracleClient = void 0;
-var types_1 = require("../types");
-var pythClient_1 = require("../oracles/pythClient");
-var switchboardClient_1 = require("../oracles/switchboardClient");
-var quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+const types_1 = require("../types");
+const pythClient_1 = require("../oracles/pythClient");
+const switchboardClient_1 = require("../oracles/switchboardClient");
+const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
 function getOracleClient(oracleSource, connection) {
-    if ((0, types_1.isVariant)(oracleSource, 'pyth')) {
+    if (types_1.isVariant(oracleSource, 'pyth')) {
         return new pythClient_1.PythClient(connection);
     }
-    if ((0, types_1.isVariant)(oracleSource, 'switchboard')) {
+    if (types_1.isVariant(oracleSource, 'switchboard')) {
         return new switchboardClient_1.SwitchboardClient(connection);
     }
-    if ((0, types_1.isVariant)(oracleSource, 'quoteAsset')) {
+    if (types_1.isVariant(oracleSource, 'quoteAsset')) {
         return new quoteAssetOracleClient_1.QuoteAssetOracleClient();
     }
-    throw new Error("Unknown oracle source ".concat(oracleSource));
+    throw new Error(`Unknown oracle source ${oracleSource}`);
 }
 exports.getOracleClient = getOracleClient;