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

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

@@ -0,0 +1,32 @@
+import { InjectiveExchangeV1Beta1Exchange } from '@injectivelabs/core-proto-ts';
+export declare const TradeExecutionType: {
+    readonly Market: "market";
+    readonly LimitFill: "limitFill";
+    readonly LimitMatchRestingOrder: "limitMatchRestingOrder";
+    readonly LimitMatchNewOrder: "limitMatchNewOrder";
+};
+export type TradeExecutionType = (typeof TradeExecutionType)[keyof typeof TradeExecutionType];
+export declare const TradeExecutionSide: {
+    readonly Maker: "maker";
+    readonly Taker: "taker";
+};
+export type TradeExecutionSide = (typeof TradeExecutionSide)[keyof typeof TradeExecutionSide];
+export declare const TradeDirection: {
+    readonly Buy: "buy";
+    readonly Sell: "sell";
+    readonly Long: "long";
+    readonly Short: "short";
+};
+export type TradeDirection = (typeof TradeDirection)[keyof typeof TradeDirection];
+export type OrderMask = InjectiveExchangeV1Beta1Exchange.OrderMask;
+export declare const OrderMaskMap: {
+    readonly UNUSED: 0;
+    readonly ANY: 1;
+    readonly REGULAR: 2;
+    readonly CONDITIONAL: 4;
+    readonly DIRECTION_BUY_OR_HIGHER: 8;
+    readonly DIRECTION_SELL_OR_LOWER: 16;
+    readonly TYPE_MARKET: 32;
+    readonly TYPE_LIMIT: 64;
+    readonly UNRECOGNIZED: -1;
+};

package/dist/cjs/types/exchange.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderMaskMap = exports.TradeDirection = exports.TradeExecutionSide = exports.TradeExecutionType = void 0;
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+exports.TradeExecutionType = {
+    Market: 'market',
+    LimitFill: 'limitFill',
+    LimitMatchRestingOrder: 'limitMatchRestingOrder',
+    LimitMatchNewOrder: 'limitMatchNewOrder',
+};
+exports.TradeExecutionSide = {
+    Maker: 'maker',
+    Taker: 'taker',
+};
+exports.TradeDirection = {
+    Buy: 'buy',
+    Sell: 'sell',
+    Long: 'long',
+    Short: 'short',
+};
+exports.OrderMaskMap = core_proto_ts_1.InjectiveExchangeV1Beta1Exchange.OrderMask;

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

@@ -0,0 +1,4 @@
+export * from './token.js';
+export * from './exchange.js';
+export type * from './pagination.js';
+export * from './cosmos.js';

package/dist/cjs/types/index.js

@@ -0,0 +1,19 @@
+"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("./token.js"), exports);
+__exportStar(require("./exchange.js"), exports);
+__exportStar(require("./cosmos.js"), exports);

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

@@ -0,0 +1,26 @@
+export interface PaginationOption {
+    key?: string;
+    offset?: number;
+    skip?: number;
+    limit?: number;
+    reverse?: boolean;
+    countTotal?: boolean;
+    endTime?: number;
+    startTime?: number;
+    fromNumber?: number;
+    toNumber?: number;
+}
+export interface PagePagination {
+    next: string | null;
+    prev: string | null;
+    current: string | null;
+}
+export interface Pagination {
+    next: string | null;
+    total: number;
+}
+export interface ExchangePagination {
+    to: number;
+    from: number;
+    total: number;
+}

