@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/cjs/types/token.d.ts

@@ -0,0 +1,61 @@
+export declare enum TokenType {
+    Ibc = "ibc",
+    Cw20 = "cw20",
+    Spl = "spl",
+    Erc20 = "erc20",
+    Lp = "lp",
+    Evm = "evm",
+    Native = "native",
+    Symbol = "symbol",
+    TokenFactory = "tokenFactory",
+    InsuranceFund = "insuranceFund",
+    Unknown = "unknown"
+}
+export declare enum TokenVerification {
+    Verified = "verified" /** verified on token-metadata package */,
+    Submitted = "submitted" /** submitted on token-metadata package but not verified */,
+    Internal = "internal" /** verified from on-chain data */,
+    External = "external" /** verified on external source */,
+    Unverified = "unverified" /** unverified on any source */
+}
+export declare enum TokenSource {
+    Aptos = "aptos",
+    Solana = "solana",
+    Cosmos = "cosmos",
+    Ethereum = "ethereum",
+    EthereumWh = "ethereum-wormhole",
+    Polygon = "polygon",
+    Klaytn = "klaytn",
+    Arbitrum = "arbitrum",
+    Sui = "sui",
+    Ibc = "ibc",
+    BinanceSmartChain = "binance-smart-chain",
+    Axelar = "axelar"
+}
+export interface TokenStatic {
+    name: string;
+    logo: string;
+    symbol: string;
+    decimals: number;
+    coinGeckoId: string;
+    denom: string;
+    address: string;
+    tokenType: TokenType;
+    tokenVerification: TokenVerification;
+    isNative?: boolean;
+    source?: TokenSource;
+    hash?: string;
+    path?: string;
+    channelId?: string;
+    baseDenom?: string;
+    externalLogo?: string;
+    overrideSymbol?: string;
+}
+export interface TokenMeta {
+    name: string;
+    logo: string;
+    symbol: string;
+    decimals: number;
+    tokenType: TokenType;
+    coinGeckoId: string;
+}

package/dist/cjs/types/token.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSource = exports.TokenVerification = exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    TokenType["Ibc"] = "ibc";
+    TokenType["Cw20"] = "cw20";
+    TokenType["Spl"] = "spl";
+    TokenType["Erc20"] = "erc20";
+    TokenType["Lp"] = "lp";
+    TokenType["Evm"] = "evm";
+    TokenType["Native"] = "native";
+    TokenType["Symbol"] = "symbol";
+    TokenType["TokenFactory"] = "tokenFactory";
+    TokenType["InsuranceFund"] = "insuranceFund";
+    TokenType["Unknown"] = "unknown";
+})(TokenType || (exports.TokenType = TokenType = {}));
+var TokenVerification;
+(function (TokenVerification) {
+    TokenVerification["Verified"] = "verified"; /** verified on token-metadata package */
+    TokenVerification["Submitted"] = "submitted"; /** submitted on token-metadata package but not verified */
+    TokenVerification["Internal"] = "internal"; /** verified from on-chain data */
+    TokenVerification["External"] = "external"; /** verified on external source */
+    TokenVerification["Unverified"] = "unverified"; /** unverified on any source */
+})(TokenVerification || (exports.TokenVerification = TokenVerification = {}));
+var TokenSource;
+(function (TokenSource) {
+    TokenSource["Aptos"] = "aptos";
+    TokenSource["Solana"] = "solana";
+    TokenSource["Cosmos"] = "cosmos";
+    TokenSource["Ethereum"] = "ethereum";
+    TokenSource["EthereumWh"] = "ethereum-wormhole";
+    TokenSource["Polygon"] = "polygon";
+    TokenSource["Klaytn"] = "klaytn";
+    TokenSource["Arbitrum"] = "arbitrum";
+    TokenSource["Sui"] = "sui";
+    TokenSource["Ibc"] = "ibc";
+    TokenSource["BinanceSmartChain"] = "binance-smart-chain";
+    TokenSource["Axelar"] = "axelar";
+})(TokenSource || (exports.TokenSource = TokenSource = {}));

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

