@injectivelabs/sdk-ts 1.16.36 → 1.16.38-alpha.0

package/dist/esm/tx-eHoJe09q.js

@@ -0,0 +1,2693 @@
+import * as CosmosTxV1Beta1TxPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/tx/v1beta1/tx_pb";
+import { bytesToHex, hashTypedData, hexToBytes, keccak256, recoverPublicKey, toBytes } from "viem";
+import { BigNumber, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_GAS_LIMIT, HttpRestClient, getDefaultStdFee, getExactDecimalsFromNumber, getSignificantDecimalsFromNumber, getStdFee, getStdFeeFromString, snakeToPascal, toBigNumber, toChainFormat, toHumanReadable } from "@injectivelabs/utils";
+import { ChainErrorModule, ErrorType, GeneralException, HttpRequestException, UnspecifiedErrorCode } from "@injectivelabs/exceptions";
+import { base64, bech32 } from "@scure/base";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import * as GoogleProtobufAnyPb from "@injectivelabs/core-proto-ts-v2/generated/google/protobuf/any_pb";
+import * as InjectiveCryptoV1Beta1Ethsecp256k1KeysPb from "@injectivelabs/core-proto-ts-v2/generated/injective/crypto/v1beta1/ethsecp256k1/keys_pb";
+import CryptoEs from "crypto-js";
+import { generateMnemonic } from "bip39";
+import { ChainId, EvmChainId } from "@injectivelabs/ts-types";
+import { HDNodeWallet, Signature, Wallet, concat, getBytes } from "ethers";
+import * as InjectiveTypesV1Beta1TxExtPb from "@injectivelabs/core-proto-ts-v2/generated/injective/types/v1beta1/tx_ext_pb";
+import * as CosmosBaseV1Beta1CoinPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/base/v1beta1/coin_pb";
+import * as CosmosCryptoSecp256k1KeysPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/crypto/secp256k1/keys_pb";
+import snakecaseKeys from "snakecase-keys";
+import * as InjectiveExchangeV1Beta1TxPb from "@injectivelabs/core-proto-ts-v2/generated/injective/exchange/v1beta1/tx_pb";
+import * as ExchangePb from "@injectivelabs/core-proto-ts-v2/generated/injective/exchange/v1beta1/exchange_pb";
+import { OracleType } from "@injectivelabs/core-proto-ts-v2/generated/injective/oracle/v1beta1/oracle_pb";
+import * as CosmosGovV1GovPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/gov/v1/gov_pb";
+import * as CosmwasmWasmV1TypesPb from "@injectivelabs/core-proto-ts-v2/generated/cosmwasm/wasm/v1/types_pb";
+import * as InjectivePermissionsV1Beta1PermissionsPb from "@injectivelabs/core-proto-ts-v2/generated/injective/permissions/v1beta1/permissions_pb";
+import * as CosmosTxSigningV1Beta1SigningPb from "@injectivelabs/core-proto-ts-v2/generated/cosmos/tx/signing/v1beta1/signing_pb";
+
+//#region src/utils/encoding.ts
+/**
+* Encoding/decoding utilities using industry-standard libraries
+*
+* Uses viem for hex encoding and @scure/base for base64 encoding
+* to ensure compatibility, better performance, and reduce bundle size.
+*
+* These libraries are already dependencies in the project and are
+* battle-tested by millions of developers.
+*/
+/**
+* Convert a hex string to Uint8Array
+* @param hex - Hex string (with or without 0x prefix)
+* @returns Uint8Array
+* @throws Error if hex string is invalid
+*/
+function hexToUint8Array(hex) {
+	if (typeof hex !== "string") throw new Error("Hex string must be a string");
+	if (hex.trim() === "") throw new Error("Hex string cannot be empty");
+	const prefixedHex = hex.startsWith("0x") ? hex : `0x${hex}`;
+	try {
+		return hexToBytes(prefixedHex);
+	} catch (_unused) {
+		throw new Error(`Invalid hex string: ${hex}`);
+	}
+}
+/**
+* Convert a Uint8Array to hex string
+* @param arr - Uint8Array to convert
+* @returns Hex string (without 0x prefix)
+*/
+function uint8ArrayToHex(arr) {
+	return bytesToHex(arr).slice(2);
+}
+/**
+* Convert a base64 string to Uint8Array
+* @param base64String - Base64 encoded string
+* @returns Uint8Array
+* @throws Error if base64 string is invalid
+*/
+function base64ToUint8Array(base64String) {
+	if (typeof base64String !== "string") throw new Error("Base64 string must be a string");
+	if (base64String.trim() === "") throw new Error("Base64 string cannot be empty");
+	try {
+		return base64.decode(base64String);
+	} catch (_unused2) {
+		throw new Error(`Invalid base64 string: ${base64String}`);
+	}
+}
+/**
+* Convert a Uint8Array to base64 string
+* @param arr - Uint8Array to convert
+* @returns Base64 encoded string
+*/
+function uint8ArrayToBase64(arr) {
+	return base64.encode(arr);
+}
+/**
+* Convert a string to Uint8Array using UTF-8 encoding
+* @param str - String to encode
+* @returns Uint8Array
+*/
+function stringToUint8Array(str) {
+	return new TextEncoder().encode(str);
+}
+/**
+* Convert a hex string to Uint8Array (buffer-like)
+* Handles hex strings with or without 0x prefix
+* @param hex - Hex string (with or without 0x prefix)
+* @returns Uint8Array
+*/
+function hexToBuff(hex) {
+	return hexToUint8Array(hex.startsWith("0x") ? hex.slice(2) : hex);
+}
+/**
+* Convert a hex string to base64 string
+* Handles hex strings with or without 0x prefix
+* @param hex - Hex string (with or without 0x prefix)
+* @returns Base64 encoded string
+*/
+function hexToBase64(hex) {
+	return uint8ArrayToBase64(hexToUint8Array(hex.startsWith("0x") ? hex.slice(2) : hex));
+}
+/**
+* Convert a base64 string to UTF-8 string
+* @param base64String - Base64 encoded string
+* @returns Decoded UTF-8 string
+* @throws Error if base64 string is invalid
+*/
+function base64ToUtf8(base64String) {
+	return toUtf8(base64ToUint8Array(base64String));
+}
+/**
+* Convert a string or Uint8Array to Uint8Array using UTF-8 encoding
+* If input is already Uint8Array, returns it as-is
+* @param str - String or Uint8Array to encode
+* @returns Uint8Array
+*/
+function fromUtf8(str) {
+	if (typeof str !== "string") return str;
+	return stringToUint8Array(str);
+}
+/**
+* Convert a Uint8Array or string to string using UTF-8 decoding
+* If input is already a string, returns it as-is
+* @param data - Uint8Array or string to decode
+* @returns Decoded string
+*/
+function toUtf8(data) {
+	if (typeof data === "string") return data;
+	return new TextDecoder().decode(data);
+}
+/**
+* Convert a Uint8Array, string, null, or undefined to string using UTF-8 decoding
+* More robust version that handles null/undefined gracefully
+* @param string - Uint8Array, string, null, or undefined to decode
+* @returns Decoded string (empty string if input is null/undefined)
+*/
+function uint8ArrayToString(string) {
+	if (!string) return "";
+	if (string.constructor !== Uint8Array) return string;
+	return new TextDecoder().decode(string);
+}
+/**
+* Convert binary data (string or Uint8Array) to base64 string
+* If input is already a string, returns it as-is
+* @param data - String or Uint8Array to encode
+* @returns Base64 encoded string
+*/
+function binaryToBase64(data) {
+	return typeof data === "string" ? data : uint8ArrayToBase64(data);
+}
+/**
+* Convert a JSON object to base64 string
+* @param data - JSON object to encode
+* @returns Base64 encoded string
+*/
+function toBase64(data) {
+	return uint8ArrayToBase64(stringToUint8Array(JSON.stringify(data)));
+}
+/**
+* Convert a base64 string to JSON object
+* @param payload - Base64 encoded string
+* @returns Decoded JSON object
+* @throws Error if base64 string is invalid or contains invalid JSON
+*/
+function fromBase64(payload) {
+	if (typeof payload !== "string") throw new Error("Base64 payload must be a string");
+	if (payload.trim() === "") throw new Error("Base64 payload cannot be empty");
+	try {
+		const decoded = new TextDecoder().decode(base64ToUint8Array(payload));
+		return JSON.parse(decoded);
+	} catch (_unused3) {
+		throw new Error(`Failed to decode base64 JSON: ${payload}`);
+	}
+}
+/**
+* Concatenate multiple Uint8Arrays into a single Uint8Array
+* Replacement for Buffer.concat()
+* @param arrays - Array of Uint8Arrays to concatenate
+* @returns Concatenated Uint8Array
+*/
+function concatUint8Arrays(arrays) {
+	if (arrays.length === 0) return new Uint8Array(0);
+	const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/constants.ts
+const BECH32_PUBKEY_ACC_PREFIX = "injpub";
+const BECH32_PUBKEY_VAL_PREFIX = "injvaloperpub";
+const BECH32_PUBKEY_CONS_PREFIX = "injvalconspub";
+const BECH32_ADDR_ACC_PREFIX = "inj";
+const BECH32_ADDR_VAL_PREFIX = "injvaloper";
+const BECH32_ADDR_CONS_PREFIX = "injvalcons";
+const DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/0";
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.98.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/core/accounts/Address.ts
+/**
+* @category Utility Classes
+*/
+var Address = class Address {
+	constructor(bech32Address) {
+		_defineProperty(this, "bech32Address", void 0);
+		this.bech32Address = bech32Address;
+	}
+	compare(address) {
+		return this.bech32Address === address.bech32Address;
+	}
+	get address() {
+		return this.bech32Address;
+	}
+	/**
+	* Create an address instance from a bech32-encoded address and a prefix
+	* @param {string} bech32 bech32-encoded address
+	* @param {string} prefix
+	* @return {Address}
+	* @throws {Error} if bech is not a valid bech32-encoded address
+	*/
+	static fromBech32(bech, prefix = BECH32_ADDR_ACC_PREFIX) {
+		try {
+			const address = uint8ArrayToHex(bech32.fromWords(bech32.decode(bech).words));
+			const addressBuffer = toBytes((address.startsWith("0x") ? address : `0x${address}`).toString());
+			return new Address(bech32.encode(prefix, bech32.toWords(addressBuffer)));
+		} catch (e) {
+			throw new GeneralException(new Error(e), { type: ErrorType.ValidationError });
+		}
+	}
+	/**
+	* Create an address instance from an ethereum address
+	* @param {string} hex Ethereum address
+	* @param {string} prefix
+	* @return {Address}
+	* @throws {Error} if bech is not a valid bech32-encoded address
+	*/
+	static fromHex(hex, prefix = BECH32_ADDR_ACC_PREFIX) {
+		const addressBuffer = toBytes((hex.startsWith("0x") ? hex : `0x${hex}`).toString());
+		return new Address(bech32.encode(prefix, bech32.toWords(addressBuffer)));
+	}
+	/**
+	* Convert an address instance to a bech32-encoded account address
+	* @param {string} prefix
+	* @returns {string}
+	*/
+	toBech32(prefix = BECH32_ADDR_ACC_PREFIX) {
+		const address = this.toHex();
+		const addressBuffer = toBytes(address.startsWith("0x") ? address : `0x${address}`);
+		return bech32.encode(prefix, bech32.toWords(addressBuffer));
+	}
+	/**
+	* Return a bech32-encoded account address
+	* @return {string}
+	* @throws {Error} if this address is not a valid account address
+	* */
+	toAccountAddress() {
+		return this.toBech32(BECH32_ADDR_ACC_PREFIX);
+	}
+	/**
+	* Return a bech32-encoded validator address
+	* @return {string}
+	* @throws {Error} if this address is not a valid validator address
+	* */
+	toValidatorAddress() {
+		return this.toBech32(BECH32_ADDR_VAL_PREFIX);
+	}
+	/**
+	* Return a bech32-encoded consensus address
+	* @return {string}
+	* @throws {Error} if this address is not a valid consensus address
+	* */
+	toConsensusAddress() {
+		return this.toBech32(BECH32_ADDR_CONS_PREFIX);
+	}
+	/**
+	* Return a hex representation of address
+	* @return {string}
+	* @throws {Error} if this address is not a valid account address
+	* */
+	toHex() {
+		const { bech32Address } = this;
+		const address = uint8ArrayToHex(bech32.fromWords(bech32.decode(bech32Address).words));
+		return address.startsWith("0x") ? address : `0x${address}`;
+	}
+	/**
+	* Return a subaccount address from the given bech32 encoded address
+	* @param {number} index the subaccount index
+	* @return {string}
+	* @throws {Error} if this address is not a valid account address
+	* */
+	getSubaccountId(index = 0) {
+		const suffix = "0".repeat(23) + index;
+		return `${this.toHex()}${suffix}`;
+	}
+	/**
+	* Return a ethereum address from the given bech32 encoded address
+	* @return {string}
+	* @throws {Error} if this address is not a valid account address
+	* */
+	getEthereumAddress() {
+		return this.toHex();
+	}
+};
+
+//#endregion
+//#region src/utils/crypto.ts
+/**
+* Hash data to hex string using SHA256
+* @param data - Base64 encoded string to hash
+* @returns Uppercase hex string
+*/
+const hashToHex = (data) => {
+	return CryptoEs.SHA256(CryptoEs.enc.Base64.parse(data)).toString().toUpperCase();
+};
+/**
+* Compute SHA256 hash of Uint8Array data
+* @param data - Data to hash
+* @returns SHA256 hash as Uint8Array
+*/
+const sha256 = (data) => {
+	const wordArray = CryptoEs.lib.WordArray.create(data);
+	return hexToUint8Array(CryptoEs.SHA256(wordArray).toString());
+};
+/**
+* Compute RIPEMD160 hash of Uint8Array data
+* @param data - Data to hash
+* @returns RIPEMD160 hash as Uint8Array
+*/
+const ripemd160 = (data) => {
+	const wordArray = CryptoEs.lib.WordArray.create(data);
+	return hexToUint8Array(CryptoEs.RIPEMD160(wordArray).toString());
+};
+/**
+* Derive public key from private key
+* @param privateKey - Private key as Uint8Array
+* @returns Compressed public key (33 bytes)
+*/
+const privateKeyToPublicKey = (privateKey) => {
+	return secp256k1.getPublicKey(privateKey, true);
+};
+/**
+* Derive public key from private key hash (hex string)
+* @param privateKeyHash - Private key as hex string (with or without 0x prefix)
+* @returns Compressed public key (33 bytes)
+*/
+const privateKeyHashToPublicKey = (privateKeyHash) => {
+	const privateKey = privateKeyHash.startsWith("0x") ? privateKeyHash.slice(2) : privateKeyHash;
+	return secp256k1.getPublicKey(hexToUint8Array(privateKey), true);
+};
+/**
+* Derive public key from private key and encode as base64
+* @param privateKey - Private key as Uint8Array
+* @returns Base64 encoded compressed public key
+*/
+const privateKeyToPublicKeyBase64 = (privateKey) => {
+	return uint8ArrayToBase64(privateKeyToPublicKey(privateKey));
+};
+/**
+* Derive public key from private key hash and encode as base64
+* @param privateKeyHash - Private key as hex string (with or without 0x prefix)
+* @returns Base64 encoded compressed public key
+*/
+const privateKeyHashToPublicKeyBase64 = (privateKeyHash) => {
+	return uint8ArrayToBase64(privateKeyHashToPublicKey(privateKeyHash));
+};
+/**
+* Hash only the domain portion of EIP-712 typed data
+* @param message - EIP-712 typed data definition
+* @returns Hash of the domain
+*/
+const domainHash = (message) => {
+	return hashTypedData({
+		domain: message.domain,
+		types: message.types,
+		primaryType: "EIP712Domain",
+		message: {}
+	});
+};
+/**
+* Hash only the message portion of EIP-712 typed data
+* @param message - EIP-712 typed data definition
+* @returns Hash of the message
+*/
+const messageHash = (message) => {
+	return hashTypedData({
+		domain: {},
+		types: message.types,
+		primaryType: message.primaryType,
+		message: message.message
+	});
+};
+/**
+* Decompress a compressed public key (starts with 02 or 03)
+* If the key is already 64 bytes, prepends '04' to make it uncompressed
+* @param startsWith02Or03 - Compressed public key hex string
+* @returns Decompressed public key hex string (without 04 prefix)
+*/
+function decompressPubKey(startsWith02Or03) {
+	if (hexToUint8Array(startsWith02Or03).length === 64) startsWith02Or03 = "04" + startsWith02Or03;
+	const decompressed = secp256k1.ProjectivePoint.fromHex(startsWith02Or03).toHex(false);
+	if (!decompressed.startsWith("04")) return decompressed;
+	return decompressed.slice(2);
+}
+/**
+* Convert public key to Ethereum address using Keccak256
+* @param pubKey - Public key as Uint8Array (64 bytes uncompressed or 33 bytes compressed)
+* @param sanitize - If true, will decompress compressed keys before hashing
+* @returns Ethereum address (20 bytes)
+* @throws Error if pubKey length is not 64 after sanitization
+*/
+const publicKeyToAddress = function(pubKey, sanitize = false) {
+	if (sanitize && pubKey.length !== 64) pubKey = secp256k1.ProjectivePoint.fromHex(pubKey).toRawBytes(false).slice(1);
+	if (pubKey.length !== 64) throw new Error("Expected pubKey to be of length 64");
+	return keccak256(pubKey, "bytes").subarray(-20);
+};
+/**
+* Sanitize typed data by converting BigInt values to strings
+* Recursively processes objects and arrays
+* @param data - Data to sanitize (can be object, array, or primitive)
+* @returns Sanitized data with BigInt values converted to strings
+*/
+const sanitizeTypedData = (data) => {
+	switch (Object.prototype.toString.call(data)) {
+		case "[object Object]": {
+			const entries = Object.keys(data).map((k) => [k, sanitizeTypedData(data[k])]);
+			return Object.fromEntries(entries);
+		}
+		case "[object Array]": return data.map((v) => sanitizeTypedData(v));
+		case "[object BigInt]": return data.toString();
+		default: return data;
+	}
+};
+function hashStruct(primaryType, data, types, _version) {
+	if (!data) throw new Error("Invalid data: data is empty");
+	let typedData;
+	if (primaryType === "EIP712Domain") typedData = {
+		domain: data,
+		types: { EIP712Domain: types.EIP712Domain },
+		primaryType: "EIP712Domain",
+		message: {}
+	};
+	else typedData = {
+		domain: types.domain || {},
+		types,
+		primaryType,
+		message: data
+	};
+	const hash = hashTypedData(typedData);
+	return { toString: (encoding) => {
+		if (encoding === "hex") return hash.slice(2);
+		return hash;
+	} };
+}
+const TypedDataUtilsSanitizeData = sanitizeTypedData;
+const TypedDataUtilsHashStruct = hashStruct;
+const SignTypedDataVersionV4 = "V4";
+
+//#endregion
+//#region src/utils/helpers.ts
+const isServerSide = () => typeof window === "undefined";
+const isReactNative = () => {
+	return typeof document === "undefined" && typeof navigator !== "undefined" && navigator.product === "ReactNative";
+};
+const isNode = () => {
+	if (typeof window === "undefined") return true;
+	return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+};
+const isBrowser = () => {
+	if (isReactNative()) return false;
+	if (isNode()) return false;
+	return typeof window !== "undefined";
+};
+const objectToJson = (object, params) => {
+	const { replacer, indentation } = params || {
+		replacer: null,
+		indentation: 2
+	};
+	return JSON.stringify(object, replacer, indentation);
+};
+const protoObjectToJson = (object, params) => {
+	const { replacer, indentation } = params || {
+		replacer: null,
+		indentation: 2
+	};
+	if (object.toObject !== void 0) return JSON.stringify(object.toObject(), replacer, indentation);
+	return objectToJson(object, {
+		replacer,
+		indentation
+	});
+};
+const grpcCoinToUiCoin = (coin) => ({
+	amount: coin.amount,
+	denom: coin.denom
+});
+const sortObjectByKeysWithReduce = (obj) => {
+	if (typeof obj !== "object" || obj === null) return obj;
+	if (Array.isArray(obj)) return obj.map((e) => sortObjectByKeysWithReduce(e)).sort();
+	return Object.keys(obj).sort().reduce((sorted, k) => {
+		const key = k;
+		sorted[key] = sortObjectByKeysWithReduce(obj[key]);
+		return sorted;
+	}, {});
+};
+const sortObjectByKeys = (obj) => {
+	if (typeof obj !== "object" || obj === null) return obj;
+	if (Array.isArray(obj)) return obj.map(sortObjectByKeys);
+	const sortedKeys = Object.keys(obj).sort();
+	const result = {};
+	sortedKeys.forEach((key) => {
+		result[key] = sortObjectByKeys(obj[key]);
+	});
+	return result;
+};
+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;
+};
+/**
+* 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);
+};
+function isJsonString(str) {
+	if (typeof str !== "string") return false;
+	try {
+		JSON.parse(str);
+	} catch (_unused) {
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/utils/numbers.ts
+const $BigNumber = BigNumber.clone({ ROUNDING_MODE: BigNumber.ROUND_DOWN });
+const isNumber = (number) => {
+	if (typeof number === "number") return true;
+	return !isNaN(parseFloat(number));
+};
+const formatNumberToAllowableDecimals = (value, allowableDecimals, roundingMode) => {
+	const decimalPlacesInValue = toBigNumber(getExactDecimalsFromNumber(value));
+	const valueToString = value.toString();
+	if (decimalPlacesInValue.lte(0)) return valueToString;
+	return decimalPlacesInValue.gte(allowableDecimals) ? toBigNumber(valueToString).toFixed(allowableDecimals, roundingMode) : valueToString;
+};
+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);
+};
+const formatAmountToAllowableAmount = (value, tensMultiplier) => {
+	return tensMultiplier < 0 ? formatNumberToAllowableDecimals(value, -tensMultiplier, BigNumber.ROUND_DOWN) : formatNumberToAllowableTensMultiplier(value, tensMultiplier, BigNumber.ROUND_DOWN);
+};
+const formatPriceToAllowablePrice = (value, tensMultiplier) => {
+	return tensMultiplier <= 0 ? formatNumberToAllowableDecimals(value, -tensMultiplier) : formatNumberToAllowableTensMultiplier(value, tensMultiplier);
+};
+/**
+*
+* Legacy function - use formatNumberToAllowableDecimals
+*
+* @param value
+* @param allowableDecimals
+* @returns
+*/
+const formatAmountToAllowableDecimals = (value, allowableDecimals) => {
+	return formatNumberToAllowableDecimals(value, allowableDecimals, BigNumber.ROUND_DOWN);
+};
+/**
+*
+* Legacy function - use formatNumberToAllowableDecimals
+*
+* @param value
+* @param allowableDecimals
+* @returns
+*/
+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
+*/
+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
+*/
+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
+*/
+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
+*/
+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
+*/
+const denomAmountToChainDenomAmountToFixed = ({ value, decimals = 18, tensMultiplier, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const valueToBn = toBigNumber(value).toFixed();
+	const number = denomAmountToChainDenomAmount({
+		value: tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value,
+		decimals
+	});
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const denomAmountFromChainDenomAmountToFixed = ({ value, decimals = 18, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const number = toHumanReadable(value, decimals);
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const derivativeMarginToChainMarginToFixed = ({ value, quoteDecimals = 18, tensMultiplier, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const valueToBn = toBigNumber(value).toFixed();
+	const number = derivativeMarginToChainMargin({
+		value: tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value,
+		quoteDecimals
+	});
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const derivativeMarginFromChainMarginToFixed = ({ value, quoteDecimals = 18, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const number = toHumanReadable(value, quoteDecimals);
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const derivativePriceToChainPriceToFixed = ({ value, tensMultiplier, quoteDecimals = 18, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const valueToBn = toBigNumber(value).toFixed();
+	const number = toChainFormat(tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value, quoteDecimals);
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const derivativePriceFromChainPriceToFixed = ({ value, quoteDecimals = 18, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const number = toHumanReadable(value, quoteDecimals);
+	if (decimalPlaces === void 0) 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
+*/
+const derivativeQuantityToChainQuantity = ({ value }) => new $BigNumber(value);
+/**
+* Amount that the chain requires is in the x format
+* where x is a human readable number stringified
+*/
+const derivativeQuantityToChainQuantityToFixed = ({ value, decimalPlaces = void 0, tensMultiplier, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const valueToBn = toBigNumber(value).toFixed();
+	const number = derivativeQuantityToChainQuantity({ value: tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value });
+	if (decimalPlaces === void 0) 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
+*/
+const derivativeQuantityFromChainQuantity = ({ value }) => new $BigNumber(value);
+/**
+* Amount that the chain requires is in the x format
+* where x is a human readable number stringified
+*/
+const derivativeQuantityFromChainQuantityToFixed = ({ value, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const number = new $BigNumber(value);
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const spotPriceToChainPriceToFixed = ({ value, baseDecimals = 18, quoteDecimals = 6, tensMultiplier, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const valueToBn = toBigNumber(value).toFixed();
+	const number = toChainFormat(tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value, toBigNumber(quoteDecimals).minus(baseDecimals).toNumber());
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const spotPriceFromChainPriceToFixed = ({ value, baseDecimals = 18, quoteDecimals = 6, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const number = toHumanReadable(value, quoteDecimals - baseDecimals);
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const spotQuantityToChainQuantityToFixed = ({ value, baseDecimals = 18, tensMultiplier, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const valueToBn = toBigNumber(value).toFixed();
+	const number = toChainFormat(tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value, baseDecimals);
+	if (decimalPlaces === void 0) 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
+*/
+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
+*/
+const spotQuantityFromChainQuantityToFixed = ({ value, baseDecimals = 18, decimalPlaces = void 0, roundingMode = BigNumber.ROUND_DOWN }) => {
+	const number = toHumanReadable(value, baseDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed(getSignificantDecimalsFromNumber(number), roundingMode);
+};
+/**
+* @deprecated use toHumanReadable from injectivelabs/utils instead
+*/
+const cosmosSdkDecToBigNumber = (number) => new BigNumber(number).dividedBy(new BigNumber(10).pow(18));
+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}
+*/
+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;
+};
+
+//#endregion
+//#region src/utils/address.ts
+/**
+* Get injective address from Ethereum hex address
+*
+* @param ethAddress string
+* @returns string
+*/
+const getInjectiveAddress = (ethAddress) => {
+	const addressBuffer = toBytes(ethAddress.toString());
+	return bech32.encode("inj", bech32.toWords(addressBuffer));
+};
+/**
+* Get ethereum address from injective bech32 address
+*
+* @param injectiveAddress string
+* @returns string
+*/
+const getEthereumAddress = (injectiveAddress) => {
+	if (injectiveAddress.startsWith("0x")) return injectiveAddress;
+	return `0x${uint8ArrayToHex(bech32.fromWords(bech32.decode(injectiveAddress).words))}`;
+};
+/**
+* Get ethereum address from injective bech32 address
+*
+* @param injectiveAddress string
+* @returns string
+*/
+const getInjectiveAddressFromSubaccountId = (subaccountId) => {
+	return getInjectiveAddress(subaccountId.slice(0, 42));
+};
+/**
+* Get default subaccount id from injective bech32 address
+*
+* @param injectiveAddress string
+* @returns string
+*/
+const getDefaultSubaccountId = (injectiveAddress) => {
+	return `0x${uint8ArrayToHex(bech32.fromWords(bech32.decode(injectiveAddress).words))}${"0".repeat(24)}`;
+};
+/**
+* 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${uint8ArrayToHex(bech32.fromWords(bech32.decode(injectiveAddress).words))}${"0".repeat(23)}${nonce}`;
+};
+/** @deprecated - use getEthereumAddress */
+const getAddressFromInjectiveAddress = (address) => {
+	if (address.startsWith("0x")) return address;
+	return `0x${uint8ArrayToHex(bech32.fromWords(bech32.decode(address).words))}`;
+};
+/**
+* Convert Ethereum address to checksummed format (EIP-55)
+* @param ethAddress - Ethereum address (with or without 0x prefix)
+* @returns Checksummed Ethereum address
+*/
+const getChecksumAddress = (ethAddress) => {
+	const lowercasedAddress = ethAddress.toLowerCase().replace("0x", "");
+	const addressHash = keccak256(lowercasedAddress).replace("0x", "");
+	return "0x" + lowercasedAddress.split("").map((char, i) => {
+		return parseInt(addressHash[i], 16) > 7 ? char.toUpperCase() : char;
+	}).join("");
+};
+/**
+* Check if address is a CW20 contract address
+* @param address - Address to check
+* @returns True if address is a CW20 contract address
+*/
+const isCw20ContractAddress = (address) => address.length === 42 && address.startsWith("inj");
+/**
+* Add 0x prefix to hex string if not present
+* @param hex - Hex string
+* @returns Hex string with 0x prefix
+*/
+const addHexPrefix = (hex) => hex.startsWith("0x") ? hex : `0x${hex}`;
+/**
+* Remove 0x prefix from hex string if present
+* @param hex - Hex string
+* @returns Hex string without 0x prefix
+*/
+const removeHexPrefix = (hex) => hex.startsWith("0x") ? hex.slice(2) : hex;
+
+//#endregion
+//#region src/utils/transaction.ts
+const recoverTypedSignaturePubKey = async (data, signature) => {
+	const publicKeyHex = await recoverPublicKey({
+		hash: hashTypedData(data),
+		signature
+	});
+	return `0x${uint8ArrayToHex(secp256k1.ProjectivePoint.fromHex(publicKeyHex.slice(2)).toRawBytes(true))}`;
+};
+
+//#endregion
+//#region src/core/accounts/PublicKey.ts
+/**
+* @category Crypto Utility Classes
+*/
+var PublicKey = class PublicKey {
+	constructor(key, type) {
+		_defineProperty(this, "type", void 0);
+		_defineProperty(this, "key", void 0);
+		this.key = key;
+		this.type = type || "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+	}
+	static fromBase64(publicKey) {
+		return new PublicKey(base64ToUint8Array(publicKey));
+	}
+	static fromBytes(publicKey) {
+		return new PublicKey(publicKey);
+	}
+	static fromHex(pubKey) {
+		return new PublicKey(hexToUint8Array((pubKey.startsWith("0x") ? pubKey.slice(2) : pubKey).toString()));
+	}
+	static fromPrivateKeyHex(privateKey) {
+		const isString = typeof privateKey === "string";
+		const privateKeyHex = isString && privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+		const privateKeyBuff = isString ? hexToUint8Array(privateKeyHex.toString()) : privateKey;
+		return new PublicKey(secp256k1.getPublicKey(privateKeyBuff, true), "/injective.crypto.v1beta1.ethsecp256k1.PubKey");
+	}
+	toPubKeyBytes() {
+		return this.key;
+	}
+	toBase64() {
+		return uint8ArrayToBase64(this.toPubKeyBytes());
+	}
+	toHex() {
+		return uint8ArrayToHex(this.toPubKeyBytes());
+	}
+	/**
+	* Convert the public key to a pubkey in bech32 format.
+	* Note: this does not convert the public key to an address.
+	*/
+	toBech32() {
+		return bech32.encode(BECH32_PUBKEY_ACC_PREFIX, bech32.toWords(hexToUint8Array(this.toHex())));
+	}
+	toAddress() {
+		const decompressedPublicKey = decompressPubKey(this.toHex());
+		const addressBuffer = keccak256(toBytes(decompressedPublicKey.startsWith("0x") ? decompressedPublicKey : "0x" + decompressedPublicKey), "bytes").subarray(-20);
+		return Address.fromHex(uint8ArrayToHex(addressBuffer).toLowerCase());
+	}
+	toProto() {
+		const proto = InjectiveCryptoV1Beta1Ethsecp256k1KeysPb.PubKey.create();
+		proto.key = this.key;
+		return proto;
+	}
+	toAny() {
+		const proto = this.toProto();
+		const message = GoogleProtobufAnyPb.Any.create();
+		message.typeUrl = this.type;
+		message.value = InjectiveCryptoV1Beta1Ethsecp256k1KeysPb.PubKey.toBinary(proto);
+		return message;
+	}
+};
+
+//#endregion
+//#region src/core/tx/utils/helpers.ts
+const createAnyMessage = (msg) => {
+	const message = GoogleProtobufAnyPb.Any.create();
+	message.typeUrl = `${msg.type.startsWith("/") ? "" : "/"}${msg.type}`;
+	message.value = msg.value;
+	return message;
+};
+const createAny = (value, type) => {
+	const message = GoogleProtobufAnyPb.Any.create();
+	message.typeUrl = type;
+	message.value = value;
+	return message;
+};
+const getInjectiveSignerAddress = (address) => {
+	if (!address) return "";
+	if (address.startsWith("inj")) return address;
+	if (address.startsWith("0x")) return getInjectiveAddress(address);
+	return address;
+};
+const getEthereumSignerAddress = (address) => {
+	if (!address) return "";
+	if (address.startsWith("0x")) return address;
+	if (address.startsWith("inj")) return getEthereumAddress(address);
+	return `0x${address}`;
+};
+
+//#endregion
+//#region src/core/tx/utils/tx.ts
+const getPublicKey = ({ chainId, key }) => {
+	if (typeof key !== "string") return key;
+	let proto;
+	let path;
+	let baseProto;
+	if (chainId.startsWith("injective")) {
+		proto = CosmosCryptoSecp256k1KeysPb.PubKey.create();
+		baseProto = CosmosCryptoSecp256k1KeysPb.PubKey;
+		path = "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+	} else if (chainId.startsWith("evmos")) {
+		proto = CosmosCryptoSecp256k1KeysPb.PubKey.create();
+		baseProto = CosmosCryptoSecp256k1KeysPb.PubKey;
+		path = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+	} else {
+		proto = CosmosCryptoSecp256k1KeysPb.PubKey.create();
+		baseProto = CosmosCryptoSecp256k1KeysPb.PubKey;
+		path = "/cosmos.crypto.secp256k1.PubKey";
+	}
+	proto.key = base64ToUint8Array(key);
+	return createAny(baseProto.toBinary(proto), path);
+};
+const createBody = ({ message, memo = "", timeoutHeight }) => {
+	const messages = Array.isArray(message) ? message : [message];
+	const txBody = CosmosTxV1Beta1TxPb.TxBody.create();
+	txBody.messages = messages.map((message$1) => createAnyMessage({
+		value: message$1.toBinary(),
+		type: message$1.toDirectSign().type
+	}));
+	txBody.memo = memo;
+	if (timeoutHeight) txBody.timeoutHeight = BigInt(timeoutHeight);
+	return txBody;
+};
+const createFee = ({ fee, payer, granter, gasLimit }) => {
+	const feeAmount = CosmosBaseV1Beta1CoinPb.Coin.create();
+	feeAmount.amount = fee.amount;
+	feeAmount.denom = fee.denom;
+	const feeProto = CosmosTxV1Beta1TxPb.Fee.create();
+	feeProto.gasLimit = BigInt(gasLimit);
+	feeProto.amount = [feeAmount];
+	if (payer) feeProto.payer = payer;
+	if (granter) feeProto.granter = granter;
+	return feeProto;
+};
+const createSigners = ({ chainId, mode, signers }) => {
+	return signers.map((s) => createSignerInfo({
+		mode,
+		chainId,
+		publicKey: s.pubKey,
+		sequence: s.sequence
+	}));
+};
+const createSignerInfo = ({ chainId, publicKey, sequence, mode }) => {
+	const pubKey = getPublicKey({
+		chainId,
+		key: publicKey
+	});
+	const single = CosmosTxV1Beta1TxPb.ModeInfo_Single.create();
+	single.mode = mode;
+	const modeInfo = CosmosTxV1Beta1TxPb.ModeInfo.create();
+	modeInfo.sum = {
+		oneofKind: "single",
+		single
+	};
+	const signerInfo = CosmosTxV1Beta1TxPb.SignerInfo.create();
+	signerInfo.publicKey = pubKey;
+	signerInfo.sequence = BigInt(sequence);
+	signerInfo.modeInfo = modeInfo;
+	return signerInfo;
+};
+const createAuthInfo = ({ signerInfo, fee }) => {
+	const authInfo = CosmosTxV1Beta1TxPb.AuthInfo.create();
+	authInfo.signerInfos = signerInfo;
+	authInfo.fee = fee;
+	return authInfo;
+};
+const createSignDoc = ({ bodyBytes, authInfoBytes, chainId, accountNumber }) => {
+	const signDoc = CosmosTxV1Beta1TxPb.SignDoc.create();
+	signDoc.accountNumber = BigInt(accountNumber);
+	signDoc.chainId = chainId;
+	signDoc.bodyBytes = bodyBytes;
+	signDoc.authInfoBytes = authInfoBytes;
+	return signDoc;
+};
+const createSignDocFromTransaction = (args) => {
+	return CosmosTxV1Beta1TxPb.SignDoc.create({
+		bodyBytes: args.txRaw.bodyBytes,
+		authInfoBytes: args.txRaw.authInfoBytes,
+		accountNumber: BigInt(args.accountNumber),
+		chainId: args.chainId
+	});
+};
+const createTxRawEIP712 = (txRaw, extension, nonCriticalExtension) => {
+	const body = CosmosTxV1Beta1TxPb.TxBody.fromBinary(txRaw.bodyBytes);
+	body.extensionOptions = [createAny(InjectiveTypesV1Beta1TxExtPb.ExtensionOptionsWeb3Tx.toBinary(extension), "/injective.types.v1beta1.ExtensionOptionsWeb3Tx")];
+	if (nonCriticalExtension) body.nonCriticalExtensionOptions = Array.isArray(nonCriticalExtension) ? nonCriticalExtension : [nonCriticalExtension];
+	txRaw.bodyBytes = CosmosTxV1Beta1TxPb.TxBody.toBinary(body);
+	return txRaw;
+};
+const createWeb3Extension = ({ evmChainId, feePayer, feePayerSig }) => {
+	const web3Extension = InjectiveTypesV1Beta1TxExtPb.ExtensionOptionsWeb3Tx.create();
+	web3Extension.typedDataChainID = BigInt(evmChainId);
+	if (feePayer) web3Extension.feePayer = feePayer;
+	if (feePayerSig) web3Extension.feePayerSig = feePayerSig;
+	return web3Extension;
+};
+const createNonCriticalExtensionFromObject = (object) => {
+	return createAny(new TextEncoder().encode(JSON.stringify(object)), "/google.protobuf.Struct");
+};
+const getTransactionPartsFromTxRaw = (txRaw) => {
+	const authInfo = CosmosTxV1Beta1TxPb.AuthInfo.fromBinary(txRaw.authInfoBytes);
+	return {
+		body: CosmosTxV1Beta1TxPb.TxBody.fromBinary(txRaw.bodyBytes),
+		authInfo,
+		signatures: txRaw.signatures
+	};
+};
+const getAminoStdSignDoc = ({ memo, chainId, accountNumber, timeoutHeight, sequence, gas, msgs }) => ({
+	chain_id: chainId,
+	timeout_height: timeoutHeight || "",
+	account_number: accountNumber.toString(),
+	sequence: sequence.toString(),
+	fee: getStdFee({ gas }),
+	msgs: msgs.map((m) => m.toAmino()),
+	memo: memo || ""
+});
+
+//#endregion
+//#region src/core/tx/eip712/maps.ts
+const msgExecuteContractType = "wasm/MsgExecuteContract";
+/**
+* ONLY USED FOR EIP712_V1
+*
+* Function used to generate EIP712 types based on a message object
+* and its structure (recursive)
+*/
+const objectKeysToEip712Types = ({ object, messageType, primaryType = "MsgValue" }) => {
+	const numberFieldsWithStringValue = [
+		"order_mask",
+		"order_type",
+		"oracle_type",
+		"round",
+		"expiration_timestamp",
+		"settlement_timestamp",
+		"oracle_scale_factor",
+		"expiry",
+		"option",
+		"proposal_id",
+		"creation_height",
+		"wasm_hook_query_max_gas"
+	];
+	const stringFieldsWithNumberValue = [
+		"timeout_timestamp",
+		"revision_height",
+		"revision_number"
+	];
+	const stringFieldsToOmitIfEmpty = ["cid"];
+	const fieldsToOmitIfEmpty = ["admin_info", "order"];
+	const output = /* @__PURE__ */ new Map();
+	const types = new Array();
+	for (const property in snakecaseKeys(object)) {
+		let propertyValue = snakecaseKeys(object)[property];
+		if (property === "@type") continue;
+		if (fieldsToOmitIfEmpty.includes(property) && !propertyValue) continue;
+		const type = typeof propertyValue;
+		if (type === "boolean") types.push({
+			name: property,
+			type: "bool"
+		});
+		else if (type === "number" || type === "bigint" || numberFieldsWithStringValue.includes(property)) types.push({
+			name: property,
+			type: numberTypeToReflectionNumberType(property, messageType)
+		});
+		else if (type === "string") {
+			if (stringFieldsToOmitIfEmpty.includes(property) && !propertyValue) continue;
+			if (stringFieldsWithNumberValue.includes(property)) {
+				types.push({
+					name: property,
+					type: stringTypeToReflectionStringType(property)
+				});
+				continue;
+			}
+			types.push({
+				name: property,
+				type: "string"
+			});
+		} else if (type === "object") if (Array.isArray(propertyValue) && propertyValue.length === 0) throw new GeneralException(/* @__PURE__ */ new Error("Array with length 0 found"));
+		else if (Array.isArray(propertyValue) && propertyValue.length > 0) {
+			const arrayFirstType = typeof propertyValue[0];
+			if (arrayFirstType === "boolean" || arrayFirstType === "number" || arrayFirstType === "string") {
+				for (const arrayEntry in propertyValue) if (typeof arrayEntry !== arrayFirstType) throw new GeneralException(/* @__PURE__ */ new Error("Array with different types found"));
+				if (arrayFirstType === "boolean") types.push({
+					name: property,
+					type: "bool[]"
+				});
+				else if (arrayFirstType === "number") types.push({
+					name: property,
+					type: "number[]"
+				});
+				else if (arrayFirstType === "string") types.push({
+					name: property,
+					type: "string[]"
+				});
+			} else if (arrayFirstType === "object") {
+				const propertyType = getObjectEip712PropertyType({
+					property: snakeToPascal(property),
+					parentProperty: primaryType,
+					messageType
+				});
+				const recursiveOutput = objectKeysToEip712Types({
+					object: propertyValue[0],
+					primaryType: propertyType,
+					messageType
+				});
+				const recursiveTypes = recursiveOutput.get(propertyType);
+				types.push({
+					name: property,
+					type: `${propertyType}[]`
+				});
+				output.set(propertyType, recursiveTypes);
+				for (const key of recursiveOutput.keys()) if (key !== primaryType) output.set(key, recursiveOutput.get(key));
+			} else throw new GeneralException(/* @__PURE__ */ new Error("Array with elements of unknown type found"));
+		} else if (propertyValue instanceof Date) types.push({
+			name: property,
+			type: "string"
+		});
+		else {
+			const propertyType = getObjectEip712PropertyType({
+				property: snakeToPascal(property),
+				parentProperty: primaryType,
+				messageType
+			});
+			const recursiveOutput = objectKeysToEip712Types({
+				object: propertyValue,
+				primaryType: propertyType,
+				messageType
+			});
+			const recursiveTypes = recursiveOutput.get(propertyType);
+			types.push({
+				name: property,
+				type: propertyType
+			});
+			output.set(propertyType, recursiveTypes);
+			for (const key of recursiveOutput.keys()) if (key !== primaryType) output.set(key, recursiveOutput.get(key));
+		}
+		else throw new GeneralException(/* @__PURE__ */ new Error(`Type ${property} not found`));
+	}
+	output.set(primaryType, types);
+	return output;
+};
+/**
+* JavaScript doesn't know the exact number types that
+* we represent these fields on chain so we have to map
+* them in their chain representation from the number value
+* that is available in JavaScript
+*/
+const numberTypeToReflectionNumberType = (property, messageType) => {
+	const msgTypeKey = messageType;
+	const messageTypeToNumberTypeMaps = {
+		"cosmos-sdk/MsgSubmitProposal": {
+			status: "int32",
+			base_decimals: "uint32",
+			quote_decimals: "uint32"
+		},
+		"injective/tokenfactory/set-denom-metadata": { decimals: "uint32" },
+		"injective/tokenfactory/create-denom": { decimals: "uint32" },
+		"exchange/MsgAdminUpdateBinaryOptionsMarket": {
+			status: "int32",
+			expiration_timestamp: "int64",
+			settlement_timestamp: "int64"
+		},
+		"exchange/MsgInstantBinaryOptionsMarketLaunch": {
+			status: "int32",
+			expiration_timestamp: "int64",
+			settlement_timestamp: "int64"
+		},
+		"exchange/MsgInstantSpotMarketLaunch": {
+			base_decimals: "uint32",
+			quote_decimals: "uint32"
+		}
+	};
+	if (msgTypeKey && messageTypeToNumberTypeMaps[msgTypeKey] && property) {
+		const type = messageTypeToNumberTypeMaps[msgTypeKey];
+		const typeKey = property;
+		if (type[typeKey]) return type[typeKey];
+	}
+	switch (property) {
+		case "order_mask": return "int32";
+		case "timeout_timestamp": return "timeout_timestamp";
+		case "revision_number": return "uint64";
+		case "revision_height": return "uint64";
+		case "order_type": return "int32";
+		case "admin_permissions": return "uint32";
+		case "oracle_scale_factor": return "uint32";
+		case "oracle_type": return "int32";
+		case "exponent": return "uint32";
+		case "round": return "uint64";
+		case "oracle_scale_factor": return "uint64";
+		case "expiry": return "int64";
+		case "creation_height": return "int64";
+		case "option": return "int32";
+		case "proposal_id": return "uint64";
+		default: return "uint64";
+	}
+};
+/**
+* JavaScript doesn't know the exact string types that
+* we represent these fields on chain so we have to map
+* them in their chain representation from the string value
+* that is available in JavaScript
+*/
+const stringTypeToReflectionStringType = (property) => {
+	switch (property) {
+		case "timeout_timestamp": return "uint64";
+		case "revision_number": return "uint64";
+		case "revision_height": return "uint64";
+		default: return "uint64";
+	}
+};
+const getObjectEip712PropertyType = ({ property, parentProperty, messageType }) => {
+	if (messageType === msgExecuteContractType) return appendWasmTypePrefixToPropertyType(property, parentProperty);
+	return appendTypePrefixToPropertyType(property, parentProperty);
+};
+/**
+* Append Wasm Type prefix to a Level0 EIP712 type
+* including its parent property type
+*/
+const appendWasmTypePrefixToPropertyType = (property, parentProperty = "") => {
+	const cosmWasmMsgPrefix = "CosmwasmInnerMsgMarker";
+	const propertyWithoutTypePrefix = property.replace("Type", "");
+	if (propertyWithoutTypePrefix === "Msg") return cosmWasmMsgPrefix;
+	return `${parentProperty.replace(cosmWasmMsgPrefix, "") + propertyWithoutTypePrefix}Value`;
+};
+/**
+* Append Type prefix to a Level0 EIP712 type
+* including its parent property type
+*/
+const appendTypePrefixToPropertyType = (property, parentProperty = "") => {
+	const propertyWithoutTypePrefix = property.replace("Type", "");
+	return `Type${(parentProperty === "MsgValue" ? "" : parentProperty.replace("Type", "")) + propertyWithoutTypePrefix}`;
+};
+/**
+* Mapping a path type to amino type for messages
+*/
+const protoTypeToAminoType = (type) => {
+	switch (type.startsWith("/") ? type.substring(1) : type) {
+		case "injective.exchange.v1beta1.MsgDeposit": return "exchange/MsgDeposit";
+		case "injective.exchange.v1beta1.MsgWithdraw": return "exchange/MsgWithdraw";
+		case "injective.exchange.v1beta1.MsgInstantSpotMarketLaunch": return "exchange/MsgInstantSpotMarketLaunch";
+		case "injective.exchange.v1beta1.MsgInstantPerpetualMarketLaunch": return "exchange/MsgInstantPerpetualMarketLaunch";
+		case "injective.exchange.v1beta1.MsgInstantExpiryFuturesMarketLaunch": return "exchange/MsgInstantExpiryFuturesMarketLaunch";
+		case "injective.exchange.v1beta1.MsgCreateSpotLimitOrder": return "exchange/MsgCreateSpotLimitOrder";
+		case "injective.exchange.v1beta1.MsgBatchCreateSpotLimitOrders": return "exchange/MsgBatchCreateSpotLimitOrders";
+		case "injective.exchange.v1beta1.MsgCreateSpotMarketOrder": return "exchange/MsgCreateSpotMarketOrder";
+		case "injective.exchange.v1beta1.MsgCancelSpotOrder": return "exchange/MsgCancelSpotOrder";
+		case "injective.exchange.v1beta1.MsgBatchCancelSpotOrders": return "exchange/MsgBatchCancelSpotOrders";
+		case "injective.exchange.v1beta1.MsgCreateDerivativeLimitOrder": return "exchange/MsgCreateDerivativeLimitOrder";
+		case "injective.exchange.v1beta1.MsgBatchCreateDerivativeLimitOrders": return "exchange/MsgBatchCreateDerivativeLimitOrders";
+		case "injective.exchange.v1beta1.MsgCreateDerivativeMarketOrder": return "exchange/MsgCreateDerivativeMarketOrder";
+		case "injective.exchange.v1beta1.MsgCancelDerivativeOrder": return "exchange/MsgCancelDerivativeOrder";
+		case "injective.exchange.v1beta1.MsgBatchCancelDerivativeOrders": return "exchange/MsgBatchCancelDerivativeOrders";
+		case "injective.exchange.v1beta1.MsgBatchCancelBinaryOptionsOrders": return "exchange/MsgBatchCancelBinaryOptionsOrders";
+		case "injective.exchange.v1beta1.MsgSubaccountTransfer": return "exchange/MsgSubaccountTransfer";
+		case "injective.exchange.v1beta1.MsgExternalTransfer": return "exchange/MsgExternalTransfer";
+		case "injective.exchange.v1beta1.MsgIncreasePositionMargin": return "exchange/MsgIncreasePositionMargin";
+		case "injective.exchange.v1beta1.MsgLiquidatePosition": return "exchange/MsgLiquidatePosition";
+		case "injective.exchange.v1beta1.MsgBatchUpdateOrders": return "exchange/MsgBatchUpdateOrders";
+		case "injective.exchange.v1beta1.MsgExec": return "exchange/MsgExec";
+		case "injective.exchange.v1beta1.MsgRegisterAsDMM": return "exchange/MsgRegisterAsDMM";
+		case "injective.exchange.v1beta1.MsgInstantBinaryOptionsMarketLaunch": return "exchange/MsgInstantBinaryOptionsMarketLaunch";
+		case "injective.exchange.v1beta1.MsgCreateBinaryOptionsLimitOrder": return "exchange/MsgCreateBinaryOptionsLimitOrder";
+		case "injective.exchange.v1beta1.MsgCreateBinaryOptionsMarketOrder": return "exchange/MsgCreateBinaryOptionsMarketOrder";
+		case "injective.exchange.v1beta1.MsgCancelBinaryOptionsOrder": return "exchange/MsgCancelBinaryOptionsOrder";
+		case "injective.exchange.v1beta1.MsgAdminUpdateBinaryOptionsMarket": return "exchange/MsgAdminUpdateBinaryOptionsMarket";
+		case "injective.exchange.v1beta1.ExchangeEnableProposal": return "exchange/ExchangeEnableProposal";
+		case "injective.exchange.v1beta1.BatchExchangeModificationProposal": return "exchange/BatchExchangeModificationProposal";
+		case "injective.exchange.v1beta1.SpotMarketParamUpdateProposal": return "exchange/SpotMarketParamUpdateProposal";
+		case "injective.exchange.v1beta1.SpotMarketLaunchProposal": return "exchange/SpotMarketLaunchProposal";
+		case "injective.exchange.v1beta1.PerpetualMarketLaunchProposal": return "exchange/PerpetualMarketLaunchProposal";
+		case "injective.exchange.v1beta1.ExpiryFuturesMarketLaunchProposal": return "exchange/ExpiryFuturesMarketLaunchProposal";
+		case "injective.exchange.v1beta1.DerivativeMarketParamUpdateProposal": return "exchange/DerivativeMarketParamUpdateProposal";
+		case "injective.exchange.v1beta1.MarketForcedSettlementProposal": return "exchange/MarketForcedSettlementProposal";
+		case "injective.exchange.v1beta1.UpdateDenomDecimalsProposal": return "exchange/UpdateDenomDecimalsProposal";
+		case "injective.exchange.v1beta1.TradingRewardCampaignLaunchProposal": return "exchange/TradingRewardCampaignLaunchProposal";
+		case "injective.exchange.v1beta1.TradingRewardCampaignUpdateProposal": return "exchange/TradingRewardCampaignUpdateProposal";
+		case "injective.exchange.v1beta1.TradingRewardPendingPointsUpdateProposal": return "exchange/TradingRewardPendingPointsUpdateProposal";
+		case "injective.exchange.v1beta1.FeeDiscountProposal": return "exchange/FeeDiscountProposal";
+		case "injective.exchange.v1beta1.BatchCommunityPoolSpendProposal": return "exchange/BatchCommunityPoolSpendProposal";
+		case "injective.exchange.v1beta1.BinaryOptionsMarketParamUpdateProposal": return "exchange/BinaryOptionsMarketParamUpdateProposal";
+		case "injective.exchange.v1beta1.BinaryOptionsMarketLaunchProposal": return "exchange/BinaryOptionsMarketLaunchProposal";
+		case "injective.exchange.v1beta1.MsgTransferAndExecute": return "exchange/MsgTransferAndExecute";
+		case "injective.exchange.v2.MsgUpdateSpotMarket": return "exchange/MsgUpdateSpotMarket";
+		case "injective.exchange.v2.MsgUpdateDerivativeMarket": return "exchange/MsgUpdateDerivativeMarket";
+		case "injective.exchange.v1beta1.CreateSpotLimitOrderAuthz": return "exchange/CreateSpotLimitOrderAuthz";
+		case "injective.exchange.v1beta1.CreateSpotMarketOrderAuthz": return "exchange/CreateSpotMarketOrderAuthz";
+		case "injective.exchange.v1beta1.BatchCreateSpotLimitOrdersAuthz": return "exchange/BatchCreateSpotLimitOrdersAuthz";
+		case "injective.exchange.v1beta1.CancelSpotOrderAuthz": return "exchange/CancelSpotOrderAuthz";
+		case "injective.exchange.v1beta1.BatchCancelSpotOrdersAuthz": return "exchange/BatchCancelSpotOrdersAuthz";
+		case "injective.exchange.v1beta1.CreateDerivativeLimitOrderAuthz": return "exchange/CreateDerivativeLimitOrderAuthz";
+		case "injective.exchange.v1beta1.CreateDerivativeMarketOrderAuthz": return "exchange/CreateDerivativeMarketOrderAuthz";
+		case "injective.exchange.v1beta1.BatchCreateDerivativeLimitOrdersAuthz": return "exchange/BatchCreateDerivativeLimitOrdersAuthz";
+		case "injective.exchange.v1beta1.CancelDerivativeOrderAuthz": return "exchange/CancelDerivativeOrderAuthz";
+		case "injective.exchange.v1beta1.BatchCancelDerivativeOrdersAuthz": return "exchange/BatchCancelDerivativeOrdersAuthz";
+		case "injective.exchange.v1beta1.BatchUpdateOrdersAuthz": return "exchange/BatchUpdateOrdersAuthz";
+		case "injective.exchange.v2.MsgSetDelegationTransferReceivers": return "exchange/MsgSetDelegationTransferReceivers";
+		case "injective.auction.v1beta1.MsgBid": return "auction/MsgBid";
+		case "injective.insurance.v1beta1.MsgCreateInsuranceFund": return "insurance/MsgCreateInsuranceFund";
+		case "injective.insurance.v1beta1.MsgUnderwrite": return "insurance/MsgUnderwrite";
+		case "injective.insurance.v1beta1.MsgRequestRedemption": return "insurance/MsgRequestRedemption";
+		case "injective.peggy.v1beta1.MsgSetOrchestratorAddresses": return "peggy/MsgSetOrchestratorAddresses";
+		case "injective.peggy.v1beta1.MsgValsetConfirm": return "peggy/MsgValsetConfirm";
+		case "injective.peggy.v1beta1.MsgSendToEth": return "peggy/MsgSendToEth";
+		case "injective.peggy.v1beta1.MsgCancelSendToEth": return "peggy/MsgCancelSendToEth";
+		case "injective.peggy.v1beta1.MsgRequestBatch": return "peggy/MsgRequestBatch";
+		case "injective.peggy.v1beta1.MsgConfirmBatch": return "peggy/MsgConfirmBatch";
+		case "injective.peggy.v1beta1.Valset": return "peggy/Valset";
+		case "injective.peggy.v1beta1.MsgDepositClaim": return "peggy/MsgDepositClaim";
+		case "injective.peggy.v1beta1.MsgWithdrawClaim": return "peggy/MsgWithdrawClaim";
+		case "injective.peggy.v1beta1.MsgERC20DeployedClaim": return "peggy/MsgERC20DeployedClaim";
+		case "injective.peggy.v1beta1.MsgValsetUpdatedClaim": return "peggy/MsgValsetUpdatedClaim";
+		case "injective.peggy.v1beta1.OutgoingTxBatch": return "peggy/OutgoingTxBatch";
+		case "injective.peggy.v1beta1.OutgoingTransferTx": return "peggy/OutgoingTransferTx";
+		case "injective.peggy.v1beta1.ERC20Token": return "peggy/ERC20Token";
+		case "injective.peggy.v1beta1.IDSet": return "peggy/IDSet";
+		case "injective.peggy.v1beta1.Attestation": return "peggy/Attestation";
+		case "injective.peggy.v1beta1.MsgSubmitBadSignatureEvidence": return "peggy/MsgSubmitBadSignatureEvidence";
+		case "injective.peggy.v1beta1.BlacklistEthereumAddressesProposal": return "peggy/BlacklistEthereumAddressesProposal";
+		case "injective.peggy.v1beta1.RevokeEthereumBlacklistProposal": return "peggy/RevokeEthereumBlacklistProposal";
+		case "injective.wasmx.v1beta1.ContractRegistrationRequestProposal": return "wasmx/ContractRegistrationRequestProposal";
+		case "injective.wasmx.v1beta1.BatchContractRegistrationRequestProposal": return "wasmx/BatchContractRegistrationRequestProposal";
+		case "injective.tokenfactory.v1beta1.MsgCreateDenom": return "injective/tokenfactory/create-denom";
+		case "injective.tokenfactory.v1beta1.MsgMint": return "injective/tokenfactory/mint";
+		case "injective.tokenfactory.v1beta1.MsgBurn": return "injective/tokenfactory/burn";
+		case "injective.tokenfactory.v1beta1.MsgSetDenomMetadata": return "injective/tokenfactory/set-denom-metadata";
+		case "cosmos.auth.v1beta1.MsgUpdateParams": return "cosmos-sdk/x/auth/MsgUpdateParams";
+		case "cosmos.authz.v1beta1.MsgGrant": return "cosmos-sdk/MsgGrant";
+		case "cosmos.authz.v1beta1.MsgRevoke": return "cosmos-sdk/MsgRevoke";
+		case "cosmos.authz.v1beta1.MsgExec": return "cosmos-sdk/MsgExec";
+		case "cosmos.bank.v1beta1.MsgSend": return "cosmos-sdk/MsgSend";
+		case "cosmos.bank.v1beta1.MsgMultiSend": return "cosmos-sdk/MsgMultiSend";
+		case "cosmos.bank.v1beta1.MsgUpdateParams": return "cosmos-sdk/x/bank/MsgUpdateParams";
+		case "cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward": return "cosmos-sdk/MsgWithdrawDelegationReward";
+		case "cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": return "cosmos-sdk/MsgWithdrawValCommission";
+		case "cosmos.distribution.v1beta1.MsgSetWithdrawAddress": return "cosmos-sdk/MsgModifyWithdrawAddress";
+		case "cosmos.distribution.v1beta1.MsgFundCommunityPool": return "cosmos-sdk/MsgFundCommunityPool";
+		case "cosmos.distribution.v1beta1.MsgUpdateParams": return "cosmos-sdk/distribution/MsgUpdateParams";
+		case "cosmos.gov.v1beta1.MsgSubmitProposal": return "cosmos-sdk/MsgSubmitProposal";
+		case "cosmos.gov.v1beta1.MsgDeposit": return "cosmos-sdk/MsgDeposit";
+		case "cosmos.gov.v1.MsgDeposit": return "cosmos-sdk/v1/MsgDeposit";
+		case "cosmos.gov.v1beta1.MsgVote": return "cosmos-sdk/MsgVote";
+		case "cosmos.gov.v1.MsgVote": return "cosmos-sdk/v1/MsgVote";
+		case "cosmos.gov.v1beta1.MsgVoteWeighted": return "cosmos-sdk/MsgVoteWeighted";
+		case "cosmos.staking.v1beta1.MsgCreateValidator": return "cosmos-sdk/MsgCreateValidator";
+		case "cosmos.staking.v1beta1.MsgEditValidator": return "cosmos-sdk/MsgEditValidator";
+		case "cosmos.staking.v1beta1.MsgDelegate": return "cosmos-sdk/MsgDelegate";
+		case "cosmos.staking.v1beta1.MsgUndelegate": return "cosmos-sdk/MsgUndelegate";
+		case "cosmos.staking.v1beta1.MsgBeginRedelegate": return "cosmos-sdk/MsgBeginRedelegate";
+		case "cosmos.staking.v1beta1.MsgTransferDelegation": return "cosmos-sdk/MsgTransferDelegation";
+		case "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation": return "cosmos-sdk/MsgCancelUnbondingDelegation";
+		case "cosmos.staking.v1beta1.MsgUpdateParams": return "cosmos-sdk/x/staking/MsgUpdateParams";
+		case "ibc.applications.transfer.v1.MsgTransfer": return "cosmos-sdk/MsgTransfer";
+		case "cosmos.feegrant.v1beta1.MsgGrantAllowance": return "cosmos-sdk/MsgGrantAllowance";
+		case "cosmos.feegrant.v1beta1.MsgRevokeAllowance": return "cosmos-sdk/MsgRevokeAllowance";
+		default: throw new GeneralException(/* @__PURE__ */ new Error("Unknown message type: " + type));
+	}
+};
+
+//#endregion
+//#region src/core/tx/eip712/utils.ts
+const getEip712Domain = (evmChainId) => {
+	return { domain: {
+		name: "Injective Web3",
+		version: "1.0.0",
+		chainId: "0x" + toBigNumber(evmChainId).toString(16),
+		salt: "0",
+		verifyingContract: "cosmos"
+	} };
+};
+const getEip712DomainV2 = (evmChainId) => {
+	return { domain: {
+		name: "Injective Web3",
+		version: "1.0.0",
+		chainId: "0x" + toBigNumber(evmChainId).toString(16),
+		verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
+		salt: "0"
+	} };
+};
+const getDefaultEip712Types = () => {
+	return { types: {
+		EIP712Domain: [
+			{
+				name: "name",
+				type: "string"
+			},
+			{
+				name: "version",
+				type: "string"
+			},
+			{
+				name: "chainId",
+				type: "uint256"
+			},
+			{
+				name: "verifyingContract",
+				type: "string"
+			},
+			{
+				name: "salt",
+				type: "string"
+			}
+		],
+		Tx: [
+			{
+				name: "account_number",
+				type: "string"
+			},
+			{
+				name: "chain_id",
+				type: "string"
+			},
+			{
+				name: "fee",
+				type: "Fee"
+			},
+			{
+				name: "memo",
+				type: "string"
+			},
+			{
+				name: "msgs",
+				type: "Msg[]"
+			},
+			{
+				name: "sequence",
+				type: "string"
+			},
+			{
+				name: "timeout_height",
+				type: "string"
+			}
+		],
+		Fee: [{
+			name: "amount",
+			type: "Coin[]"
+		}, {
+			name: "gas",
+			type: "string"
+		}],
+		Coin: [{
+			name: "denom",
+			type: "string"
+		}, {
+			name: "amount",
+			type: "string"
+		}],
+		Msg: [{
+			name: "type",
+			type: "string"
+		}, {
+			name: "value",
+			type: "MsgValue"
+		}]
+	} };
+};
+const getDefaultEip712TypesV2 = () => {
+	return { types: {
+		EIP712Domain: [
+			{
+				name: "name",
+				type: "string"
+			},
+			{
+				name: "version",
+				type: "string"
+			},
+			{
+				name: "chainId",
+				type: "uint256"
+			},
+			{
+				name: "verifyingContract",
+				type: "address"
+			},
+			{
+				name: "salt",
+				type: "string"
+			}
+		],
+		Tx: [{
+			name: "context",
+			type: "string"
+		}, {
+			name: "msgs",
+			type: "string"
+		}]
+	} };
+};
+const getEip712Fee = (params) => {
+	const defaultStdFee = getDefaultStdFee();
+	if (!params) return { fee: defaultStdFee };
+	const { amount, gas, feePayer } = {
+		amount: params.amount || defaultStdFee.amount,
+		gas: params.gas || DEFAULT_GAS_LIMIT.toFixed(),
+		feePayer: params.feePayer
+	};
+	return { fee: {
+		...feePayer && { feePayer },
+		gas,
+		amount
+	} };
+};
+const getEip712FeeV2 = (params) => {
+	const defaultStdFee = getDefaultStdFee();
+	if (!params) return { fee: {
+		amount: [{
+			denom: defaultStdFee.amount[0].denom,
+			amount: defaultStdFee.amount[0].amount
+		}],
+		gas: Number(defaultStdFee.gas)
+	} };
+	const amountFromParams = (params.amount || defaultStdFee.amount)[0];
+	const { amount, gas, payer } = {
+		amount: [{
+			denom: amountFromParams.denom,
+			amount: amountFromParams.amount
+		}],
+		gas: Number(params.gas || DEFAULT_GAS_LIMIT.toFixed()),
+		payer: params.feePayer
+	};
+	return { fee: {
+		amount,
+		gas,
+		...payer && { payer }
+	} };
+};
+const getTypesIncludingFeePayer = ({ fee, types }) => {
+	if (!fee) return types;
+	if (!fee.feePayer) return types;
+	types.types["Fee"].unshift({
+		name: "feePayer",
+		type: "string"
+	});
+	return types;
+};
+const getEipTxDetails = ({ accountNumber, sequence, timeoutHeight, chainId, memo }) => {
+	return {
+		account_number: accountNumber,
+		chain_id: chainId,
+		timeout_height: timeoutHeight,
+		memo: memo || "",
+		sequence
+	};
+};
+const getEipTxContext = ({ accountNumber, sequence, fee, timeoutHeight, chainId, memo }) => {
+	return {
+		account_number: Number(accountNumber),
+		chain_id: chainId,
+		...getEip712FeeV2(fee),
+		memo: memo || "",
+		sequence: Number(sequence),
+		timeout_height: Number(timeoutHeight)
+	};
+};
+
+//#endregion
+//#region src/core/tx/eip712/eip712.ts
+const getEip712TypedData = ({ msgs, tx, fee, evmChainId }) => {
+	const messages = Array.isArray(msgs) ? msgs : [msgs];
+	const eip712Msgs = messages.map((m) => m.toEip712());
+	const eip712MessageTypes = messages[0].toEip712Types();
+	return {
+		...getTypesIncludingFeePayer({
+			fee,
+			types: { types: {
+				...getDefaultEip712Types().types,
+				...Object.fromEntries(eip712MessageTypes)
+			} }
+		}),
+		primaryType: "Tx",
+		...getEip712Domain(evmChainId),
+		message: {
+			...getEipTxDetails(tx),
+			...getEip712Fee(fee),
+			msgs: eip712Msgs
+		}
+	};
+};
+const getEip712TypedDataV2 = ({ msgs, tx, fee, evmChainId }) => {
+	const eip712Msgs = (Array.isArray(msgs) ? msgs : [msgs]).map((m) => m.toEip712V2());
+	return {
+		...getDefaultEip712TypesV2(),
+		primaryType: "Tx",
+		...getEip712DomainV2(evmChainId),
+		message: {
+			context: JSON.stringify(getEipTxContext({
+				...tx,
+				fee
+			}), (_, value) => typeof value === "bigint" ? value.toString() : value),
+			msgs: JSON.stringify(eip712Msgs, (_, value) => typeof value === "bigint" ? value.toString() : value)
+		}
+	};
+};
+
+//#endregion
+//#region src/core/modules/utils.ts
+function prepareSignBytes(obj) {
+	if (Array.isArray(obj)) return obj.map(prepareSignBytes);
+	if (typeof obj !== `object` || obj === null) return obj;
+	const sorted = {};
+	Object.keys(obj).sort().forEach((key) => {
+		if (obj[key] === void 0 || obj[key] === null) return;
+		sorted[key] = prepareSignBytes(obj[key]);
+	});
+	return sorted;
+}
+
+//#endregion
+//#region src/core/modules/MsgBase.ts
+/**
+* @category Messages
+*/
+var MsgBase = class {
+	constructor(params) {
+		_defineProperty(this, "params", void 0);
+		this.params = params;
+	}
+	/** @deprecated - use toWeb3Gw instead, renamed for clarity */
+	toWeb3() {
+		return this.toWeb3Gw();
+	}
+	toJSON() {
+		return JSON.stringify(prepareSignBytes(this.toData()));
+	}
+	/**
+	* Returns the types of the message for EIP712
+	*/
+	toEip712Types() {
+		const amino = this.toAmino();
+		return objectKeysToEip712Types({
+			object: amino.value,
+			messageType: amino.type
+		});
+	}
+	/**
+	* Returns the values of the message for EIP712
+	*/
+	toEip712() {
+		return this.toAmino();
+	}
+	/**
+	* Returns the values of the message for EIP712_V2
+	*/
+	toEip712V2() {
+		return this.toWeb3Gw();
+	}
+	toDirectSignJSON() {
+		return JSON.stringify(prepareSignBytes(this.toDirectSign()));
+	}
+};
+
+//#endregion
+//#region src/core/modules/exchange/msgs/MsgSignData.ts
+/**
+* @category Messages
+*/
+var MsgSignData = class MsgSignData extends MsgBase {
+	static fromJSON(params) {
+		return new MsgSignData(params);
+	}
+	toProto() {
+		const { params } = this;
+		return InjectiveExchangeV1Beta1TxPb.MsgSignData.create({
+			signer: hexToUint8Array(getEthereumAddress(params.sender)),
+			data: stringToUint8Array(toUtf8(params.data))
+		});
+	}
+	toData() {
+		const proto = this.toProto();
+		return {
+			"@type": "/injective.exchange.v1beta1.MsgSignData",
+			...proto
+		};
+	}
+	toAmino() {
+		const proto = this.toProto();
+		return {
+			type: "sign/MsgSignData",
+			value: {
+				signer: uint8ArrayToHex(proto.signer),
+				data: toUtf8(proto.data)
+			}
+		};
+	}
+	toWeb3Gw() {
+		const { value } = this.toAmino();
+		return {
+			"@type": "/injective.exchange.v1beta1.MsgSignData",
+			...value
+		};
+	}
+	toDirectSign() {
+		return {
+			type: "/injective.exchange.v1beta1.MsgSignData",
+			message: this.toProto()
+		};
+	}
+	toBinary() {
+		return InjectiveExchangeV1Beta1TxPb.MsgSignData.toBinary(this.toProto());
+	}
+};
+
+//#endregion
+//#region src/core/modules/exchange/msgs/MsgIncreasePositionMargin.ts
+const createMessage = (params) => {
+	return InjectiveExchangeV1Beta1TxPb.MsgIncreasePositionMargin.create({
+		sender: params.injectiveAddress,
+		sourceSubaccountId: params.srcSubaccountId,
+		destinationSubaccountId: params.dstSubaccountId,
+		marketId: params.marketId,
+		amount: params.amount
+	});
+};
+/**
+* @category Messages
+*/
+var MsgIncreasePositionMargin = class MsgIncreasePositionMargin extends MsgBase {
+	static fromJSON(params) {
+		return new MsgIncreasePositionMargin(params);
+	}
+	toProto() {
+		const { params: initialParams } = this;
+		return createMessage({
+			...initialParams,
+			amount: toChainFormat(initialParams.amount).toFixed()
+		});
+	}
+	toData() {
+		const proto = this.toProto();
+		return {
+			"@type": "/injective.exchange.v1beta1.MsgIncreasePositionMargin",
+			...proto
+		};
+	}
+	toAmino() {
+		const { params } = this;
+		return {
+			type: "exchange/MsgIncreasePositionMargin",
+			value: {
+				sender: params.injectiveAddress,
+				source_subaccount_id: params.srcSubaccountId,
+				destination_subaccount_id: params.dstSubaccountId,
+				market_id: params.marketId,
+				amount: params.amount
+			}
+		};
+	}
+	toWeb3Gw() {
+		const { value } = this.toAmino();
+		return {
+			"@type": "/injective.exchange.v1beta1.MsgIncreasePositionMargin",
+			...value
+		};
+	}
+	toEip712() {
+		const { type, value } = this.toAmino();
+		return {
+			type,
+			value: {
+				...value,
+				amount: toChainFormat(value.amount).toFixed()
+			}
+		};
+	}
+	toEip712V2() {
+		const { params } = this;
+		return {
+			...this.toWeb3Gw(),
+			amount: numberToCosmosSdkDecString(params.amount)
+		};
+	}
+	toDirectSign() {
+		return {
+			type: "/injective.exchange.v1beta1.MsgIncreasePositionMargin",
+			message: this.toProto()
+		};
+	}
+	toBinary() {
+		return InjectiveExchangeV1Beta1TxPb.MsgIncreasePositionMargin.toBinary(this.toProto());
+	}
+};
+
+//#endregion
+//#region src/client/chain/types/gov.ts
+const VoteOptionMap = CosmosGovV1GovPb.VoteOption;
+const ProposalStatusMap = CosmosGovV1GovPb.ProposalStatus;
+
+//#endregion
+//#region src/client/chain/types/wasm.ts
+const ContractCodeHistoryOperationTypeMap = CosmwasmWasmV1TypesPb.ContractCodeHistoryOperationType;
+
+//#endregion
+//#region src/client/chain/types/staking.ts
+const BondStatus = {
+	UnBonded: "UnBonded",
+	UnBonding: "UnBonding",
+	Bonded: "Bonded"
+};
+
+//#endregion
+//#region src/client/chain/types/exchange.ts
+const GrpcOrderTypeMap = ExchangePb.OrderType;
+const OrderTypeMap = ExchangePb.OrderType;
+const GrpcMarketStatusMap = ExchangePb.MarketStatus;
+
+//#endregion
+//#region src/client/chain/types/insurance.ts
+const OracleTypeMap = OracleType;
+
+//#endregion
+//#region src/client/chain/types/permissions.ts
+const PermissionActionMap = InjectivePermissionsV1Beta1PermissionsPb.Action;
+
+//#endregion
+//#region src/client/chain/types/index.ts
+const ChainModule = { ...ChainErrorModule };
+
+//#endregion
+//#region src/core/tx/eip712/MsgDecoder.ts
+var MsgDecoder = class {
+	static decode(message) {
+		const type = message.typeUrl;
+		switch (true) {
+			case type.includes("MsgIncreasePositionMargin"): {
+				const msg = InjectiveExchangeV1Beta1TxPb.MsgIncreasePositionMargin.fromBinary(message.value);
+				return MsgIncreasePositionMargin.fromJSON({
+					marketId: msg.marketId,
+					injectiveAddress: msg.sender,
+					srcSubaccountId: msg.sourceSubaccountId,
+					dstSubaccountId: msg.destinationSubaccountId,
+					amount: msg.amount
+				});
+			}
+			case type.includes("MsgSignData"): {
+				const msg = InjectiveExchangeV1Beta1TxPb.MsgSignData.fromBinary(message.value);
+				return MsgSignData.fromJSON({
+					data: toUtf8(msg.data),
+					sender: getInjectiveAddress(uint8ArrayToHex(msg.signer))
+				});
+			}
+			default: throw new Error("Unknown message type");
+		}
+	}
+};
+
+//#endregion
+//#region src/core/accounts/PrivateKey.ts
+/**
+* Class for wrapping SigningKey that is used for signature creation and public key derivation.
+*
+* @category Crypto Utility Classes
+*/
+var PrivateKey = class PrivateKey {
+	constructor(wallet) {
+		_defineProperty(this, "wallet", void 0);
+		this.wallet = wallet;
+	}
+	/**
+	* Generate new private key with random mnemonic phrase
+	* @returns { privateKey: PrivateKey, mnemonic: string }
+	*/
+	static generate() {
+		const mnemonic = generateMnemonic();
+		return {
+			privateKey: PrivateKey.fromMnemonic(mnemonic),
+			mnemonic
+		};
+	}
+	/**
+	* Create a PrivateKey instance from a given mnemonic phrase and a HD derivation path.
+	* If path is not given, default to Band's HD prefix 494 and all other indexes being zeroes.
+	* @param {string} words the mnemonic phrase
+	* @param {string|undefined} path the HD path that follows the BIP32 standard (optional)
+	* @returns {PrivateKey} Initialized PrivateKey object
+	*/
+	static fromMnemonic(words, path = DEFAULT_DERIVATION_PATH) {
+		return new PrivateKey(new Wallet(HDNodeWallet.fromPhrase(words, void 0, path).privateKey));
+	}
+	/**
+	* Create a PrivateKey instance from a given private key and a HD derivation path.
+	* If path is not given, default to Band's HD prefix 494 and all other indexes being zeroes.
+	* @param {string} privateKey  the private key
+	* @returns {PrivateKey} Initialized PrivateKey object
+	*
+	* @deprecated - use fromHex instead
+	*/
+	static fromPrivateKey(privateKey) {
+		return new PrivateKey(new Wallet(privateKey));
+	}
+	/**
+	* Create a PrivateKey instance from a given private key and a HD derivation path.
+	* If path is not given, default to Band's HD prefix 494 and all other indexes being zeroes.
+	* @param {string} privateKey  the private key
+	* @returns {PrivateKey} Initialized PrivateKey object
+	*/
+	static fromHex(privateKey) {
+		const isString = typeof privateKey === "string";
+		const privateKeyHex = isString && privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+		return new PrivateKey(new Wallet(uint8ArrayToHex(isString ? hexToUint8Array(privateKeyHex.toString()) : privateKey)));
+	}
+	/**
+	* Return the private key in hex
+	* @returns {string}
+	**/
+	toPrivateKeyHex() {
+		return this.wallet.privateKey.startsWith("0x") ? this.wallet.privateKey : `0x${this.wallet.privateKey}`;
+	}
+	/**
+	* Return the PublicKey associated with this private key.
+	* @returns {PublicKey} a Public key that can be used to verify the signatures made with this PrivateKey
+	**/
+	toPublicKey() {
+		return PublicKey.fromPrivateKeyHex(this.wallet.privateKey);
+	}
+	/**
+	* Return the hex address associated with this private key.
+	* @returns {string}
+	*/
+	toHex() {
+		return this.wallet.address.startsWith("0x") ? this.wallet.address : `0x${this.wallet.address}`;
+	}
+	/**
+	* Return the Address associated with this private key.
+	* @returns {Address}
+	**/
+	toAddress() {
+		return Address.fromHex(this.toHex());
+	}
+	/**
+	* Return the Bech32 address associated with this private key.
+	* @returns {string}
+	**/
+	toBech32() {
+		return Address.fromHex(this.toHex()).toBech32();
+	}
+	/**
+	* Sign the given message using the wallet's _signingKey function.
+	* @param {string} messageBytes: the message that will be hashed and signed, a Buffer made of bytes
+	* @returns {Uint8Array} a signature of this private key over the given message
+	*/
+	sign(messageBytes) {
+		const { wallet } = this;
+		const msgHash = keccak256(messageBytes);
+		const signature = wallet.signingKey.sign(msgHash);
+		const splittedSignature = Signature.from(signature);
+		return getBytes(concat([splittedSignature.r, splittedSignature.s]));
+	}
+	/**
+	* Sign the given message using the edcsa sign_deterministic function.
+	* @param {Buffer} messageBytes: the message that will be hashed and signed, a Buffer made of bytes
+	* @returns {Uint8Array} a signature of this private key over the given message
+	*/
+	signEcda(messageBytes) {
+		const { wallet } = this;
+		const msgHash = keccak256(messageBytes);
+		const privateKey = hexToUint8Array(wallet.privateKey.startsWith("0x") ? wallet.privateKey.slice(2) : wallet.privateKey);
+		return secp256k1.sign(toBytes(msgHash), privateKey).toCompactRawBytes();
+	}
+	/**
+	* Sign the given message using the wallet's _signingKey function.
+	* @param {string} messageHashedBytes: the message that will be signed, a Buffer made of bytes
+	* @returns {Uint8Array} a signature of this private key over the given message
+	*/
+	signHashed(messageHashedBytes) {
+		const { wallet } = this;
+		const signature = wallet.signingKey.sign(messageHashedBytes);
+		const splittedSignature = Signature.from(signature);
+		return getBytes(concat([splittedSignature.r, splittedSignature.s]));
+	}
+	/**
+	* Sign the given message using the edcsa sign_deterministic function.
+	* @param {Buffer} messageHashedBytes: the message that will be signed, a Buffer made of bytes
+	* @returns {Uint8Array} a signature of this private key over the given message
+	*/
+	signHashedEcda(messageHashedBytes) {
+		const { wallet } = this;
+		const privateKey = hexToUint8Array(wallet.privateKey.startsWith("0x") ? wallet.privateKey.slice(2) : wallet.privateKey);
+		return secp256k1.sign(messageHashedBytes, privateKey).toCompactRawBytes();
+	}
+	/**
+	* Sign the given typed data using the edcsa sign_deterministic function.
+	* @param {TypedDataDefinition | any} eip712Data: the typed data that will be hashed and signed
+	* @returns {Uint8Array} a signature of this private key over the given message
+	*/
+	async signTypedData(eip712Data) {
+		const { wallet } = this;
+		const privateKeyHex = wallet.privateKey.startsWith("0x") ? wallet.privateKey.slice(2) : wallet.privateKey;
+		const msgHashBytes = hashTypedData(TypedDataUtilsSanitizeData(eip712Data));
+		const privateKey = hexToUint8Array(privateKeyHex);
+		const sig = secp256k1.sign(toBytes(msgHashBytes), privateKey);
+		const signature = sig.toCompactRawBytes();
+		const signatureWithRecovery = new Uint8Array(signature.length + 1);
+		signatureWithRecovery.set(signature);
+		signatureWithRecovery[signature.length] = sig.recovery + 27;
+		return signatureWithRecovery;
+	}
+	/**
+	* Sign the given typed data using the edcsa sign_deterministic function.
+	* @param {Buffer} eip712Data: the typed data that will be signed, a Buffer made of bytes
+	* @returns {Uint8Array} a signature of this private key over the given message
+	*/
+	signHashedTypedData(eip712Data) {
+		const { wallet } = this;
+		const privateKey = hexToUint8Array(wallet.privateKey.startsWith("0x") ? wallet.privateKey.slice(2) : wallet.privateKey);
+		return secp256k1.sign(eip712Data, privateKey).toCompactRawBytes();
+	}
+	/**
+	* Verify signature using EIP712 typed data
+	* and the publicKey
+	*
+	* (params are passed as an object)
+	*
+	* @param {string} signature: the signature to verify in hex
+	* @param {any} eip712: the EIP712 typed data to verify against
+	* @param {string} publicKey: the public key to verify against in hex
+	* */
+	static async verifySignature({ signature, eip712, publicKey }) {
+		const publicKeyInHex = publicKey.startsWith("0x") ? publicKey : `0x${publicKey}`;
+		const recoveredPubKey = await recoverTypedSignaturePubKey(eip712, signature);
+		const recoveredPubKeyInHex = recoveredPubKey.startsWith("0x") ? recoveredPubKey : `0x${recoveredPubKey}`;
+		/** uncompressed/compressed key */
+		if (publicKeyInHex.length !== recoveredPubKeyInHex.length) return recoveredPubKeyInHex.substring(0, publicKeyInHex.length) === publicKeyInHex;
+		return publicKeyInHex === recoveredPubKeyInHex;
+	}
+	/**
+	* Verify signature using EIP712 typed data
+	* and the publicKey
+	*
+	* (params are passed as an object)
+	*
+	* @param {string} signature: the signature to verify in hex
+	* @param {any} eip712: the EIP712 typed data to verify against
+	* @param {string} publicKey: the public key to verify against in hex
+	* */
+	async verifyThisPkSignature({ signature, eip712 }) {
+		const publicKeyInHex = `0x${this.toPublicKey().toHex()}`;
+		const recoveredPubKey = await recoverTypedSignaturePubKey(eip712, signature);
+		const recoveredPubKeyInHex = recoveredPubKey.startsWith("0x") ? recoveredPubKey : `0x${recoveredPubKey}`;
+		/** uncompressed/compressed key */
+		if (publicKeyInHex.length !== recoveredPubKeyInHex.length) return recoveredPubKeyInHex.substring(0, publicKeyInHex.length) === publicKeyInHex;
+		return publicKeyInHex === recoveredPubKeyInHex;
+	}
+	/**
+	* Verify cosmos signature EIP712 typed
+	* data from the TxRaw and verify the signature
+	* that's included in the TxRaw
+	*
+	* (params are passed as an object)
+	*
+	* @param {CosmosTxV1Beta1TxPb.TxRaw} txRaw: the signature to verify in hex
+	* @param {object} signer: the public key and the account number to verify against
+	**/
+	static async verifyCosmosSignature({ txRaw, signer }) {
+		const { body, authInfo, signatures } = getTransactionPartsFromTxRaw(txRaw);
+		if (authInfo.signerInfos.length > 1 || signatures.length > 1) throw new GeneralException(/* @__PURE__ */ new Error("Validation of multiple signers is not supported"));
+		if (body.messages.length > 1) throw new GeneralException(/* @__PURE__ */ new Error("Validation of multiple messages is not supported"));
+		const getChainIds = () => {
+			if (!body.extensionOptions.length) return {
+				chainId: ChainId.Mainnet,
+				EvmChainId: EvmChainId.Mainnet
+			};
+			const extension = body.extensionOptions.find((extension$1) => extension$1.typeUrl.includes("ExtensionOptionsWeb3Tx"));
+			if (!extension) return {
+				chainId: ChainId.Mainnet,
+				EvmChainId: EvmChainId.Mainnet
+			};
+			const decodedExtension = InjectiveTypesV1Beta1TxExtPb.ExtensionOptionsWeb3Tx.fromBinary(extension.value);
+			const evmChainId$1 = Number(decodedExtension.typedDataChainID);
+			return {
+				evmChainId: EvmChainId,
+				chainId: [
+					EvmChainId.Kovan,
+					EvmChainId.Goerli,
+					EvmChainId.Sepolia
+				].includes(evmChainId$1) ? ChainId.Testnet : ChainId.Mainnet
+			};
+		};
+		const { evmChainId, chainId } = getChainIds();
+		const [signerInfo] = authInfo.signerInfos;
+		const [signature] = signatures;
+		const [msg] = body.messages;
+		const eip712TypedData = getEip712TypedData({
+			msgs: [MsgDecoder.decode(msg)],
+			fee: authInfo.fee,
+			tx: {
+				memo: body.memo,
+				accountNumber: signer.accountNumber.toString(),
+				sequence: signerInfo.sequence.toString(),
+				timeoutHeight: body.timeoutHeight.toString(),
+				chainId
+			},
+			evmChainId
+		});
+		return await this.verifySignature({
+			eip712: eip712TypedData,
+			signature: uint8ArrayToHex(signature),
+			publicKey: uint8ArrayToHex(base64ToUint8Array(signer.publicKey))
+		});
+	}
+	/**
+	* Verify signature using ADR-36 sign doc
+	* and the publicKey
+	*
+	* (params are passed as an object)
+	*
+	* @param {string} signature: the signature to verify in hex
+	* @param {any} signDoc: the signDoc to verify against
+	* @param {string} publicKey:the public key to verify against in hex
+	* */
+	static verifyArbitrarySignature({ signature, signDoc, publicKey }) {
+		const sigHex = signature.startsWith("0x") ? signature : `0x${signature}`;
+		const pubHex = publicKey.startsWith("0x") ? publicKey : `0x${publicKey}`;
+		return secp256k1.verify(toBytes(sigHex), toBytes(keccak256(signDoc)), toBytes(pubHex));
+	}
+};
+
+//#endregion
+//#region src/core/accounts/BaseAccount.ts
+/**
+* @category Utility Classes
+*/
+var BaseAccount = class BaseAccount extends Address {
+	constructor({ address, accountNumber, sequence, pubKey }) {
+		super(address);
+		_defineProperty(this, "accountNumber", void 0);
+		_defineProperty(this, "sequence", void 0);
+		_defineProperty(this, "pubKey", void 0);
+		this.accountNumber = accountNumber;
+		this.sequence = sequence;
+		this.pubKey = pubKey;
+	}
+	static fromRestApi(accountResponse) {
+		const { base_account: baseAccount } = accountResponse.account;
+		return new BaseAccount({
+			address: baseAccount.address,
+			accountNumber: baseAccount.account_number ? parseInt(baseAccount.account_number, 10) : 0,
+			sequence: baseAccount.sequence ? parseInt(baseAccount.sequence, 10) : 0,
+			pubKey: baseAccount.pub_key ? {
+				type: baseAccount.pub_key["@type"],
+				key: baseAccount.pub_key.key
+			} : {
+				type: "",
+				key: ""
+			}
+		});
+	}
+	static fromRestCosmosApi(accountResponse) {
+		return new BaseAccount({
+			address: accountResponse.address,
+			accountNumber: accountResponse.account_number ? parseInt(accountResponse.account_number, 10) : 0,
+			sequence: accountResponse.sequence ? parseInt(accountResponse.sequence, 10) : 0,
+			pubKey: accountResponse.pub_key ? {
+				type: accountResponse.pub_key["@type"],
+				key: accountResponse.pub_key.key
+			} : {
+				type: "",
+				key: ""
+			}
+		});
+	}
+	incrementSequence() {
+		this.sequence += 1;
+		return this;
+	}
+	toAccountDetails() {
+		return {
+			pubKey: this.pubKey,
+			sequence: this.sequence,
+			address: this.bech32Address,
+			accountNumber: this.accountNumber
+		};
+	}
+};
+
+//#endregion
+//#region src/client/base/BaseRestConsumer.ts
+/**
+* @hidden
+*/
+var BaseRestConsumer = class extends HttpRestClient {};
+
+//#endregion
+//#region src/client/chain/rest/ChainRestAuthApi.ts
+/**
+* @category Chain Rest API
+*/
+var ChainRestAuthApi = class extends BaseRestConsumer {
+	/**
+	* Looks up the account information for the Injective address.
+	*
+	* @param address address of account to look up
+	*/
+	async fetchAccount(address, params = {}) {
+		const endpoint = `cosmos/auth/v1beta1/accounts/${address}`;
+		try {
+			return (await this.retry(() => this.get(endpoint, params))).data;
+		} catch (e) {
+			if (e instanceof HttpRequestException) throw e;
+			throw new HttpRequestException(new Error(e), {
+				code: UnspecifiedErrorCode,
+				context: `${this.endpoint}/${endpoint}`,
+				contextModule: ChainModule.Auth
+			});
+		}
+	}
+	/**
+	* Looks up the account information for any cosmos chain address.
+	*
+	* @param address address of account to look up
+	*/
+	async fetchCosmosAccount(address, params = {}) {
+		const endpoint = `cosmos/auth/v1beta1/accounts/${address}`;
+		try {
+			const isInjectiveAddress = address.startsWith("inj") || address.startsWith("evmos");
+			const response = await this.retry(() => this.get(endpoint, params));
+			return isInjectiveAddress ? response.data.account.base_account : response.data.account;
+		} catch (e) {
+			if (e instanceof HttpRequestException) throw e;
+			throw new HttpRequestException(new Error(e), {
+				code: UnspecifiedErrorCode,
+				context: `${this.endpoint}/${endpoint}`,
+				contextModule: ChainModule.Auth
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/client/chain/rest/ChainRestTendermintApi.ts
+/**
+* @category Chain Rest API
+*/
+var ChainRestTendermintApi = class extends BaseRestConsumer {
+	async fetchLatestBlock(params = {}) {
+		const endpoint = `cosmos/base/tendermint/v1beta1/blocks/latest`;
+		try {
+			const response = await this.retry(() => this.get(endpoint, params));
+			return response.data.sdk_block || response.data.block;
+		} catch (e) {
+			if (e instanceof HttpRequestException) throw e;
+			throw new HttpRequestException(new Error(e), {
+				code: UnspecifiedErrorCode,
+				context: `${this.endpoint}/${endpoint}`,
+				contextModule: ChainModule.Tendermint
+			});
+		}
+	}
+	async fetchBlock(height, params = {}) {
+		const endpoint = `cosmos/base/tendermint/v1beta1/blocks/${height}`;
+		try {
+			const response = await this.retry(() => this.get(endpoint, params));
+			return response.data.sdk_block || response.data.block;
+		} catch (e) {
+			if (e instanceof HttpRequestException) throw e;
+			throw new HttpRequestException(new Error(e), {
+				code: UnspecifiedErrorCode,
+				context: `${this.endpoint}/${endpoint}`,
+				contextModule: ChainModule.Tendermint
+			});
+		}
+	}
+	async fetchNodeInfo(params = {}) {
+		const endpoint = `cosmos/base/tendermint/v1beta1/node_info`;
+		try {
+			const response = await this.retry(() => this.get(endpoint, params));
+			return {
+				nodeInfo: response.data.default_node_info,
+				applicationVersion: response.data.application_version
+			};
+		} catch (e) {
+			if (e instanceof HttpRequestException) throw e;
+			throw new HttpRequestException(new Error(e), {
+				code: UnspecifiedErrorCode,
+				context: `${this.endpoint}/${endpoint}`,
+				contextModule: ChainModule.Tendermint
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/core/tx/utils/constants.ts
+const SIGN_DIRECT = CosmosTxSigningV1Beta1SigningPb.SignMode.DIRECT;
+const SIGN_AMINO = CosmosTxSigningV1Beta1SigningPb.SignMode.LEGACY_AMINO_JSON;
+const SIGN_EIP712 = CosmosTxSigningV1Beta1SigningPb.SignMode.LEGACY_AMINO_JSON;
+const SIGN_EIP712_V2 = CosmosTxSigningV1Beta1SigningPb.SignMode.EIP712_V2;
+
+//#endregion
+//#region src/core/tx/tx.ts
+/**
+* @typedef {Object} CreateTransactionWithSignersArgs
+* @param {CreateTransactionWithSignersArgs} params
+* @property {Msg | Msg[]} message - the Cosmos messages to wrap them in a transaction
+* @property {string} memo - the memo to attach to the transaction
+* @property {StdFee} fee - the fee to attach to the transaction
+* @property {SignerDetails} signers - the signers of the transaction
+* @property {number} number - the account number to attach to the transaction
+* @property {number} chainId - the chain-id to attach to the transaction
+* @property {string} pubKey - the account pubKey to attach to the transaction (in base64)
+*
+* @typedef {Object} CreateTransactionResult
+* @property {TxRaw} txRaw  - the Tx raw that was created
+* @property {SignDoc} signDoc  - the SignDoc that was created - used for signing of the transaction
+* @property {SignerDetails} signers  - the signers of the transaction
+* @property {Uint8Array} bodyBytes  - the body bytes of the transaction
+* @property {Uint8Array} authInfoBytes  - the auth info bytes of the transaction
+* @property {Uint8Array} signBytes  - the sign bytes of the transaction (SignDoc serialized to binary)
+* @property {Uint8Array} signHashedBytes  - the sign bytes of the transaction (SignDoc serialized to binary) and hashed using keccak256
+* @returns {CreateTransactionResult} result
+*/
+const createTransactionWithSigners = ({ signers, chainId, message, timeoutHeight, memo = "", fee = getDefaultStdFee(), signMode = SIGN_DIRECT }) => {
+	const actualSigners = Array.isArray(signers) ? signers : [signers];
+	const [signer] = actualSigners;
+	const body = createBody({
+		message,
+		memo,
+		timeoutHeight
+	});
+	const actualFee = typeof fee === "string" ? getStdFeeFromString(fee) : fee;
+	const feeMessage = createFee({
+		fee: actualFee.amount[0],
+		payer: actualFee.payer,
+		granter: actualFee.granter,
+		gasLimit: parseInt(actualFee.gas, 10)
+	});
+	const authInfo = createAuthInfo({
+		signerInfo: createSigners({
+			chainId,
+			mode: signMode,
+			signers: actualSigners
+		}),
+		fee: feeMessage
+	});
+	const bodyBytes = CosmosTxV1Beta1TxPb.TxBody.toBinary(body);
+	const authInfoBytes = CosmosTxV1Beta1TxPb.AuthInfo.toBinary(authInfo);
+	const signDoc = createSignDoc({
+		chainId,
+		bodyBytes,
+		authInfoBytes,
+		accountNumber: signer.accountNumber
+	});
+	const signDocBytes = CosmosTxV1Beta1TxPb.SignDoc.toBinary(signDoc);
+	const toSignBytes = signDocBytes;
+	const toSignHash = keccak256(signDocBytes, "bytes");
+	const txRaw = CosmosTxV1Beta1TxPb.TxRaw.create();
+	txRaw.authInfoBytes = authInfoBytes;
+	txRaw.bodyBytes = bodyBytes;
+	return {
+		txRaw,
+		signDoc,
+		signers,
+		signer,
+		signBytes: toSignBytes,
+		signHashedBytes: toSignHash,
+		bodyBytes,
+		authInfoBytes
+	};
+};
+/**
+* @typedef {Object} CreateTransactionArgs
+* @param {CreateTransactionArgs} params
+* @property {MsgArg | MsgArg[]} message - the Cosmos messages to wrap them in a transaction
+* @property {string} memo - the memo to attach to the transaction
+* @property {StdFee} fee - the fee to attach to the transaction
+* @property {string} sequence - the account sequence to attach to the transaction
+* @property {number} number - the account number to attach to the transaction
+* @property {number} chainId - the chain-id to attach to the transaction
+* @property {string} pubKey - the account pubKey to attach to the transaction (in base64)
+*
+* @typedef {Object} CreateTransactionResult
+* @property {TxRaw} txRaw  // the Tx raw that was created
+* @property {SignDoc} signDoc  // the SignDoc that was created - used for signing of the transaction
+* @property {number} accountNumber  // the account number of the signer of the transaction
+* @property {Uint8Array} bodyBytes  // the body bytes of the transaction
+* @property {Uint8Array} authInfoBytes  // the auth info bytes of the transaction
+* @property {Uint8Array} signBytes  // the sign bytes of the transaction (SignDoc serialized to binary)
+* @property {Uint8Array} signHashedBytes  // the sign bytes of the transaction (SignDoc serialized to binary) and hashed using keccak256
+* @returns {CreateTransactionResult} result
+*/
+const createTransaction = (args) => {
+	return createTransactionWithSigners({
+		...args,
+		signers: {
+			pubKey: args.pubKey,
+			accountNumber: args.accountNumber,
+			sequence: args.sequence
+		}
+	});
+};
+/**
+* Used when we want to pass a Msg class instead of the {type, message}
+* object of the Message (using the toDirectSign() method)
+* @returns
+*/
+const createTransactionFromMsg = (params) => {
+	const messages = Array.isArray(params.message) ? params.message : [params.message];
+	return createTransaction({
+		...params,
+		message: messages
+	});
+};
+/**
+* Used when we get a DirectSignResponse from
+* Cosmos native wallets like Keplr, Leap, etc after
+* the TxRaw has been signed.
+*
+* The reason why we need to create a new TxRaw and
+* not use the one that we passed to signing is that the users
+* can change the gas fees and that will alter the original
+* TxRaw which will cause signature miss match if we broadcast
+* that transaction on chain
+* @returns TxRaw
+*/
+const createTxRawFromSigResponse = (response) => {
+	if (response.signed === void 0) return response;
+	const directSignResponse = response;
+	const txRaw = CosmosTxV1Beta1TxPb.TxRaw.create();
+	txRaw.authInfoBytes = directSignResponse.signed.authInfoBytes;
+	txRaw.bodyBytes = directSignResponse.signed.bodyBytes;
+	txRaw.signatures = [base64ToUint8Array(directSignResponse.signature.signature)];
+	return txRaw;
+};
+/**
+* Used when we don't have account details and block details
+* and we pass the message and the user's address only
+* @returns
+*/
+const createTransactionForAddressAndMsg = async (params) => {
+	const messages = Array.isArray(params.message) ? params.message : [params.message];
+	const chainRestAuthApi = new ChainRestAuthApi(params.endpoint);
+	const tendermintRestApi = new ChainRestTendermintApi(params.endpoint);
+	/** Account Details * */
+	const accountDetails = await chainRestAuthApi.fetchCosmosAccount(params.address);
+	const baseAccount = BaseAccount.fromRestCosmosApi(accountDetails);
+	const latestHeight = (await tendermintRestApi.fetchLatestBlock()).header.height;
+	const timeoutHeight = toBigNumber(latestHeight).plus(DEFAULT_BLOCK_TIMEOUT_HEIGHT);
+	if (!(params.pubKey || baseAccount.pubKey.key)) throw new GeneralException(/* @__PURE__ */ new Error(`The pubKey for ${params.address} is missing.`));
+	return createTransaction({
+		...params,
+		pubKey: params.pubKey || baseAccount.pubKey.key,
+		sequence: Number(baseAccount.sequence),
+		accountNumber: Number(baseAccount.accountNumber),
+		timeoutHeight: timeoutHeight.toNumber(),
+		message: messages
+	});
+};
+const createTransactionAndCosmosSignDoc = (args) => {
+	const result = createTransaction(args);
+	const [signer] = Array.isArray(result.signers) ? result.signers : [result.signers];
+	return {
+		...result,
+		cosmosSignDoc: CosmosTxV1Beta1TxPb.SignDoc.create({
+			bodyBytes: result.bodyBytes,
+			authInfoBytes: result.authInfoBytes,
+			accountNumber: BigInt(signer.accountNumber),
+			chainId: args.chainId
+		})
+	};
+};
+const createTransactionAndCosmosSignDocForAddressAndMsg = async (params) => {
+	const result = await createTransactionForAddressAndMsg(params);
+	const [signer] = Array.isArray(result.signers) ? result.signers : [result.signers];
+	return {
+		...result,
+		cosmosSignDoc: CosmosTxV1Beta1TxPb.SignDoc.create({
+			bodyBytes: result.bodyBytes,
+			authInfoBytes: result.authInfoBytes,
+			accountNumber: BigInt(signer.accountNumber),
+			chainId: params.chainId
+		})
+	};
+};
+const getTxRawFromTxRawOrDirectSignResponse = (txRawOrDirectSignResponse) => {
+	return txRawOrDirectSignResponse.signed === void 0 ? txRawOrDirectSignResponse : createTxRawFromSigResponse(txRawOrDirectSignResponse);
+};
+
+//#endregion
+//#region src/core/tx/arbitrary.ts
+const generateArbitrarySignDoc = (message, signer) => {
+	const signDoc = {
+		account_number: "0",
+		chain_id: "",
+		fee: {
+			amount: [],
+			gas: "0"
+		},
+		memo: "",
+		msgs: [{
+			type: "sign/MsgSignData",
+			value: {
+				data: uint8ArrayToBase64(stringToUint8Array(toUtf8(message))),
+				signer
+			}
+		}],
+		sequence: "0"
+	};
+	const stringified = toUtf8(JSON.stringify(sortObjectByKeys(signDoc)));
+	return {
+		signDoc,
+		signDocBuff: stringified,
+		stringifiedSignDoc: stringified
+	};
+};
+
+//#endregion
+export { createBody as $, fromUtf8 as $n, getExactDecimalsFromNumber as $t, VoteOptionMap as A, messageHash as An, denomAmountFromChainDenomAmountToFixed as At, getEip712DomainV2 as B, _defineProperty as Bn, derivativePriceFromChainPriceToFixed as Bt, OracleTypeMap as C, sortObjectByKeysWithReduce as Cn, getInjectiveAddressFromSubaccountId as Ct, BondStatus as D, decompressPubKey as Dn, amountToCosmosSdkDecAmount as Dt, OrderTypeMap as E, TypedDataUtilsSanitizeData as En, removeHexPrefix as Et, getEip712TypedData as F, publicKeyToAddress as Fn, derivativeMarginFromChainMargin as Ft, getTypesIncludingFeePayer as G, BECH32_PUBKEY_CONS_PREFIX as Gn, derivativeQuantityToChainQuantity as Gt, getEip712FeeV2 as H, BECH32_ADDR_CONS_PREFIX as Hn, derivativePriceToChainPriceToFixed as Ht, getEip712TypedDataV2 as I, ripemd160 as In, derivativeMarginFromChainMarginToFixed as It, objectKeysToEip712Types as J, base64ToUint8Array as Jn, formatAmountToAllowableDecimals as Jt, getObjectEip712PropertyType as K, BECH32_PUBKEY_VAL_PREFIX as Kn, derivativeQuantityToChainQuantityToFixed as Kt, getDefaultEip712Types as L, sanitizeTypedData as Ln, derivativeMarginToChainMargin as Lt, MsgSignData as M, privateKeyHashToPublicKeyBase64 as Mn, denomAmountToChainDenomAmount as Mt, MsgBase as N, privateKeyToPublicKey as Nn, denomAmountToChainDenomAmountToFixed as Nt, ContractCodeHistoryOperationTypeMap as O, domainHash as On, cosmosSdkDecToBigNumber as Ot, prepareSignBytes as P, privateKeyToPublicKeyBase64 as Pn, denomAmountToGrpcChainDenomAmount as Pt, createAuthInfo as Q, fromBase64 as Qn, formatPriceToAllowablePrice as Qt, getDefaultEip712TypesV2 as R, sha256 as Rn, derivativeMarginToChainMarginToFixed as Rt, OracleType as S, sortObjectByKeys as Sn, getInjectiveAddress as St, GrpcOrderTypeMap as T, TypedDataUtilsHashStruct as Tn, isCw20ContractAddress as Tt, getEipTxContext as U, BECH32_ADDR_VAL_PREFIX as Un, derivativeQuantityFromChainQuantity as Ut, getEip712Fee as V, BECH32_ADDR_ACC_PREFIX as Vn, derivativePriceToChainPrice as Vt, getEipTxDetails as W, BECH32_PUBKEY_ACC_PREFIX as Wn, derivativeQuantityFromChainQuantityToFixed as Wt, stringTypeToReflectionStringType as X, binaryToBase64 as Xn, formatNumberToAllowableTensMultiplier as Xt, protoTypeToAminoType as Y, base64ToUtf8 as Yn, formatNumberToAllowableDecimals as Yt, CosmosTxV1Beta1TxPb as Z, concatUint8Arrays as Zn, formatPriceToAllowableDecimals as Zt, BaseAccount as _, isNode as _n, addHexPrefix as _t, createTransactionForAddressAndMsg as a, spotPriceFromChainPriceToFixed as an, toUtf8 as ar, createSigners as at, ChainModule as b, objectToJson as bn, getDefaultSubaccountId as bt, createTxRawFromSigResponse as c, spotQuantityFromChainQuantity as cn, uint8ArrayToString as cr, getAminoStdSignDoc as ct, SIGN_DIRECT as d, spotQuantityToChainQuantityToFixed as dn, createAny as dt, getSignificantDecimalsFromNumber as en, hexToBase64 as er, createFee as et, SIGN_EIP712 as f, getErrorMessage as fn, createAnyMessage as ft, BaseRestConsumer as g, isJsonString as gn, recoverTypedSignaturePubKey as gt, ChainRestAuthApi as h, isBrowser as hn, PublicKey as ht, createTransactionAndCosmosSignDocForAddressAndMsg as i, spotPriceFromChainPrice as in, toBase64 as ir, createSignerInfo as it, MsgIncreasePositionMargin as j, privateKeyHashToPublicKey as jn, denomAmountFromGrpcChainDenomAmount as jt, ProposalStatusMap as k, hashToHex as kn, denomAmountFromChainDenomAmount as kt, getTxRawFromTxRawOrDirectSignResponse as l, spotQuantityFromChainQuantityToFixed as ln, getPublicKey as lt, ChainRestTendermintApi as m, hexToNumber as mn, getInjectiveSignerAddress as mt, createTransaction as n, isNumber as nn, hexToUint8Array as nr, createSignDoc as nt, createTransactionFromMsg as o, spotPriceToChainPrice as on, uint8ArrayToBase64 as or, createTxRawEIP712 as ot, SIGN_EIP712_V2 as p, grpcCoinToUiCoin as pn, getEthereumSignerAddress as pt, numberTypeToReflectionNumberType as q, DEFAULT_DERIVATION_PATH as qn, formatAmountToAllowableAmount as qt, createTransactionAndCosmosSignDoc as r, numberToCosmosSdkDecString as rn, stringToUint8Array as rr, createSignDocFromTransaction as rt, createTransactionWithSigners as s, spotPriceToChainPriceToFixed as sn, uint8ArrayToHex as sr, createWeb3Extension as st, generateArbitrarySignDoc as t, getTensMultiplier as tn, hexToBuff as tr, createNonCriticalExtensionFromObject as tt, SIGN_AMINO as u, spotQuantityToChainQuantity as un, getTransactionPartsFromTxRaw as ut, PrivateKey as v, isReactNative as vn, getAddressFromInjectiveAddress as vt, GrpcMarketStatusMap as w, SignTypedDataVersionV4 as wn, getSubaccountId as wt, PermissionActionMap as x, protoObjectToJson as xn, getEthereumAddress as xt, MsgDecoder as y, isServerSide as yn, getChecksumAddress as yt, getEip712Domain as z, Address as zn, derivativePriceFromChainPrice as zt };