@shapeshiftoss/utils 1.0.4 → 1.0.6

package/dist/cjs/bigAmount/bigAmount.d.ts

@@ -0,0 +1,82 @@
+import type BigNumber from 'bignumber.js';
+type NullableScalar = BigNumber.Value | null | undefined;
+type WithPrecision = {
+    value: BigNumber.Value | null | undefined;
+    precision: number;
+    assetId?: never;
+};
+type WithAssetId = {
+    value: BigNumber.Value | null | undefined;
+    assetId: string;
+    precision?: never;
+};
+type FactoryArgs = WithPrecision | WithAssetId;
+export type BigAmountConfig = {
+    resolvePrecision: (assetId: string) => number;
+    resolvePrice: (assetId: string) => string;
+    resolvePriceUsd: (assetId: string) => string;
+};
+export declare class BigAmount {
+    private readonly value;
+    readonly precision: number;
+    readonly assetId?: string;
+    private static config?;
+    private constructor();
+    static configure(config: BigAmountConfig): void;
+    static getConfig(): BigAmountConfig | undefined;
+    static resetConfig(): void;
+    static fromBaseUnit(args: FactoryArgs): BigAmount;
+    static fromPrecision(args: FactoryArgs): BigAmount;
+    static zero({ precision, assetId }: {
+        precision: number;
+        assetId?: string;
+    }): BigAmount;
+    static fromBN({ value, precision, assetId, }: {
+        value: BigNumber;
+        precision: number;
+        assetId?: string;
+    }): BigAmount;
+    static fromJSON({ value, precision, assetId, }: {
+        value: string;
+        precision: number;
+        assetId?: string;
+    }): BigAmount;
+    static min(...amounts: BigAmount[]): BigAmount;
+    static max(...amounts: BigAmount[]): BigAmount;
+    static isBigAmount(value: unknown): value is BigAmount;
+    plus(other: BigAmount | NullableScalar): BigAmount;
+    minus(other: BigAmount | NullableScalar): BigAmount;
+    times(scalar: NullableScalar): BigAmount;
+    div(scalar: NullableScalar): BigAmount;
+    abs(): BigAmount;
+    negated(): BigAmount;
+    positiveOrZero(): BigAmount;
+    decimalPlaces(n: number, rm?: BigNumber.RoundingMode): BigAmount;
+    gt(other: BigAmount | NullableScalar): boolean;
+    gte(other: BigAmount | NullableScalar): boolean;
+    lt(other: BigAmount | NullableScalar): boolean;
+    lte(other: BigAmount | NullableScalar): boolean;
+    eq(other: BigAmount | NullableScalar): boolean;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    isFinite(): boolean;
+    toBaseUnit(): string;
+    toPrecision(): string;
+    toBN(): BigNumber;
+    toFixed(decimals?: number): string;
+    toString(): string;
+    toNumber(): number;
+    toSignificant(digits: number): string;
+    toUserCurrency(decimals?: number): string;
+    toUSD(decimals?: number): string;
+    static fromThorBaseUnit(value: BigNumber.Value | null | undefined): BigAmount;
+    toThorBaseUnit(): string;
+    toJSON(): {
+        value: string;
+        precision: number;
+        assetId?: string;
+    };
+    private static resolveConfigPrecision;
+}
+export {};

package/dist/cjs/bigAmount/bigAmount.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigAmount = void 0;
+const bignumber_1 = require("../bignumber/bignumber");
+const ROUND_DOWN = 1;
+const ROUND_HALF_UP = 4;
+const TEN = (0, bignumber_1.bn)(10);
+const THOR_PRECISION = 8;
+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((0, bignumber_1.bnOrZero)(args.value), precision, args.assetId);
+        }
+        return new BigAmount((0, bignumber_1.bnOrZero)(args.value), args.precision);
+    }
+    static fromPrecision(args) {
+        if ('assetId' in args && args.assetId !== undefined) {
+            const precision = BigAmount.resolveConfigPrecision(args.assetId);
+            return new BigAmount((0, bignumber_1.bnOrZero)(args.value).times(TEN.pow(precision)), precision, args.assetId);
+        }
+        return new BigAmount((0, bignumber_1.bnOrZero)(args.value).times(TEN.pow(args.precision)), args.precision);
+    }
+    static zero({ precision, assetId }) {
+        return new BigAmount((0, bignumber_1.bn)(0), precision, assetId);
+    }
+    static fromBN({ value, precision, assetId, }) {
+        const safeValue = value.isFinite() ? value : (0, bignumber_1.bn)(0);
+        return new BigAmount(safeValue.times(TEN.pow(precision)), precision, assetId);
+    }
+    static fromJSON({ value, precision, assetId, }) {
+        return new BigAmount((0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.bnOrZero)(other).times(TEN.pow(this.precision))), this.precision, this.assetId);
+    }
+    times(scalar) {
+        assertNotBigAmount(scalar, 'times');
+        return new BigAmount(this.value.times((0, bignumber_1.bnOrZero)(scalar)), this.precision, this.assetId);
+    }
+    div(scalar) {
+        assertNotBigAmount(scalar, 'div');
+        const divisor = (0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.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((0, bignumber_1.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);
+    }
+}
+exports.BigAmount = BigAmount;
+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/cjs/bigAmount/bigAmount.test.d.ts

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