@@ -0,0 +1,41 @@
+/**
+ * Get injective address from Ethereum hex address
+ *
+ * @param ethAddress string
+ * @returns string
+ */
+export declare const getInjectiveAddress: (ethAddress: string) => string;
+/**
+ * Get ethereum address from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+export declare const getEthereumAddress: (injectiveAddress: string) => string;
+/**
+ * Get ethereum address from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+export declare const getInjectiveAddressFromSubaccountId: (subaccountId: string) => string;
+/**
+ * Get default subaccount id from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+export declare const getDefaultSubaccountId: (injectiveAddress: string) => string;
+/**
+ * Get subaccount id from injective bech32 address and an index (defaults to 0)
+ * @param injectiveAddress string
+ * @param nonce number
+ * @returns string
+ */
+export declare const getSubaccountId: (injectiveAddress: string, nonce?: number) => string;
+/** @deprecated - use getEthereumAddress */
+export declare const getAddressFromInjectiveAddress: (address: string) => string;
+export declare const getChecksumAddress: (ethAddress: string) => string;
+export declare const isCw20ContractAddress: (address: string) => boolean;
+export declare const addHexPrefix: (hex: string) => string;
+export declare const removeHexPrefix: (hex: string) => string;

package/dist/cjs/utils/address.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeHexPrefix = exports.addHexPrefix = exports.isCw20ContractAddress = exports.getChecksumAddress = exports.getAddressFromInjectiveAddress = exports.getSubaccountId = exports.getDefaultSubaccountId = exports.getInjectiveAddressFromSubaccountId = exports.getEthereumAddress = exports.getInjectiveAddress = void 0;
+const bech32_1 = require("bech32");
+const ethereumjs_util_1 = require("ethereumjs-util");
+const keccak256_1 = __importDefault(require("keccak256"));
+/**
+ * Get injective address from Ethereum hex address
+ *
+ * @param ethAddress string
+ * @returns string
+ */
+const getInjectiveAddress = (ethAddress) => {
+    const addressBuffer = ethereumjs_util_1.Address.fromString(ethAddress.toString()).toBuffer();
+    return bech32_1.bech32.encode('inj', bech32_1.bech32.toWords(addressBuffer));
+};
+exports.getInjectiveAddress = getInjectiveAddress;
+/**
+ * Get ethereum address from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+const getEthereumAddress = (injectiveAddress) => {
+    if (injectiveAddress.startsWith('0x')) {
+        return injectiveAddress;
+    }
+    return `0x${Buffer.from(bech32_1.bech32.fromWords(bech32_1.bech32.decode(injectiveAddress).words)).toString('hex')}`;
+};
+exports.getEthereumAddress = getEthereumAddress;
+/**
+ * Get ethereum address from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+const getInjectiveAddressFromSubaccountId = (subaccountId) => {
+    const ethAddress = subaccountId.slice(0, 42);
+    return (0, exports.getInjectiveAddress)(ethAddress);
+};
+exports.getInjectiveAddressFromSubaccountId = getInjectiveAddressFromSubaccountId;
+/**
+ * Get default subaccount id from injective bech32 address
+ *
+ * @param injectiveAddress string
+ * @returns string
+ */
+const getDefaultSubaccountId = (injectiveAddress) => {
+    return `0x${Buffer.from(bech32_1.bech32.fromWords(bech32_1.bech32.decode(injectiveAddress).words)).toString('hex')}${'0'.repeat(24)}`;
+};
+exports.getDefaultSubaccountId = getDefaultSubaccountId;
+/**
+ * Get subaccount id from injective bech32 address and an index (defaults to 0)
+ * @param injectiveAddress string
+ * @param nonce number
+ * @returns string
+ */
+const getSubaccountId = (injectiveAddress, nonce = 0) => {
+    return `0x${Buffer.from(bech32_1.bech32.fromWords(bech32_1.bech32.decode(injectiveAddress).words)).toString('hex')}${'0'.repeat(23)}${nonce}`;
+};
+exports.getSubaccountId = getSubaccountId;
+/** @deprecated - use getEthereumAddress */
+const getAddressFromInjectiveAddress = (address) => {
+    if (address.startsWith('0x')) {
+        return address;
+    }
+    return `0x${Buffer.from(bech32_1.bech32.fromWords(bech32_1.bech32.decode(address).words)).toString('hex')}`;
+};
+exports.getAddressFromInjectiveAddress = getAddressFromInjectiveAddress;
+const getChecksumAddress = (ethAddress) => {
+    const lowercasedAddress = ethAddress.toLowerCase().replace('0x', '');
+    const addressHash = (0, keccak256_1.default)(lowercasedAddress)
+        .toString('hex')
+        .replace('0x', '');
+    let checksumAddress = '0x';
+    for (let i = 0; i < lowercasedAddress.length; i++) {
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += lowercasedAddress[i].toUpperCase();
+        }
+        else {
+            checksumAddress += lowercasedAddress[i];
+        }
+    }
+    return checksumAddress;
+};
+exports.getChecksumAddress = getChecksumAddress;
+const isCw20ContractAddress = (address) => address.length === 42 && address.startsWith('inj');
+exports.isCw20ContractAddress = isCw20ContractAddress;
+const addHexPrefix = (hex) => hex.startsWith('0x') ? hex : `0x${hex}`;
+exports.addHexPrefix = addHexPrefix;
+const removeHexPrefix = (hex) => hex.startsWith('0x') ? hex.slice(2) : hex;
+exports.removeHexPrefix = removeHexPrefix;

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

