@shapeshiftoss/utils 1.0.5 → 1.1.0

package/dist/esm/bigAmount/bigAmount.js

@@ -0,0 +1,272 @@
+import { bn, bnOrZero } from '../bignumber/bignumber.js';
+const ROUND_DOWN = 1;
+const ROUND_HALF_UP = 4;
+const TEN = bn(10);
+const THOR_PRECISION = 8;
+export class BigAmount {
+    // Internal value is ALWAYS in base units (raw blockchain integer scale).
+    value;
+    precision;
+    assetId;
+    static config;
+    constructor(value, precision, assetId) {
+        this.value = value;
+        this.precision = precision;
+        this.assetId = assetId;
+    }
+    // ── Configuration ───────────────────────────────
+    static configure(config) {
+        BigAmount.config = config;
+    }
+    static getConfig() {
+        return BigAmount.config;
+    }
+    static resetConfig() {
+        BigAmount.config = undefined;
+    }
+    // ── Construction (all nullish-safe) ───────────────
+    static fromBaseUnit(args) {
+        if ('assetId' in args && args.assetId !== undefined) {
+            const precision = BigAmount.resolveConfigPrecision(args.assetId);
+            return new BigAmount(bnOrZero(args.value), precision, args.assetId);
+        }
+        return new BigAmount(bnOrZero(args.value), args.precision);
+    }
+    static fromPrecision(args) {
+        if ('assetId' in args && args.assetId !== undefined) {
+            const precision = BigAmount.resolveConfigPrecision(args.assetId);
+            return new BigAmount(bnOrZero(args.value).times(TEN.pow(precision)), precision, args.assetId);
+        }
+        return new BigAmount(bnOrZero(args.value).times(TEN.pow(args.precision)), args.precision);
+    }
+    static zero({ precision, assetId }) {
+        return new BigAmount(bn(0), precision, assetId);
+    }
+    static fromBN({ value, precision, assetId, }) {
+        const safeValue = value.isFinite() ? value : bn(0);
+        return new BigAmount(safeValue.times(TEN.pow(precision)), precision, assetId);
+    }
+    static fromJSON({ value, precision, assetId, }) {
+        return new BigAmount(bn(value), precision, assetId);
+    }
+    static min(...amounts) {
+        if (amounts.length === 0)
+            throw new Error('BigAmount.min requires at least one argument');
+        return amounts.reduce((acc, cur) => {
+            assertSamePrecision(acc, cur);
+            return acc.value.lte(cur.value) ? acc : cur;
+        });
+    }
+    static max(...amounts) {
+        if (amounts.length === 0)
+            throw new Error('BigAmount.max requires at least one argument');
+        return amounts.reduce((acc, cur) => {
+            assertSamePrecision(acc, cur);
+            return acc.value.gte(cur.value) ? acc : cur;
+        });
+    }
+    static isBigAmount(value) {
+        return value instanceof BigAmount;
+    }
+    // ── Arithmetic (chainable → BigAmount) ────────────
+    plus(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return new BigAmount(this.value.plus(other.value), this.precision, this.assetId);
+        }
+        return new BigAmount(this.value.plus(bnOrZero(other).times(TEN.pow(this.precision))), this.precision, this.assetId);
+    }
+    minus(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return new BigAmount(this.value.minus(other.value), this.precision, this.assetId);
+        }
+        return new BigAmount(this.value.minus(bnOrZero(other).times(TEN.pow(this.precision))), this.precision, this.assetId);
+    }
+    times(scalar) {
+        assertNotBigAmount(scalar, 'times');
+        return new BigAmount(this.value.times(bnOrZero(scalar)), this.precision, this.assetId);
+    }
+    div(scalar) {
+        assertNotBigAmount(scalar, 'div');
+        const divisor = bnOrZero(scalar);
+        if (divisor.isZero()) {
+            return BigAmount.zero({ precision: this.precision, assetId: this.assetId });
+        }
+        return new BigAmount(this.value.div(divisor), this.precision, this.assetId);
+    }
+    abs() {
+        return new BigAmount(this.value.abs(), this.precision, this.assetId);
+    }
+    negated() {
+        return new BigAmount(this.value.negated(), this.precision, this.assetId);
+    }
+    positiveOrZero() {
+        return this.value.isPositive()
+            ? this
+            : BigAmount.zero({ precision: this.precision, assetId: this.assetId });
+    }
+    decimalPlaces(n, rm) {
+        const precisionValue = this.value.div(TEN.pow(this.precision));
+        const truncated = precisionValue.decimalPlaces(n, rm);
+        return new BigAmount(truncated.times(TEN.pow(this.precision)), this.precision, this.assetId);
+    }
+    // ── Comparison (terminal → boolean) ───────────────
+    gt(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return this.value.gt(other.value);
+        }
+        return this.value.gt(bnOrZero(other).times(TEN.pow(this.precision)));
+    }
+    gte(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return this.value.gte(other.value);
+        }
+        return this.value.gte(bnOrZero(other).times(TEN.pow(this.precision)));
+    }
+    lt(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return this.value.lt(other.value);
+        }
+        return this.value.lt(bnOrZero(other).times(TEN.pow(this.precision)));
+    }
+    lte(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return this.value.lte(other.value);
+        }
+        return this.value.lte(bnOrZero(other).times(TEN.pow(this.precision)));
+    }
+    eq(other) {
+        if (other instanceof BigAmount) {
+            assertSamePrecision(this, other);
+            return this.value.eq(other.value);
+        }
+        return this.value.eq(bnOrZero(other).times(TEN.pow(this.precision)));
+    }
+    isZero() {
+        return this.value.isZero();
+    }
+    isPositive() {
+        return this.value.isPositive();
+    }
+    isNegative() {
+        return this.value.isNegative();
+    }
+    isFinite() {
+        return this.value.isFinite();
+    }
+    // ── Output ────────────────────────────────────────
+    toBaseUnit() {
+        return this.value.toFixed(0, ROUND_HALF_UP);
+    }
+    toPrecision() {
+        return this.value.div(TEN.pow(this.precision)).toFixed();
+    }
+    toBN() {
+        return this.value.div(TEN.pow(this.precision));
+    }
+    toFixed(decimals) {
+        const precisionValue = this.value.div(TEN.pow(this.precision));
+        if (typeof decimals === 'number') {
+            return precisionValue.toFixed(decimals, ROUND_DOWN);
+        }
+        return precisionValue.toFixed();
+    }
+    toString() {
+        return this.toPrecision();
+    }
+    toNumber() {
+        return this.value.div(TEN.pow(this.precision)).toNumber();
+    }
+    toSignificant(digits) {
+        const precisionValue = this.value.div(TEN.pow(this.precision));
+        if (precisionValue.isZero())
+            return '0';
+        const fixed = precisionValue.toFixed();
+        const isNeg = fixed.startsWith('-');
+        const abs = isNeg ? fixed.slice(1) : fixed;
+        const dotIndex = abs.indexOf('.');
+        if (dotIndex === -1)
+            return fixed;
+        const intPart = abs.slice(0, dotIndex);
+        const decPart = abs.slice(dotIndex + 1);
+        if (intPart !== '0') {
+            const intDigits = intPart.length;
+            if (intDigits >= digits)
+                return (isNeg ? '-' : '') + intPart;
+            const trimmed = decPart.slice(0, digits - intDigits);
+            const result = `${intPart}.${trimmed}`.replace(/\.?0+$/, '');
+            return (isNeg ? '-' : '') + result;
+        }
+        let firstNonZero = 0;
+        while (firstNonZero < decPart.length && decPart[firstNonZero] === '0') {
+            firstNonZero++;
+        }
+        const significantPart = decPart.slice(firstNonZero, firstNonZero + digits);
+        const leadingZeros = decPart.slice(0, firstNonZero);
+        const result = `0.${leadingZeros}${significantPart}`.replace(/0+$/, '');
+        return (isNeg ? '-' : '') + result;
+    }
+    // ── Fiat conversion ────────────────────────────────
+    toUserCurrency(decimals = 2) {
+        if (!this.assetId)
+            throw new Error('BigAmount: toUserCurrency() requires assetId');
+        if (!BigAmount.config?.resolvePrice)
+            throw new Error('BigAmount: not configured');
+        const price = BigAmount.config.resolvePrice(this.assetId);
+        return this.value
+            .div(TEN.pow(this.precision))
+            .times(bnOrZero(price))
+            .toFixed(decimals, ROUND_HALF_UP);
+    }
+    toUSD(decimals = 2) {
+        if (!this.assetId)
+            throw new Error('BigAmount: toUSD() requires assetId');
+        if (!BigAmount.config?.resolvePriceUsd)
+            throw new Error('BigAmount: not configured');
+        const priceUsd = BigAmount.config.resolvePriceUsd(this.assetId);
+        return this.value
+            .div(TEN.pow(this.precision))
+            .times(bnOrZero(priceUsd))
+            .toFixed(decimals, ROUND_HALF_UP);
+    }
+    // ── THORChain precision ──────────────────────────
+    static fromThorBaseUnit(value) {
+        return BigAmount.fromBaseUnit({ value, precision: THOR_PRECISION });
+    }
+    toThorBaseUnit() {
+        return this.value
+            .times(TEN.pow(THOR_PRECISION))
+            .div(TEN.pow(this.precision))
+            .toFixed(0, ROUND_HALF_UP);
+    }
+    // ── Interop ───────────────────────────────────────
+    toJSON() {
+        return {
+            value: this.value.toFixed(0, ROUND_HALF_UP),
+            precision: this.precision,
+            assetId: this.assetId,
+        };
+    }
+    // ── Private helpers ────────────────────────────────
+    static resolveConfigPrecision(assetId) {
+        if (!BigAmount.config?.resolvePrecision) {
+            throw new Error('BigAmount: not configured — call BigAmount.configure() first');
+        }
+        return BigAmount.config.resolvePrecision(assetId);
+    }
+}
+function assertSamePrecision(a, b) {
+    if (a.precision !== b.precision) {
+        throw new Error(`Cannot operate on amounts with different precisions: ${a.precision} vs ${b.precision}`);
+    }
+}
+function assertNotBigAmount(value, method) {
+    if (value instanceof BigAmount) {
+        throw new TypeError(`BigAmount.${method} does not accept BigAmount as argument (dimensionally invalid). Use .toPrecision() or .toBaseUnit() to extract the scalar first.`);
+    }
+}

package/dist/esm/bigAmount/bigAmount.test.d.ts

@@ -0,0 +1 @@
+export {};