@injectivelabs/sdk-ts 1.16.38-alpha.7 → 1.16.38

package/dist/cjs/utils/helpers.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToNumber = exports.getErrorMessage = exports.sortObjectByKeys = exports.sortObjectByKeysWithReduce = exports.uint8ArrayToString = exports.grpcCoinToUiCoin = exports.protoObjectToJson = exports.objectToJson = exports.isBrowser = exports.isNode = exports.isReactNative = exports.isServerSide = void 0;
+exports.isJsonString = isJsonString;
+const isServerSide = () => typeof window === 'undefined';
+exports.isServerSide = isServerSide;
+const isReactNative = () => {
+    return (typeof document === 'undefined' &&
+        typeof navigator !== 'undefined' &&
+        navigator.product === 'ReactNative');
+};
+exports.isReactNative = isReactNative;
+const isNode = () => {
+    if (typeof window === 'undefined') {
+        return true;
+    }
+    return (typeof process !== 'undefined' &&
+        typeof process.versions !== 'undefined' &&
+        typeof process.versions.node !== 'undefined');
+};
+exports.isNode = isNode;
+const isBrowser = () => {
+    if ((0, exports.isReactNative)()) {
+        return false;
+    }
+    if ((0, exports.isNode)()) {
+        return false;
+    }
+    return typeof window !== 'undefined';
+};
+exports.isBrowser = isBrowser;
+const objectToJson = (object, params) => {
+    const { replacer, indentation } = params || { replacer: null, indentation: 2 };
+    return JSON.stringify(object, replacer, indentation);
+};
+exports.objectToJson = objectToJson;
+const protoObjectToJson = (object, params) => {
+    const { replacer, indentation } = params || { replacer: null, indentation: 2 };
+    if (object.toObject !== undefined) {
+        return JSON.stringify(object.toObject(), replacer, indentation);
+    }
+    return (0, exports.objectToJson)(object, { replacer, indentation });
+};
+exports.protoObjectToJson = protoObjectToJson;
+const grpcCoinToUiCoin = (coin) => ({
+    amount: coin.amount,
+    denom: coin.denom,
+});
+exports.grpcCoinToUiCoin = grpcCoinToUiCoin;
+const uint8ArrayToString = (string) => {
+    if (!string) {
+        return '';
+    }
+    if (string.constructor !== Uint8Array) {
+        return string;
+    }
+    return new TextDecoder().decode(string);
+};
+exports.uint8ArrayToString = uint8ArrayToString;
+const sortObjectByKeysWithReduce = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map((e) => (0, exports.sortObjectByKeysWithReduce)(e)).sort();
+    }
+    return Object.keys(obj)
+        .sort()
+        .reduce((sorted, k) => {
+        const key = k;
+        sorted[key] = (0, exports.sortObjectByKeysWithReduce)(obj[key]);
+        return sorted;
+    }, {});
+};
+exports.sortObjectByKeysWithReduce = sortObjectByKeysWithReduce;
+const sortObjectByKeys = (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(exports.sortObjectByKeys);
+    }
+    const sortedKeys = Object.keys(obj).sort();
+    const result = {};
+    sortedKeys.forEach((key) => {
+        result[key] = (0, exports.sortObjectByKeys)(obj[key]);
+    });
+    return result;
+};
+exports.sortObjectByKeys = sortObjectByKeys;
+const getErrorMessage = (error, endpoint) => {
+    if (!error.response) {
+        return `The request to ${endpoint} has failed.`;
+    }
+    return error.response.data
+        ? error.response.data.message || error.response.data
+        : error.response.statusText;
+};
+exports.getErrorMessage = getErrorMessage;
+/**
+ * Converts value to it's number representation
+ */
+const hexToNumber = (value) => {
+    const [negative, hexValue] = value.startsWith('-')
+        ? [true, value.slice(1)]
+        : [false, value];
+    const num = BigInt(hexValue);
+    if (num > Number.MAX_SAFE_INTEGER) {
+        return Number(negative ? -num : num);
+    }
+    if (num < Number.MIN_SAFE_INTEGER) {
+        return Number(num);
+    }
+    return negative ? -1 * Number(num) : Number(num);
+};
+exports.hexToNumber = hexToNumber;
+function isJsonString(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    try {
+        JSON.parse(str);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}

package/dist/cjs/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './utf8.js';
+export * from './buff.js';
+export * from './time.js';
+export * from './msgs.js';
+export * from './grpc.js';
+export * from './crypto.js';
+export * from './helpers.js';
+export * from './numbers.js';
+export * from './markets.js';
+export * from './address.js';
+export * from './constants.js';
+export * from './pagination.js';
+export * from './transaction.js';

package/dist/cjs/utils/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utf8.js"), exports);
+__exportStar(require("./buff.js"), exports);
+__exportStar(require("./time.js"), exports);
+__exportStar(require("./msgs.js"), exports);
+__exportStar(require("./grpc.js"), exports);
+__exportStar(require("./crypto.js"), exports);
+__exportStar(require("./helpers.js"), exports);
+__exportStar(require("./numbers.js"), exports);
+__exportStar(require("./markets.js"), exports);
+__exportStar(require("./address.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./pagination.js"), exports);
+__exportStar(require("./transaction.js"), exports);

package/dist/cjs/utils/markets.d.ts

@@ -0,0 +1,34 @@
+export declare const getDerivativeMarketTensMultiplier: ({ quoteDecimals, minPriceTickSize, minQuantityTickSize, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    quoteDecimals: number;
+}) => {
+    quantityTensMultiplier: number;
+    priceTensMultiplier: number;
+};
+export declare const getSpotMarketTensMultiplier: ({ baseDecimals, quoteDecimals, minPriceTickSize, minQuantityTickSize, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    baseDecimals: number;
+    quoteDecimals: number;
+}) => {
+    priceTensMultiplier: number;
+    quantityTensMultiplier: number;
+};
+export declare const getDerivativeMarketDecimals: ({ minPriceTickSize, minQuantityTickSize, quoteDecimals, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    quoteDecimals: number;
+}) => {
+    quantityDecimals: number;
+    priceDecimals: number;
+};
+export declare const getSpotMarketDecimals: ({ minPriceTickSize, minQuantityTickSize, baseDecimals, quoteDecimals, }: {
+    minPriceTickSize: number | string;
+    minQuantityTickSize: number | string;
+    baseDecimals: number;
+    quoteDecimals: number;
+}) => {
+    priceDecimals: number;
+    quantityDecimals: number;
+};

package/dist/cjs/utils/markets.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpotMarketDecimals = exports.getDerivativeMarketDecimals = exports.getSpotMarketTensMultiplier = exports.getDerivativeMarketTensMultiplier = void 0;
+const utils_1 = require("@injectivelabs/utils");
+const numbers_js_1 = require("./numbers.js");
+const getDerivativeMarketTensMultiplier = ({ quoteDecimals, minPriceTickSize, minQuantityTickSize, }) => {
+    return {
+        quantityTensMultiplier: (0, numbers_js_1.getTensMultiplier)(minQuantityTickSize),
+        priceTensMultiplier: (0, numbers_js_1.getTensMultiplier)(new utils_1.BigNumber(minPriceTickSize).shiftedBy(-quoteDecimals).toFixed()),
+    };
+};
+exports.getDerivativeMarketTensMultiplier = getDerivativeMarketTensMultiplier;
+const getSpotMarketTensMultiplier = ({ baseDecimals, quoteDecimals, minPriceTickSize, minQuantityTickSize, }) => {
+    return {
+        priceTensMultiplier: (0, numbers_js_1.getTensMultiplier)(new utils_1.BigNumber(minPriceTickSize)
+            .shiftedBy(baseDecimals - quoteDecimals)
+            .toFixed()),
+        quantityTensMultiplier: (0, numbers_js_1.getTensMultiplier)(new utils_1.BigNumber(minQuantityTickSize).shiftedBy(-baseDecimals).toFixed()),
+    };
+};
+exports.getSpotMarketTensMultiplier = getSpotMarketTensMultiplier;
+const getDerivativeMarketDecimals = ({ minPriceTickSize, minQuantityTickSize, quoteDecimals, }) => {
+    return {
+        quantityDecimals: (0, numbers_js_1.getExactDecimalsFromNumber)(minQuantityTickSize),
+        priceDecimals: (0, numbers_js_1.getExactDecimalsFromNumber)(new utils_1.BigNumber(minPriceTickSize).shiftedBy(-quoteDecimals).toFixed()),
+    };
+};
+exports.getDerivativeMarketDecimals = getDerivativeMarketDecimals;
+const getSpotMarketDecimals = ({ minPriceTickSize, minQuantityTickSize, baseDecimals, quoteDecimals, }) => {
+    return {
+        priceDecimals: (0, numbers_js_1.getExactDecimalsFromNumber)(new utils_1.BigNumber(minPriceTickSize)
+            .shiftedBy(baseDecimals - quoteDecimals)
+            .toFixed()),
+        quantityDecimals: (0, numbers_js_1.getExactDecimalsFromNumber)(new utils_1.BigNumber(minQuantityTickSize).shiftedBy(-baseDecimals).toFixed()),
+    };
+};
+exports.getSpotMarketDecimals = getSpotMarketDecimals;

package/dist/cjs/utils/msgs.d.ts

@@ -0,0 +1,2 @@
+import type { Msgs } from '../core/modules/msgs.js';
+export declare const getGasPriceBasedOnMessage: (msgs: Msgs[]) => number;

package/dist/cjs/utils/msgs.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGasPriceBasedOnMessage = void 0;
+const utils_1 = require("@injectivelabs/utils");
+const getGasPriceBasedOnMessage = (msgs) => {
+    const messages = Array.isArray(msgs) ? msgs : [msgs];
+    const messageType = messages[0].toDirectSign().type;
+    if (messageType.includes('MsgPrivilegedExecuteContract')) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_GAS_LIMIT)
+            .times(6)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('MsgExecuteContract')) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_GAS_LIMIT)
+            .times(3)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('exchange')) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_EXCHANGE_LIMIT)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('wasm')) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_GAS_LIMIT)
+            .times(1.5)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('authz')) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_EXCHANGE_LIMIT)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('gov') &&
+        (messageType.includes('MsgDeposit') ||
+            messageType.includes('MsgSubmitProposal'))) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_GAS_LIMIT)
+            .times(15)
+            .times(messages.length)
+            .decimalPlaces(0)
+            .toNumber();
+    }
+    if (messageType.includes('MsgTransfer')) {
+        return (0, utils_1.toBigNumber)(utils_1.DEFAULT_IBC_GAS_LIMIT).times(messages.length).toNumber();
+    }
+    return (0, utils_1.toBigNumber)(utils_1.DEFAULT_GAS_LIMIT).times(messages.length).toNumber();
+};
+exports.getGasPriceBasedOnMessage = getGasPriceBasedOnMessage;

package/dist/cjs/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 };