@@ -0,0 +1,2 @@
+export declare const hexToBuff: (hex: string) => Buffer<ArrayBuffer>;
+export declare const hexToBase64: (hex: string) => string;

package/dist/cjs/utils/buff.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBase64 = exports.hexToBuff = void 0;
+const hexToBuff = (hex) => {
+    return Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex');
+};
+exports.hexToBuff = hexToBuff;
+const hexToBase64 = (hex) => {
+    return Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex').toString('base64');
+};
+exports.hexToBase64 = hexToBase64;

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

@@ -0,0 +1,9 @@
+import { DEFAULT_STD_FEE, DEFAULT_STD_FEE_BY_DENOM } from '@injectivelabs/utils';
+export declare const BECH32_PUBKEY_ACC_PREFIX = "injpub";
+export declare const BECH32_PUBKEY_VAL_PREFIX = "injvaloperpub";
+export declare const BECH32_PUBKEY_CONS_PREFIX = "injvalconspub";
+export declare const BECH32_ADDR_ACC_PREFIX = "inj";
+export declare const BECH32_ADDR_VAL_PREFIX = "injvaloper";
+export declare const BECH32_ADDR_CONS_PREFIX = "injvalcons";
+export declare const DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/0";
+export { DEFAULT_STD_FEE, DEFAULT_STD_FEE_BY_DENOM };

package/dist/cjs/utils/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STD_FEE_BY_DENOM = exports.DEFAULT_STD_FEE = exports.DEFAULT_DERIVATION_PATH = exports.BECH32_ADDR_CONS_PREFIX = exports.BECH32_ADDR_VAL_PREFIX = exports.BECH32_ADDR_ACC_PREFIX = exports.BECH32_PUBKEY_CONS_PREFIX = exports.BECH32_PUBKEY_VAL_PREFIX = exports.BECH32_PUBKEY_ACC_PREFIX = void 0;
+const utils_1 = require("@injectivelabs/utils");
+Object.defineProperty(exports, "DEFAULT_STD_FEE", { enumerable: true, get: function () { return utils_1.DEFAULT_STD_FEE; } });
+Object.defineProperty(exports, "DEFAULT_STD_FEE_BY_DENOM", { enumerable: true, get: function () { return utils_1.DEFAULT_STD_FEE_BY_DENOM; } });
+exports.BECH32_PUBKEY_ACC_PREFIX = 'injpub';
+exports.BECH32_PUBKEY_VAL_PREFIX = 'injvaloperpub';
+exports.BECH32_PUBKEY_CONS_PREFIX = 'injvalconspub';
+exports.BECH32_ADDR_ACC_PREFIX = 'inj';
+exports.BECH32_ADDR_VAL_PREFIX = 'injvaloper';
+exports.BECH32_ADDR_CONS_PREFIX = 'injvalcons';
+exports.DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/0";

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

@@ -0,0 +1,19 @@
+import { TypedMessage, MessageTypes, SignTypedDataVersion } from '@metamask/eth-sig-util';
+export declare const hashToHex: (data: string) => string;
+export declare const sha256: (data: Uint8Array) => Uint8Array;
+export declare const ripemd160: (data: Uint8Array) => Uint8Array;
+export declare const privateKeyToPublicKey: (privateKey: Uint8Array) => Uint8Array;
+export declare const privateKeyHashToPublicKey: (privateKeyHash: string) => Uint8Array;
+export declare const privateKeyToPublicKeyBase64: (privateKey: Uint8Array) => string;
+export declare const privateKeyHashToPublicKeyBase64: (privateKeyHash: string) => string;
+export declare const domainHash: (message: any) => Buffer<ArrayBufferLike>;
+export declare const messageHash: (message: any) => Buffer<ArrayBufferLike>;
+export declare function uint8ArrayToHex(arr: Uint8Array): string;
+export declare function hexToUnit8Array(str: string): Uint8Array<ArrayBuffer>;
+export declare function decompressPubKey(startsWith02Or03: string): string;
+export declare const publicKeyToAddress: (pubKey: Uint8Array, sanitize?: boolean) => Uint8Array;
+export declare const sanitizeTypedData: <T extends object | any[] | bigint | string | number | boolean | null | undefined>(data: T) => T;
+export declare const TypedDataUtilsSanitizeData: <T extends MessageTypes>(data: TypedMessage<T>) => TypedMessage<T>;
+export declare const TypedDataUtilsHashStruct: (primaryType: string, data: Record<string, unknown>, types: Record<string, import("@metamask/eth-sig-util").MessageTypeProperty[]>, version: SignTypedDataVersion.V3 | SignTypedDataVersion.V4) => Buffer;
+export declare const SignTypedDataVersionV4 = SignTypedDataVersion.V4;
+export type TypedMessageV4 = TypedMessage<MessageTypes>;