package/dist/cjs/types/pagination.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,65 @@
+export declare const TokenType: {
+    readonly Ibc: "ibc";
+    readonly Cw20: "cw20";
+    readonly Spl: "spl";
+    readonly Erc20: "erc20";
+    readonly Lp: "lp";
+    readonly Evm: "evm";
+    readonly Native: "native";
+    readonly Symbol: "symbol";
+    readonly TokenFactory: "tokenFactory";
+    readonly InsuranceFund: "insuranceFund";
+    readonly Unknown: "unknown";
+};
+export type TokenType = (typeof TokenType)[keyof typeof TokenType];
+export declare const TokenVerification: {
+    readonly Verified: "verified";
+    readonly Submitted: "submitted";
+    readonly Internal: "internal";
+    readonly External: "external";
+    readonly Unverified: "unverified";
+};
+export type TokenVerification = (typeof TokenVerification)[keyof typeof TokenVerification];
+export declare const TokenSource: {
+    readonly Aptos: "aptos";
+    readonly Solana: "solana";
+    readonly Cosmos: "cosmos";
+    readonly Ethereum: "ethereum";
+    readonly EthereumWh: "ethereum-wormhole";
+    readonly Polygon: "polygon";
+    readonly Klaytn: "klaytn";
+    readonly Arbitrum: "arbitrum";
+    readonly Sui: "sui";
+    readonly Ibc: "ibc";
+    readonly BinanceSmartChain: "binance-smart-chain";
+    readonly Axelar: "axelar";
+};
+export type TokenSource = (typeof TokenSource)[keyof typeof TokenSource];
+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;
+    description?: 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,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSource = exports.TokenVerification = exports.TokenType = void 0;
+exports.TokenType = {
+    Ibc: 'ibc',
+    Cw20: 'cw20',
+    Spl: 'spl',
+    Erc20: 'erc20',
+    Lp: 'lp',
+    Evm: 'evm',
+    Native: 'native',
+    Symbol: 'symbol',
+    TokenFactory: 'tokenFactory',
+    InsuranceFund: 'insuranceFund',
+    Unknown: 'unknown',
+};
+exports.TokenVerification = {
+    Verified: 'verified',
+    Submitted: 'submitted',
+    Internal: 'internal',
+    External: 'external',
+    Unverified: 'unverified',
+};
+exports.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',
+};

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,89 @@
+"use strict";
+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 base_1 = require("@scure/base");
+const viem_1 = require("viem");
+/**
+ * Get injective address from Ethereum hex address
+ *
+ * @param ethAddress string
+ * @returns string
+ */
+const getInjectiveAddress = (ethAddress) => {
+    const addressBuffer = (0, viem_1.toBytes)(ethAddress.toString());
+    return base_1.bech32.encode('inj', base_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(base_1.bech32.fromWords(base_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(base_1.bech32.fromWords(base_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(base_1.bech32.fromWords(base_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(base_1.bech32.fromWords(base_1.bech32.decode(address).words)).toString('hex')}`;
+};
+exports.getAddressFromInjectiveAddress = getAddressFromInjectiveAddress;
+const getChecksumAddress = (ethAddress) => {
+    const lowercasedAddress = ethAddress.toLowerCase().replace('0x', '');
+    const addressHash = (0, viem_1.keccak256)(lowercasedAddress).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,7 @@
+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";

package/dist/cjs/utils/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+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,23 @@
+import type { TypedDataDefinition } from 'viem';
+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: TypedDataDefinition) => `0x${string}`;
+export declare const messageHash: (message: TypedDataDefinition) => `0x${string}`;
+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;
+interface BufferLike {
+    toString(encoding?: string): string;
+}
+export declare const TypedDataUtilsSanitizeData: <T extends object | any[] | bigint | string | number | boolean | null | undefined>(data: T) => T;
+export declare const TypedDataUtilsHashStruct: (primaryType: string, data: any, types: any, _version?: string) => BufferLike;
+export declare const SignTypedDataVersionV4: "V4";
+export type TypedMessageV4 = TypedDataDefinition;
+export {};

package/dist/cjs/utils/crypto.js

@@ -0,0 +1,160 @@
+"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 viem_1 = require("viem");
+const viem_2 = require("viem");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+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;
+// Hash only the domain portion
+const domainHash = (message) => {
+    const domainTypedData = {
+        domain: message.domain,
+        types: message.types,
+        primaryType: 'EIP712Domain',
+        message: {},
+    };
+    return (0, viem_2.hashTypedData)(domainTypedData);
+};
+exports.domainHash = domainHash;
+// Hash only the message portion
+const messageHash = (message) => {
+    const messageTypedData = {
+        domain: {},
+        types: message.types,
+        primaryType: message.primaryType,
+        message: message.message,
+    };
+    return (0, viem_2.hashTypedData)(messageTypedData);
+};
+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, viem_1.keccak256)(Buffer.from(pubKey), 'bytes').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;
+// Create a hashStruct function that mimics the original behavior
+function hashStruct(primaryType, data, types, _version) {
+    if (!data) {
+        throw new Error('Invalid data: data is empty');
+    }
+    // For EIP-712, we need to create a complete structure
+    // The original implementation would hash just the specific part
+    let typedData;
+    if (primaryType === 'EIP712Domain') {
+        // For domain hash, we only need the domain data
+        typedData = {
+            domain: data,
+            types: { EIP712Domain: types.EIP712Domain },
+            primaryType: 'EIP712Domain',
+            message: {},
+        };
+    }
+    else {
+        // For message hash, we need the complete structure
+        // Use the domain data if it's available in types
+        typedData = {
+            domain: types.domain || {},
+            types,
+            primaryType,
+            message: data,
+        };
+    }
+    const hash = (0, viem_2.hashTypedData)(typedData);
+    return {
+        toString: (encoding) => {
+            if (encoding === 'hex') {
+                return hash.slice(2); // Remove 0x prefix for hex string
+            }
+            return hash;
+        },
+    };
+}
+// Maintain backward compatibility with existing exports
+exports.TypedDataUtilsSanitizeData = exports.sanitizeTypedData;
+exports.TypedDataUtilsHashStruct = hashStruct;
+exports.SignTypedDataVersionV4 = '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: () => grpcPkg.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 type { Coin } from '@injectivelabs/ts-types';
+import type { CosmosBaseV1Beta1Coin } from '@injectivelabs/core-proto-ts';
+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;