@injectivelabs/sdk-ts 1.16.25-alpha.1 → 1.16.26

package/dist/esm/utils/numbers.d.ts

@@ -0,0 +1,313 @@
+import { BigNumber, getExactDecimalsFromNumber, getSignificantDecimalsFromNumber } from '@injectivelabs/utils';
+export declare const isNumber: (number: string | number) => boolean;
+export declare const formatNumberToAllowableDecimals: (value: string | number, allowableDecimals: number, roundingMode?: BigNumber.RoundingMode) => string;
+export declare const formatNumberToAllowableTensMultiplier: (value: string | number, tensMultiplier: number, roundingMode?: BigNumber.RoundingMode) => string;
+export declare const formatAmountToAllowableAmount: (value: string | number, tensMultiplier: number) => string;
+export declare const formatPriceToAllowablePrice: (value: string | number, tensMultiplier: number) => string;
+/**
+ *
+ * Legacy function - use formatNumberToAllowableDecimals
+ *
+ * @param value
+ * @param allowableDecimals
+ * @returns
+ */
+export declare const formatAmountToAllowableDecimals: (value: string | number, allowableDecimals: number) => string;
+/**
+ *
+ * Legacy function - use formatNumberToAllowableDecimals
+ *
+ * @param value
+ * @param allowableDecimals
+ * @returns
+ */
+export declare const formatPriceToAllowableDecimals: (value: string | number, allowableDecimals: number) => string;
+/**
+ * On chain amounts queried from a sentry using the
+ * gRPC API are returned with an extra decimal point
+ * 18 places from the beginning, so we need to remove it
+ * to get a workable amount
+ */
+export declare const denomAmountFromGrpcChainDenomAmount: (value: string | number | BigNumber) => BigNumber;
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * On chain amounts broadcasted to a sentry directly using the
+ * gRPC API should be passed with an extra decimal point
+ * 18 places from the beginning, so we need to add it
+ * to get a workable amount
+ */
+export declare const denomAmountToGrpcChainDenomAmount: (value: string | number | BigNumber) => BigNumber;
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * On chain amounts (based on the cosmosSdk.Dec type)
+ * broadcasted to a sentry directly using the
+ * gRPC API should be passed with an extra decimal point
+ * 18 places from the beginning (i.e multiplied by 1e18), so we need to add it
+ * to get a workable amount
+ */
+export declare const amountToCosmosSdkDecAmount: (value: string | number | BigNumber) => BigNumber;
+/**
+ * * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const denomAmountToChainDenomAmount: ({ value, decimals, }: {
+    value: number | string | BigNumber;
+    decimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const denomAmountToChainDenomAmountToFixed: ({ value, decimals, tensMultiplier, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    decimals?: number | string;
+    tensMultiplier?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const denomAmountFromChainDenomAmount: ({ value, decimals, }: {
+    value: number | string | BigNumber;
+    decimals?: number | string;
+}) => BigNumber;
+/**
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export declare const denomAmountFromChainDenomAmountToFixed: ({ value, decimals, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    decimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const derivativeMarginToChainMargin: ({ value, quoteDecimals, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export declare const derivativeMarginToChainMarginToFixed: ({ value, quoteDecimals, tensMultiplier, decimalPlaces, roundingMode, }: {
+    decimalPlaces?: number;
+    tensMultiplier?: number;
+    roundingMode?: BigNumber.RoundingMode;
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+}) => string;
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const derivativeMarginFromChainMargin: ({ value, quoteDecimals, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const derivativeMarginFromChainMarginToFixed: ({ value, quoteDecimals, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const derivativePriceToChainPrice: ({ value, quoteDecimals, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export declare const derivativePriceToChainPriceToFixed: ({ value, tensMultiplier, quoteDecimals, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    tensMultiplier?: number;
+    quoteDecimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export declare const derivativePriceFromChainPrice: ({ value, quoteDecimals, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export declare const derivativePriceFromChainPriceToFixed: ({ value, quoteDecimals, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toBigNumber from injectivelabs/utils instead
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number
+ */
+export declare const derivativeQuantityToChainQuantity: ({ value, }: {
+    value: number | string | BigNumber;
+}) => BigNumber;
+/**
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number stringified
+ */
+export declare const derivativeQuantityToChainQuantityToFixed: ({ value, decimalPlaces, tensMultiplier, roundingMode, }: {
+    value: number | string | BigNumber;
+    decimalPlaces?: number;
+    tensMultiplier?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number
+ */
+export declare const derivativeQuantityFromChainQuantity: ({ value, }: {
+    value: number | string | BigNumber;
+}) => BigNumber;
+/**
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number stringified
+ */
+export declare const derivativeQuantityFromChainQuantityToFixed: ({ value, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ * Amount that the chain requires is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number
+ */
+export declare const spotPriceToChainPrice: ({ value, baseDecimals, quoteDecimals, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+    baseDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain requires is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number stringified
+ */
+export declare const spotPriceToChainPriceToFixed: ({ value, baseDecimals, quoteDecimals, tensMultiplier, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+    baseDecimals?: number | string;
+    decimalPlaces?: number;
+    tensMultiplier?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number
+ */
+export declare const spotPriceFromChainPrice: ({ value, baseDecimals, quoteDecimals, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number | string;
+    baseDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain returns is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number stringified
+ */
+export declare const spotPriceFromChainPriceToFixed: ({ value, baseDecimals, quoteDecimals, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    quoteDecimals?: number;
+    baseDecimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * Amount that the chain requires is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export declare const spotQuantityToChainQuantity: ({ value, baseDecimals, }: {
+    value: number | string | BigNumber;
+    baseDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain requires is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export declare const spotQuantityToChainQuantityToFixed: ({ value, baseDecimals, tensMultiplier, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    tensMultiplier?: number;
+    baseDecimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export declare const spotQuantityFromChainQuantity: ({ value, baseDecimals, }: {
+    value: number | string | BigNumber;
+    baseDecimals?: number | string;
+}) => BigNumber;
+/**
+ * Amount that the chain returns is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export declare const spotQuantityFromChainQuantityToFixed: ({ value, baseDecimals, decimalPlaces, roundingMode, }: {
+    value: number | string | BigNumber;
+    baseDecimals?: number;
+    decimalPlaces?: number;
+    roundingMode?: BigNumber.RoundingMode;
+}) => string;
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ */
+export declare const cosmosSdkDecToBigNumber: (number: string | number | BigNumber) => BigNumber;
+export declare const numberToCosmosSdkDecString: (value: string | number | BigNumber) => string;
+/**
+ * This function returns a multiplier of 10
+ * based on the input. There are two cases:
+ *
+ * 1. If the number is less than 1, it returns a NEGATIVE
+ * number which is the number of decimals the number has
+ *
+ * 2. If the number is higher than 1, it returns a POSITIVE
+ * number which is the number of 10 multiplier the number has
+ *
+ * @param number
+ * @returns {number}
+ */
+export declare const getTensMultiplier: (number: number | string) => number;
+export { getSignificantDecimalsFromNumber, getExactDecimalsFromNumber };

package/dist/esm/utils/numbers.js

@@ -0,0 +1,365 @@
+import { BigNumber, toBigNumber, toChainFormat, toHumanReadable, getExactDecimalsFromNumber, getSignificantDecimalsFromNumber, } from '@injectivelabs/utils';
+const $BigNumber = BigNumber.clone({ ROUNDING_MODE: BigNumber.ROUND_DOWN });
+export const isNumber = (number) => {
+    if (typeof number === 'number') {
+        return true;
+    }
+    return !isNaN(parseFloat(number));
+};
+export const formatNumberToAllowableDecimals = (value, allowableDecimals, roundingMode) => {
+    const decimalPlacesInValue = toBigNumber(getExactDecimalsFromNumber(value));
+    const valueToString = value.toString();
+    if (decimalPlacesInValue.lte(0)) {
+        return valueToString;
+    }
+    const decimalMoreThanAllowance = decimalPlacesInValue.gte(allowableDecimals);
+    return decimalMoreThanAllowance
+        ? toBigNumber(valueToString).toFixed(allowableDecimals, roundingMode)
+        : valueToString;
+};
+export const formatNumberToAllowableTensMultiplier = (value, tensMultiplier, roundingMode) => {
+    const valueToBn = toBigNumber(value);
+    if (tensMultiplier === 0) {
+        return valueToBn.toFixed(0, roundingMode);
+    }
+    const tensMul = toBigNumber(10).pow(tensMultiplier);
+    if (valueToBn.lte(tensMul)) {
+        return tensMul.toFixed(0, roundingMode);
+    }
+    return toBigNumber(valueToBn.div(tensMul).toFixed(0, roundingMode))
+        .multipliedBy(tensMul)
+        .toFixed(0);
+};
+export const formatAmountToAllowableAmount = (value, tensMultiplier) => {
+    return tensMultiplier < 0
+        ? formatNumberToAllowableDecimals(value, -tensMultiplier, BigNumber.ROUND_DOWN)
+        : formatNumberToAllowableTensMultiplier(value, tensMultiplier, BigNumber.ROUND_DOWN);
+};
+export const formatPriceToAllowablePrice = (value, tensMultiplier) => {
+    return tensMultiplier <= 0
+        ? formatNumberToAllowableDecimals(value, -tensMultiplier)
+        : formatNumberToAllowableTensMultiplier(value, tensMultiplier);
+};
+/**
+ *
+ * Legacy function - use formatNumberToAllowableDecimals
+ *
+ * @param value
+ * @param allowableDecimals
+ * @returns
+ */
+export const formatAmountToAllowableDecimals = (value, allowableDecimals) => {
+    return formatNumberToAllowableDecimals(value, allowableDecimals, BigNumber.ROUND_DOWN);
+};
+/**
+ *
+ * Legacy function - use formatNumberToAllowableDecimals
+ *
+ * @param value
+ * @param allowableDecimals
+ * @returns
+ */
+export const formatPriceToAllowableDecimals = (value, allowableDecimals) => {
+    return formatNumberToAllowableDecimals(value, allowableDecimals);
+};
+/**
+ * On chain amounts queried from a sentry using the
+ * gRPC API are returned with an extra decimal point
+ * 18 places from the beginning, so we need to remove it
+ * to get a workable amount
+ */
+export const denomAmountFromGrpcChainDenomAmount = (value) => new $BigNumber(value).dividedBy(new $BigNumber(10).pow(18));
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * On chain amounts broadcasted to a sentry directly using the
+ * gRPC API should be passed with an extra decimal point
+ * 18 places from the beginning, so we need to add it
+ * to get a workable amount
+ */
+export const denomAmountToGrpcChainDenomAmount = (value) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(18));
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * On chain amounts (based on the cosmosSdk.Dec type)
+ * broadcasted to a sentry directly using the
+ * gRPC API should be passed with an extra decimal point
+ * 18 places from the beginning (i.e multiplied by 1e18), so we need to add it
+ * to get a workable amount
+ */
+export const amountToCosmosSdkDecAmount = (value) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(18));
+/**
+ * * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const denomAmountToChainDenomAmount = ({ value, decimals = 18, }) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(decimals));
+/**
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const denomAmountToChainDenomAmountToFixed = ({ value, decimals = 18, tensMultiplier, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const valueToBn = toBigNumber(value).toFixed();
+    const flooredValue = tensMultiplier
+        ? formatPriceToAllowablePrice(valueToBn, tensMultiplier)
+        : value;
+    const number = denomAmountToChainDenomAmount({
+        value: flooredValue,
+        decimals,
+    });
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const denomAmountFromChainDenomAmount = ({ value, decimals = 18, }) => new $BigNumber(value).dividedBy(new $BigNumber(10).pow(decimals));
+/**
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export const denomAmountFromChainDenomAmountToFixed = ({ value, decimals = 18, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const number = toHumanReadable(value, decimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const derivativeMarginToChainMargin = ({ value, quoteDecimals = 18, }) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(quoteDecimals));
+/**
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export const derivativeMarginToChainMarginToFixed = ({ value, quoteDecimals = 18, tensMultiplier, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const valueToBn = toBigNumber(value).toFixed();
+    const flooredValue = tensMultiplier
+        ? formatPriceToAllowablePrice(valueToBn, tensMultiplier)
+        : value;
+    const number = derivativeMarginToChainMargin({
+        value: flooredValue,
+        quoteDecimals,
+    });
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const derivativeMarginFromChainMargin = ({ value, quoteDecimals = 18, }) => new $BigNumber(value).dividedBy(new $BigNumber(10).pow(quoteDecimals));
+/**
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const derivativeMarginFromChainMarginToFixed = ({ value, quoteDecimals = 18, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const number = toHumanReadable(value, quoteDecimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const derivativePriceToChainPrice = ({ value, quoteDecimals = 18, }) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(quoteDecimals));
+/**
+ * Amount that the chain requires is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export const derivativePriceToChainPriceToFixed = ({ value, tensMultiplier, quoteDecimals = 18, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const valueToBn = toBigNumber(value).toFixed();
+    const flooredValue = tensMultiplier
+        ? formatPriceToAllowablePrice(valueToBn, tensMultiplier)
+        : value;
+    const number = toChainFormat(flooredValue, quoteDecimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number
+ */
+export const derivativePriceFromChainPrice = ({ value, quoteDecimals = 18, }) => new $BigNumber(value).dividedBy(new $BigNumber(10).pow(quoteDecimals));
+/**
+ * Amount that the chain returns is in the x * 10^(quoteDecimals) format
+ * where x is a human readable number stringified
+ */
+export const derivativePriceFromChainPriceToFixed = ({ value, quoteDecimals = 18, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const number = toHumanReadable(value, quoteDecimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toBigNumber from injectivelabs/utils instead
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number
+ */
+export const derivativeQuantityToChainQuantity = ({ value, }) => new $BigNumber(value);
+/**
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number stringified
+ */
+export const derivativeQuantityToChainQuantityToFixed = ({ value, decimalPlaces = undefined, tensMultiplier, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const valueToBn = toBigNumber(value).toFixed();
+    const flooredValue = tensMultiplier
+        ? formatPriceToAllowablePrice(valueToBn, tensMultiplier)
+        : value;
+    const number = derivativeQuantityToChainQuantity({ value: flooredValue });
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number
+ */
+export const derivativeQuantityFromChainQuantity = ({ value, }) => new $BigNumber(value);
+/**
+ * Amount that the chain requires is in the x format
+ * where x is a human readable number stringified
+ */
+export const derivativeQuantityFromChainQuantityToFixed = ({ value, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const number = new $BigNumber(value);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ * Amount that the chain requires is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number
+ */
+export const spotPriceToChainPrice = ({ value, baseDecimals = 18, quoteDecimals = 6, }) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(new $BigNumber(quoteDecimals).minus(baseDecimals)));
+/**
+ * Amount that the chain requires is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number stringified
+ */
+export const spotPriceToChainPriceToFixed = ({ value, baseDecimals = 18, quoteDecimals = 6, tensMultiplier, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const valueToBn = toBigNumber(value).toFixed();
+    const flooredValue = tensMultiplier
+        ? formatPriceToAllowablePrice(valueToBn, tensMultiplier)
+        : value;
+    const number = toChainFormat(flooredValue, toBigNumber(quoteDecimals).minus(baseDecimals).toNumber());
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number
+ */
+export const spotPriceFromChainPrice = ({ value, baseDecimals = 18, quoteDecimals = 6, }) => new $BigNumber(value).dividedBy(new $BigNumber(10).pow(new $BigNumber(quoteDecimals).minus(baseDecimals)));
+/**
+ * Amount that the chain returns is in the x / 10^(quoteDecimals - baseDecimals) format
+ * where x is a human readable number stringified
+ */
+export const spotPriceFromChainPriceToFixed = ({ value, baseDecimals = 18, quoteDecimals = 6, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const number = toHumanReadable(value, quoteDecimals - baseDecimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toChainFormat from injectivelabs/utils instead
+ *
+ * Amount that the chain requires is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export const spotQuantityToChainQuantity = ({ value, baseDecimals = 18, }) => new $BigNumber(value).multipliedBy(new $BigNumber(10).pow(baseDecimals));
+/**
+ * Amount that the chain requires is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export const spotQuantityToChainQuantityToFixed = ({ value, baseDecimals = 18, tensMultiplier, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const valueToBn = toBigNumber(value).toFixed();
+    const flooredValue = tensMultiplier
+        ? formatPriceToAllowablePrice(valueToBn, tensMultiplier)
+        : value;
+    const number = toChainFormat(flooredValue, baseDecimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ *
+ * Amount that the chain returns is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export const spotQuantityFromChainQuantity = ({ value, baseDecimals = 18, }) => new $BigNumber(value).dividedBy(new $BigNumber(10).pow(baseDecimals));
+/**
+ * Amount that the chain returns is in the x * 10^(baseDecimals) format
+ * where x is a human readable number
+ */
+export const spotQuantityFromChainQuantityToFixed = ({ value, baseDecimals = 18, decimalPlaces = undefined, roundingMode = BigNumber.ROUND_DOWN, }) => {
+    const number = toHumanReadable(value, baseDecimals);
+    if (decimalPlaces === undefined) {
+        return number.toFixed();
+    }
+    return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+ * @deprecated use toHumanReadable from injectivelabs/utils instead
+ */
+export const cosmosSdkDecToBigNumber = (number) => new BigNumber(number).dividedBy(new BigNumber(10).pow(18));
+export const numberToCosmosSdkDecString = (value) => {
+    return new BigNumber(value).toFixed(18);
+};
+/**
+ * This function returns a multiplier of 10
+ * based on the input. There are two cases:
+ *
+ * 1. If the number is less than 1, it returns a NEGATIVE
+ * number which is the number of decimals the number has
+ *
+ * 2. If the number is higher than 1, it returns a POSITIVE
+ * number which is the number of 10 multiplier the number has
+ *
+ * @param number
+ * @returns {number}
+ */
+export const getTensMultiplier = (number) => {
+    const numberToBn = new BigNumber(number);
+    if (numberToBn.eq(1)) {
+        return 0;
+    }
+    if (numberToBn.lt(1)) {
+        return -1 * getExactDecimalsFromNumber(numberToBn.toFixed());
+    }
+    const [, zerosInTheNumber] = numberToBn.toFixed().split('1');
+    return zerosInTheNumber.length;
+};
+export { getSignificantDecimalsFromNumber, getExactDecimalsFromNumber };