package/dist/cjs/utils/crypto.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignTypedDataVersionV4 = exports.TypedDataUtilsHashStruct = exports.TypedDataUtilsSanitizeData = exports.sanitizeTypedData = exports.publicKeyToAddress = exports.messageHash = exports.domainHash = exports.privateKeyHashToPublicKeyBase64 = exports.privateKeyToPublicKeyBase64 = exports.privateKeyHashToPublicKey = exports.privateKeyToPublicKey = exports.ripemd160 = exports.sha256 = exports.hashToHex = void 0;
+exports.uint8ArrayToHex = uint8ArrayToHex;
+exports.hexToUnit8Array = hexToUnit8Array;
+exports.decompressPubKey = decompressPubKey;
+// import CryptoEs from 'crypto-es'
+const crypto_js_1 = __importDefault(require("crypto-js"));
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const keccak256_1 = __importDefault(require("keccak256"));
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const hashToHex = (data) => {
+    return crypto_js_1.default.SHA256(crypto_js_1.default.enc.Base64.parse(data))
+        .toString()
+        .toUpperCase();
+};
+exports.hashToHex = hashToHex;
+const sha256 = (data) => {
+    const wordArray = crypto_js_1.default.lib.WordArray.create(data);
+    const hash = crypto_js_1.default.SHA256(wordArray);
+    return Uint8Array.from(Buffer.from(hash.toString(), 'hex'));
+};
+exports.sha256 = sha256;
+const ripemd160 = (data) => {
+    const wordArray = crypto_js_1.default.lib.WordArray.create(data);
+    const hash = crypto_js_1.default.RIPEMD160(wordArray);
+    return Uint8Array.from(Buffer.from(hash.toString(), 'hex'));
+};
+exports.ripemd160 = ripemd160;
+const privateKeyToPublicKey = (privateKey) => {
+    return secp256k1_1.secp256k1.getPublicKey(privateKey, true);
+};
+exports.privateKeyToPublicKey = privateKeyToPublicKey;
+const privateKeyHashToPublicKey = (privateKeyHash) => {
+    const privateKey = privateKeyHash.startsWith('0x')
+        ? privateKeyHash.slice(2)
+        : privateKeyHash;
+    return secp256k1_1.secp256k1.getPublicKey(Buffer.from(privateKey, 'hex'), true);
+};
+exports.privateKeyHashToPublicKey = privateKeyHashToPublicKey;
+const privateKeyToPublicKeyBase64 = (privateKey) => {
+    return Buffer.from((0, exports.privateKeyToPublicKey)(privateKey)).toString('base64');
+};
+exports.privateKeyToPublicKeyBase64 = privateKeyToPublicKeyBase64;
+const privateKeyHashToPublicKeyBase64 = (privateKeyHash) => {
+    return Buffer.from((0, exports.privateKeyHashToPublicKey)(privateKeyHash)).toString('base64');
+};
+exports.privateKeyHashToPublicKeyBase64 = privateKeyHashToPublicKeyBase64;
+const domainHash = (message) => eth_sig_util_1.TypedDataUtils.hashStruct('EIP712Domain', message.domain, message.types, eth_sig_util_1.SignTypedDataVersion.V4);
+exports.domainHash = domainHash;
+const messageHash = (message) => eth_sig_util_1.TypedDataUtils.hashStruct(message.primaryType, message.message, message.types, eth_sig_util_1.SignTypedDataVersion.V4);
+exports.messageHash = messageHash;
+function uint8ArrayToHex(arr) {
+    return Buffer.from(arr).toString('hex');
+}
+function hexToUnit8Array(str) {
+    return new Uint8Array(Buffer.from(str, 'hex'));
+}
+function decompressPubKey(startsWith02Or03) {
+    const testBuffer = Buffer.from(startsWith02Or03, 'hex');
+    if (testBuffer.length === 64)
+        startsWith02Or03 = '04' + startsWith02Or03;
+    const point = secp256k1_1.secp256k1.ProjectivePoint.fromHex(Buffer.from(testBuffer).toString('hex'));
+    const decompressed = point.toHex(false);
+    if (!decompressed.startsWith('04'))
+        return decompressed;
+    return decompressed.slice(2);
+}
+const publicKeyToAddress = function (pubKey, sanitize = false) {
+    if (sanitize && pubKey.length !== 64) {
+        pubKey = secp256k1_1.secp256k1.ProjectivePoint.fromHex(pubKey)
+            .toRawBytes(false)
+            .slice(1);
+    }
+    if (pubKey.length !== 64) {
+        throw new Error('Expected pubKey to be of length 64');
+    }
+    return (0, keccak256_1.default)(Buffer.from(pubKey)).subarray(-20);
+};
+exports.publicKeyToAddress = publicKeyToAddress;
+const sanitizeTypedData = (data) => {
+    switch (Object.prototype.toString.call(data)) {
+        case '[object Object]': {
+            const entries = Object.keys(data).map((k) => [
+                k,
+                (0, exports.sanitizeTypedData)(data[k]),
+            ]);
+            return Object.fromEntries(entries);
+        }
+        case '[object Array]':
+            return data.map((v) => (0, exports.sanitizeTypedData)(v));
+        case '[object BigInt]':
+            return data.toString();
+        default:
+            return data;
+    }
+};
+exports.sanitizeTypedData = sanitizeTypedData;
+exports.TypedDataUtilsSanitizeData = eth_sig_util_1.TypedDataUtils.sanitizeData;
+exports.TypedDataUtilsHashStruct = eth_sig_util_1.TypedDataUtils.hashStruct;
+exports.SignTypedDataVersionV4 = eth_sig_util_1.SignTypedDataVersion.V4;

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

