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

package/src/events/eventList.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventList = void 0;
-class Node {
-    constructor(event, next, prev) {
-        this.event = event;
-        this.next = next;
-        this.prev = prev;
-    }
-}
-class EventList {
-    constructor(eventType, maxSize, sortFn, orderDirection) {
-        this.eventType = eventType;
-        this.maxSize = maxSize;
-        this.sortFn = sortFn;
-        this.orderDirection = orderDirection;
-        this.size = 0;
-    }
-    insert(event) {
-        this.size++;
-        const newNode = new Node(event);
-        if (this.head === undefined) {
-            this.head = this.tail = newNode;
-            return;
-        }
-        if (this.sortFn(this.head.event, newNode.event) ===
-            (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
-            this.head.prev = newNode;
-            newNode.next = this.head;
-            this.head = newNode;
-        }
-        else {
-            let currentNode = this.head;
-            while (currentNode.next !== undefined &&
-                this.sortFn(currentNode.next.event, newNode.event) !==
-                    (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
-                currentNode = currentNode.next;
-            }
-            newNode.next = currentNode.next;
-            if (currentNode.next !== undefined) {
-                newNode.next.prev = newNode;
-            }
-            currentNode.next = newNode;
-            newNode.prev = currentNode;
-        }
-        if (this.size > this.maxSize) {
-            this.detach();
-        }
-    }
-    detach() {
-        const node = this.tail;
-        if (node.prev !== undefined) {
-            node.prev.next = node.next;
-        }
-        else {
-            this.head = node.next;
-        }
-        if (node.next !== undefined) {
-            node.next.prev = node.prev;
-        }
-        else {
-            this.tail = node.prev;
-        }
-        this.size--;
-    }
-    toArray() {
-        return Array.from(this);
-    }
-    *[Symbol.iterator]() {
-        let node = this.head;
-        while (node) {
-            yield node.event;
-            node = node.next;
-        }
-    }
-}
-exports.EventList = EventList;

package/src/events/txEventCache.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxEventCache = void 0;
-class Node {
-    constructor(key, value, next, prev) {
-        this.key = key;
-        this.value = value;
-        this.next = next;
-        this.prev = prev;
-    }
-}
-// lru cache
-class TxEventCache {
-    constructor(maxTx = 1024) {
-        this.maxTx = maxTx;
-        this.size = 0;
-        this.cacheMap = {};
-    }
-    add(key, events) {
-        const existingNode = this.cacheMap[key];
-        if (existingNode) {
-            this.detach(existingNode);
-            this.size--;
-        }
-        else if (this.size === this.maxTx) {
-            delete this.cacheMap[this.tail.key];
-            this.detach(this.tail);
-            this.size--;
-        }
-        // Write to head of LinkedList
-        if (!this.head) {
-            this.head = this.tail = new Node(key, events);
-        }
-        else {
-            const node = new Node(key, events, this.head);
-            this.head.prev = node;
-            this.head = node;
-        }
-        // update cacheMap with LinkedList key and Node reference
-        this.cacheMap[key] = this.head;
-        this.size++;
-    }
-    has(key) {
-        return this.cacheMap.hasOwnProperty(key);
-    }
-    get(key) {
-        var _a;
-        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
-    }
-    detach(node) {
-        if (node.prev !== undefined) {
-            node.prev.next = node.next;
-        }
-        else {
-            this.head = node.next;
-        }
-        if (node.next !== undefined) {
-            node.next.prev = node.prev;
-        }
-        else {
-            this.tail = node.prev;
-        }
-    }
-    clear() {
-        this.head = undefined;
-        this.tail = undefined;
-        this.size = 0;
-        this.cacheMap = {};
-    }
-}
-exports.TxEventCache = TxEventCache;

package/src/examples/makeTradeExample.js

@@ -1,157 +0,0 @@
-'use strict';
-var __awaiter =
-	(this && this.__awaiter) ||
-	function (thisArg, _arguments, P, generator) {
-		function adopt(value) {
-			return value instanceof P
-				? value
-				: new P(function (resolve) {
-						resolve(value);
-				  });
-		}
-		return new (P || (P = Promise))(function (resolve, reject) {
-			function fulfilled(value) {
-				try {
-					step(generator.next(value));
-				} catch (e) {
-					reject(e);
-				}
-			}
-			function rejected(value) {
-				try {
-					step(generator['throw'](value));
-				} catch (e) {
-					reject(e);
-				}
-			}
-			function step(result) {
-				result.done
-					? resolve(result.value)
-					: adopt(result.value).then(fulfilled, rejected);
-			}
-			step((generator = generator.apply(thisArg, _arguments || [])).next());
-		});
-	};
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.getTokenAddress = void 0;
-const anchor_1 = require('@project-serum/anchor');
-const __1 = require('..');
-const spl_token_1 = require('@solana/spl-token');
-const web3_js_1 = require('@solana/web3.js');
-const __2 = require('..');
-const banks_1 = require('../constants/spotMarkets');
-const getTokenAddress = (mintAddress, userPubKey) => {
-	return spl_token_1.Token.getAssociatedTokenAddress(
-		new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`),
-		spl_token_1.TOKEN_PROGRAM_ID,
-		new web3_js_1.PublicKey(mintAddress),
-		new web3_js_1.PublicKey(userPubKey)
-	);
-};
-exports.getTokenAddress = getTokenAddress;
-const main = () =>
-	__awaiter(void 0, void 0, void 0, function* () {
-		// Initialize Drift SDK
-		const sdkConfig = __2.initialize({ env: 'devnet' });
-		// Set up the Wallet and Provider
-		const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
-		const keypair = web3_js_1.Keypair.fromSecretKey(
-			Uint8Array.from(JSON.parse(privateKey))
-		);
-		const wallet = new __1.Wallet(keypair);
-		// Set up the Connection
-		const rpcAddress = process.env.RPC_ADDRESS; // can use: https://api.devnet.solana.com for devnet; https://api.mainnet-beta.solana.com for mainnet;
-		const connection = new web3_js_1.Connection(rpcAddress);
-		// Set up the Provider
-		const provider = new anchor_1.AnchorProvider(
-			connection,
-			wallet,
-			anchor_1.AnchorProvider.defaultOptions()
-		);
-		// Check SOL Balance
-		const lamportsBalance = yield connection.getBalance(wallet.publicKey);
-		console.log('SOL balance:', lamportsBalance / Math.pow(10, 9));
-		// Misc. other things to set up
-		const usdcTokenAddress = yield exports.getTokenAddress(
-			sdkConfig.USDC_MINT_ADDRESS,
-			wallet.publicKey.toString()
-		);
-		// Set up the Drift Clearing House
-		const clearingHousePublicKey = new web3_js_1.PublicKey(
-			sdkConfig.CLEARING_HOUSE_PROGRAM_ID
-		);
-		const clearingHouse = new __2.ClearingHouse({
-			connection,
-			wallet: provider.wallet,
-			programID: clearingHousePublicKey,
-		});
-		yield clearingHouse.subscribe();
-		// Set up Clearing House user client
-		const user = new __2.ClearingHouseUser({
-			clearingHouse,
-			userAccountPublicKey: yield clearingHouse.getUserAccountPublicKey(),
-		});
-		//// Check if clearing house account exists for the current wallet
-		const userAccountExists = yield user.exists();
-		if (!userAccountExists) {
-			//// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
-			const depositAmount = new anchor_1.BN(10000).mul(__2.QUOTE_PRECISION);
-			yield clearingHouse.initializeUserAccountAndDepositCollateral(
-				depositAmount,
-				yield exports.getTokenAddress(
-					usdcTokenAddress.toString(),
-					wallet.publicKey.toString()
-				),
-				banks_1.SpotMarkets['devnet'][0].marketIndex
-			);
-		}
-		yield user.subscribe();
-		// Get current price
-		const solMarketInfo = sdkConfig.PERP_MARKETS.find(
-			(market) => market.baseAssetSymbol === 'SOL'
-		);
-		const currentMarketPrice = __2.calculateMarkPrice(
-			clearingHouse.getMarketAccount(solMarketInfo.marketIndex),
-			undefined
-		);
-		const formattedPrice = __2.convertToNumber(
-			currentMarketPrice,
-			__2.MARK_PRICE_PRECISION
-		);
-		console.log(`Current Market Price is $${formattedPrice}`);
-		// Estimate the slippage for a $5000 LONG trade
-		const solMarketAccount = clearingHouse.getMarketAccount(
-			solMarketInfo.marketIndex
-		);
-		const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
-		const slippage = __2.convertToNumber(
-			__2.calculateTradeSlippage(
-				__2.PositionDirection.LONG,
-				longAmount,
-				solMarketAccount,
-				'quote',
-				undefined
-			)[0],
-			__2.MARK_PRICE_PRECISION
-		);
-		console.log(
-			`Slippage for a $5000 LONG on the SOL market would be $${slippage}`
-		);
-		// Make a $5000 LONG trade
-		yield clearingHouse.openPosition(
-			__2.PositionDirection.LONG,
-			longAmount,
-			solMarketInfo.marketIndex
-		);
-		console.log(`LONGED $5000 SOL`);
-		// Reduce the position by $2000
-		const reduceAmount = new anchor_1.BN(2000).mul(__2.QUOTE_PRECISION);
-		yield clearingHouse.openPosition(
-			__2.PositionDirection.SHORT,
-			reduceAmount,
-			solMarketInfo.marketIndex
-		);
-		// Close the rest of the position
-		yield clearingHouse.closePosition(solMarketInfo.marketIndex);
-	});
-main();

package/src/factory/bigNum.js

@@ -1,390 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigNum = void 0;
-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);
-    }
-    bigNumFromParam(bn) {
-        return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
-    }
-    add(bn) {
-        assert_1.assert(bn.precision.eq(this.precision), 'Adding unequal precisions');
-        return BigNum.from(this.val.add(bn.val), this.precision);
-    }
-    sub(bn) {
-        assert_1.assert(bn.precision.eq(this.precision), 'Subtracting unequal precisions');
-        return BigNum.from(this.val.sub(bn.val), this.precision);
-    }
-    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
-     */
-    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());
-    }
-    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
-     */
-    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
-     */
-    shiftTo(targetPrecision) {
-        return this.shift(targetPrecision.sub(this.precision));
-    }
-    /**
-     * Scale the number by a fraction
-     * @param numerator
-     * @param denominator
-     * @returns
-     */
-    scale(numerator, denominator) {
-        return this.mul(BigNum.from(new anchor_1.BN(numerator))).div(new anchor_1.BN(denominator));
-    }
-    toPercentage(denominator, precision) {
-        return this.shift(precision)
-            .shift(2, true)
-            .div(denominator)
-            .toPrecision(precision);
-    }
-    gt(bn, ignorePrecision) {
-        const comparisonVal = this.bigNumFromParam(bn);
-        if (!ignorePrecision && !comparisonVal.eq(numericConstants_1.ZERO)) {
-            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 = this.bigNumFromParam(bn);
-        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
-            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 = this.bigNumFromParam(bn);
-        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
-            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 = this.bigNumFromParam(bn);
-        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
-            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 = this.bigNumFromParam(bn);
-        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
-            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);
-    }
-    eqZero() {
-        return this.val.eq(numericConstants_1.ZERO);
-    }
-    gtZero() {
-        return this.val.gt(numericConstants_1.ZERO);
-    }
-    ltZero() {
-        return this.val.lt(numericConstants_1.ZERO);
-    }
-    gteZero() {
-        return this.val.gte(numericConstants_1.ZERO);
-    }
-    lteZero() {
-        return this.val.lte(numericConstants_1.ZERO);
-    }
-    abs() {
-        return new BigNum(this.val.abs(), this.precision);
-    }
-    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
-     */
-    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
-        let printString = [
-            ...Array(this.precision.toNumber()).fill(0),
-            ...plainString.split(''),
-        ].join('');
-        // inject decimal
-        printString =
-            printString.substring(0, printString.length - precisionNum) +
-                BigNum.delim +
-                printString.substring(printString.length - precisionNum);
-        // remove leading zeroes
-        printString = printString.replace(/^0+/, '');
-        // add zero if leading delim
-        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;
-    }
-    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('-', '');
-        }
-        let index = formattedLeftSide.length - 3;
-        while (index >= 1) {
-            const formattedLeftSideArray = formattedLeftSide.split('');
-            formattedLeftSideArray.splice(index, 0, BigNum.spacer);
-            formattedLeftSide = formattedLeftSideArray.join('');
-            index -= 3;
-        }
-        return `${isNeg ? '-' : ''}${formattedLeftSide}${rightSide ? `${BigNum.delim}${rightSide}` : ''}`;
-    }
-    /**
-     * Print and remove unnecessary trailing zeroes
-     * @returns
-     */
-    printShort(useTradePrecision, precisionOverride) {
-        const printVal = precisionOverride
-            ? this.toPrecision(precisionOverride)
-            : useTradePrecision
-                ? this.toTradePrecision()
-                : this.print();
-        return printVal.replace(/0+$/g, '').replace(/\.$/, '').replace(/,$/, '');
-    }
-    debug() {
-        console.log(`${this.toString()} | ${this.print()} | ${this.precision.toString()}`);
-    }
-    /**
-     * Pretty print with the specified number of decimal places
-     * @param fixedPrecision
-     * @returns
-     */
-    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 `${leftSide}${BigNum.delim}${filledRightSide}`;
-    }
-    /**
-     * Pretty print to the specified number of significant figures
-     * @param fixedPrecision
-     * @returns
-     */
-    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);
-        }
-        const pointsOfPrecision = precisionPrintString.replace(BigNum.delim, '').length;
-        if (pointsOfPrecision < fixedPrecision) {
-            precisionPrintString = [
-                ...precisionPrintString.split(''),
-                ...Array(fixedPrecision - pointsOfPrecision).fill('0'),
-            ].join('');
-        }
-        if (!precisionPrintString.includes(BigNum.delim)) {
-            const delimFullStringLocation = printString.indexOf(BigNum.delim);
-            let skipExponent = false;
-            if (delimFullStringLocation === -1) {
-                // no decimal, not missing any precision
-                skipExponent = true;
-            }
-            if (precisionPrintString[precisionPrintString.length - 1] === BigNum.delim) {
-                // decimal is at end of string, not missing any precision, do nothing
-                skipExponent = true;
-            }
-            if (printString.indexOf(BigNum.delim) === fixedPrecision) {
-                // decimal is at end of string, not missing any precision, do nothing
-                skipExponent = true;
-            }
-            if (!skipExponent) {
-                const exponent = delimFullStringLocation - fixedPrecision;
-                if (trailingZeroes) {
-                    precisionPrintString = `${precisionPrintString}${Array(exponent)
-                        .fill('0')
-                        .join('')}`;
-                }
-                else {
-                    precisionPrintString = `${precisionPrintString}e${exponent}`;
-                }
-            }
-        }
-        return precisionPrintString;
-    }
-    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
-     */
-    toNotional(useTradePrecision, precisionOverride) {
-        var _a;
-        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) {
-            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) {
-        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);
-        }
-        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 = [
-                ...leadDigits.split(''),
-                ...Array(precision - leadDigits.length).fill('0'),
-            ].join('');
-        }
-        const decimalLocation = leftSide.length - 3 * unitNumber;
-        let leadString = '';
-        if (decimalLocation >= precision) {
-            leadString = `${leadDigits}`;
-        }
-        else {
-            leadString = `${leadDigits.slice(0, decimalLocation)}${BigNum.delim}${leadDigits.slice(decimalLocation)}`;
-        }
-        return `${leadString}${unit}`;
-    }
-    toJSON() {
-        return {
-            val: this.val.toString(),
-            precision: this.precision.toString(),
-        };
-    }
-    isNeg() {
-        return this.lt(numericConstants_1.ZERO, true);
-    }
-    isPos() {
-        return !this.isNeg();
-    }
-    /**
-     * Get the numerical value of the BigNum. This can break if the BigNum is too large.
-     * @returns
-     */
-    toNum() {
-        return parseFloat(this.print());
-    }
-    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
-     */
-    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
-     */
-    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);
-        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);
-    }
-    static max(a, b) {
-        return a.gt(b) ? a : b;
-    }
-    static min(a, b) {
-        return a.lt(b) ? a : b;
-    }
-    static zero(precision) {
-        return BigNum.from(0, precision);
-    }
-}
-exports.BigNum = BigNum;
-BigNum.delim = '.';
-BigNum.spacer = ',';