@@ -0,0 +1,4 @@
+import * as grpcPkg from '@injectivelabs/grpc-web';
+declare const grpc: typeof grpcPkg.grpc;
+export declare const getGrpcTransport: () => import("@injectivelabs/grpc-web").grpc.TransportFactory;
+export { grpc, grpcPkg };

package/dist/cjs/utils/grpc.js

@@ -0,0 +1,56 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcPkg = exports.grpc = exports.getGrpcTransport = void 0;
+const grpcPkg = __importStar(require("@injectivelabs/grpc-web"));
+exports.grpcPkg = grpcPkg;
+const grpc_web_node_http_transport_1 = require("@injectivelabs/grpc-web-node-http-transport");
+const grpc_web_react_native_transport_1 = require("@injectivelabs/grpc-web-react-native-transport");
+const helpers_js_1 = require("./helpers.js");
+const grpc = grpcPkg.grpc ??
+    grpcPkg.default
+        .grpc ??
+    grpcPkg;
+exports.grpc = grpc;
+const getGrpcTransport = () => {
+    if ((0, helpers_js_1.isReactNative)()) {
+        return (0, grpc_web_react_native_transport_1.ReactNativeTransport)({ withCredentials: true });
+    }
+    if ((0, helpers_js_1.isNode)()) {
+        return (0, grpc_web_node_http_transport_1.NodeHttpTransport)();
+    }
+    return grpc.CrossBrowserHttpTransport({ withCredentials: false });
+};
+exports.getGrpcTransport = getGrpcTransport;

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

@@ -0,0 +1,24 @@
+import { CosmosBaseV1Beta1Coin } from '@injectivelabs/core-proto-ts';
+import { Coin } from '@injectivelabs/ts-types';
+export declare const isServerSide: () => boolean;
+export declare const isReactNative: () => boolean;
+export declare const isNode: () => boolean;
+export declare const isBrowser: () => boolean;
+export declare const objectToJson: (object: Record<string, any>, params?: {
+    replacer?: any;
+    indentation?: number;
+} | undefined) => string;
+export declare const protoObjectToJson: (object: any, params?: {
+    replacer?: any;
+    indentation?: number;
+} | undefined) => string;
+export declare const grpcCoinToUiCoin: (coin: CosmosBaseV1Beta1Coin.Coin) => Coin;
+export declare const uint8ArrayToString: (string: string | Uint8Array | null | undefined) => string;
+export declare const sortObjectByKeysWithReduce: <T>(obj: T) => T;
+export declare const sortObjectByKeys: <T>(obj: T) => T;
+export declare const getErrorMessage: (error: any, endpoint: string) => string;
+/**
+ * Converts value to it's number representation
+ */
+export declare const hexToNumber: (value: string) => number;
+export declare function isJsonString<T>(str: T): boolean;

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 (e) {
+        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);