@injectivelabs/sdk-ts 1.16.23 → 1.16.25-alpha.0

package/dist/cjs/PrivateKey-72Aogc8C.cjs

@@ -0,0 +1,2930 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_defineProperty = require('./defineProperty-Dkg4B6va.cjs');
+let __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb = require("@injectivelabs/core-proto-ts-v2/generated/cosmos/tx/v1beta1/tx_pb");
+__injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb);
+let viem = require("viem");
+let __injectivelabs_utils = require("@injectivelabs/utils");
+let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+let __scure_base = require("@scure/base");
+let __noble_curves_secp256k1 = require("@noble/curves/secp256k1");
+let __injectivelabs_core_proto_ts_v2_generated_google_protobuf_any_pb = require("@injectivelabs/core-proto-ts-v2/generated/google/protobuf/any_pb");
+__injectivelabs_core_proto_ts_v2_generated_google_protobuf_any_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_google_protobuf_any_pb);
+let __injectivelabs_core_proto_ts_v2_generated_injective_crypto_v1beta1_ethsecp256k1_keys_pb = require("@injectivelabs/core-proto-ts-v2/generated/injective/crypto/v1beta1/ethsecp256k1/keys_pb");
+__injectivelabs_core_proto_ts_v2_generated_injective_crypto_v1beta1_ethsecp256k1_keys_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_injective_crypto_v1beta1_ethsecp256k1_keys_pb);
+let crypto_js = require("crypto-js");
+crypto_js = __toESM(crypto_js);
+let bip39 = require("bip39");
+let __injectivelabs_ts_types = require("@injectivelabs/ts-types");
+let ethers = require("ethers");
+let __injectivelabs_core_proto_ts_v2_generated_injective_types_v1beta1_tx_ext_pb = require("@injectivelabs/core-proto-ts-v2/generated/injective/types/v1beta1/tx_ext_pb");
+__injectivelabs_core_proto_ts_v2_generated_injective_types_v1beta1_tx_ext_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_injective_types_v1beta1_tx_ext_pb);
+let __injectivelabs_core_proto_ts_v2_generated_cosmos_base_v1beta1_coin_pb = require("@injectivelabs/core-proto-ts-v2/generated/cosmos/base/v1beta1/coin_pb");
+__injectivelabs_core_proto_ts_v2_generated_cosmos_base_v1beta1_coin_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_cosmos_base_v1beta1_coin_pb);
+let __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb = require("@injectivelabs/core-proto-ts-v2/generated/cosmos/crypto/secp256k1/keys_pb");
+__injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb);
+let snakecase_keys = require("snakecase-keys");
+snakecase_keys = __toESM(snakecase_keys);
+let __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb = require("@injectivelabs/core-proto-ts-v2/generated/injective/exchange/v1beta1/tx_pb");
+__injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb = __toESM(__injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_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 (0, viem.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 (0, viem.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 __scure_base.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 __scure_base.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 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 src/core/accounts/Address.ts
+/**
+* @category Utility Classes
+*/
+var Address = class Address {
+	constructor(bech32Address) {
+		require_defineProperty._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(__scure_base.bech32.fromWords(__scure_base.bech32.decode(bech).words));
+			const addressBuffer = (0, viem.toBytes)((address.startsWith("0x") ? address : `0x${address}`).toString());
+			return new Address(__scure_base.bech32.encode(prefix, __scure_base.bech32.toWords(addressBuffer)));
+		} catch (e) {
+			throw new __injectivelabs_exceptions.GeneralException(new Error(e), { type: __injectivelabs_exceptions.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 = (0, viem.toBytes)((hex.startsWith("0x") ? hex : `0x${hex}`).toString());
+		return new Address(__scure_base.bech32.encode(prefix, __scure_base.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 = (0, viem.toBytes)(address.startsWith("0x") ? address : `0x${address}`);
+		return __scure_base.bech32.encode(prefix, __scure_base.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(__scure_base.bech32.fromWords(__scure_base.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 crypto_js.default.SHA256(crypto_js.default.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 = crypto_js.default.lib.WordArray.create(data);
+	return hexToUint8Array(crypto_js.default.SHA256(wordArray).toString());
+};
+/**
+* Compute RIPEMD160 hash of Uint8Array data
+* @param data - Data to hash
+* @returns RIPEMD160 hash as Uint8Array
+*/
+const ripemd160 = (data) => {
+	const wordArray = crypto_js.default.lib.WordArray.create(data);
+	return hexToUint8Array(crypto_js.default.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 __noble_curves_secp256k1.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 __noble_curves_secp256k1.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 (0, viem.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 (0, viem.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 = __noble_curves_secp256k1.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 = __noble_curves_secp256k1.secp256k1.ProjectivePoint.fromHex(pubKey).toRawBytes(false).slice(1);
+	if (pubKey.length !== 64) throw new Error("Expected pubKey to be of length 64");
+	return (0, viem.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 = (0, viem.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/numbers.ts
+const $BigNumber = __injectivelabs_utils.BigNumber.clone({ ROUNDING_MODE: __injectivelabs_utils.BigNumber.ROUND_DOWN });
+const isNumber = (number) => {
+	if (typeof number === "number") return true;
+	return !isNaN(parseFloat(number));
+};
+const formatNumberToAllowableDecimals = (value, allowableDecimals, roundingMode) => {
+	const decimalPlacesInValue = (0, __injectivelabs_utils.toBigNumber)((0, __injectivelabs_utils.getExactDecimalsFromNumber)(value));
+	const valueToString = value.toString();
+	if (decimalPlacesInValue.lte(0)) return valueToString;
+	return decimalPlacesInValue.gte(allowableDecimals) ? (0, __injectivelabs_utils.toBigNumber)(valueToString).toFixed(allowableDecimals, roundingMode) : valueToString;
+};
+const formatNumberToAllowableTensMultiplier = (value, tensMultiplier, roundingMode) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value);
+	if (tensMultiplier === 0) return valueToBn.toFixed(0, roundingMode);
+	const tensMul = (0, __injectivelabs_utils.toBigNumber)(10).pow(tensMultiplier);
+	if (valueToBn.lte(tensMul)) return tensMul.toFixed(0, roundingMode);
+	return (0, __injectivelabs_utils.toBigNumber)(valueToBn.div(tensMul).toFixed(0, roundingMode)).multipliedBy(tensMul).toFixed(0);
+};
+const formatAmountToAllowableAmount = (value, tensMultiplier) => {
+	return tensMultiplier < 0 ? formatNumberToAllowableDecimals(value, -tensMultiplier, __injectivelabs_utils.BigNumber.ROUND_DOWN) : formatNumberToAllowableTensMultiplier(value, tensMultiplier, __injectivelabs_utils.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, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value).toFixed();
+	const number = denomAmountToChainDenomAmount({
+		value: tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value,
+		decimals
+	});
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const number = (0, __injectivelabs_utils.toHumanReadable)(value, decimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value).toFixed();
+	const number = derivativeMarginToChainMargin({
+		value: tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value,
+		quoteDecimals
+	});
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const number = (0, __injectivelabs_utils.toHumanReadable)(value, quoteDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value).toFixed();
+	const number = (0, __injectivelabs_utils.toChainFormat)(tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value, quoteDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const number = (0, __injectivelabs_utils.toHumanReadable)(value, quoteDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value).toFixed();
+	const number = derivativeQuantityToChainQuantity({ value: tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value });
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const number = new $BigNumber(value);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value).toFixed();
+	const number = (0, __injectivelabs_utils.toChainFormat)(tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value, (0, __injectivelabs_utils.toBigNumber)(quoteDecimals).minus(baseDecimals).toNumber());
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const number = (0, __injectivelabs_utils.toHumanReadable)(value, quoteDecimals - baseDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const valueToBn = (0, __injectivelabs_utils.toBigNumber)(value).toFixed();
+	const number = (0, __injectivelabs_utils.toChainFormat)(tensMultiplier ? formatPriceToAllowablePrice(valueToBn, tensMultiplier) : value, baseDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.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 = __injectivelabs_utils.BigNumber.ROUND_DOWN }) => {
+	const number = (0, __injectivelabs_utils.toHumanReadable)(value, baseDecimals);
+	if (decimalPlaces === void 0) return number.toFixed();
+	return number.toFixed((0, __injectivelabs_utils.getSignificantDecimalsFromNumber)(number), roundingMode);
+};
+/**
+* @deprecated use toHumanReadable from injectivelabs/utils instead
+*/
+const cosmosSdkDecToBigNumber = (number) => new __injectivelabs_utils.BigNumber(number).dividedBy(new __injectivelabs_utils.BigNumber(10).pow(18));
+const numberToCosmosSdkDecString = (value) => {
+	return new __injectivelabs_utils.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 __injectivelabs_utils.BigNumber(number);
+	if (numberToBn.eq(1)) return 0;
+	if (numberToBn.lt(1)) return -1 * (0, __injectivelabs_utils.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 = (0, viem.toBytes)(ethAddress.toString());
+	return __scure_base.bech32.encode("inj", __scure_base.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(__scure_base.bech32.fromWords(__scure_base.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(__scure_base.bech32.fromWords(__scure_base.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(__scure_base.bech32.fromWords(__scure_base.bech32.decode(injectiveAddress).words))}${"0".repeat(23)}${nonce}`;
+};
+/** @deprecated - use getEthereumAddress */
+const getAddressFromInjectiveAddress = (address) => {
+	if (address.startsWith("0x")) return address;
+	return `0x${uint8ArrayToHex(__scure_base.bech32.fromWords(__scure_base.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 = (0, viem.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 (0, viem.recoverPublicKey)({
+		hash: (0, viem.hashTypedData)(data),
+		signature
+	});
+	return `0x${uint8ArrayToHex(__noble_curves_secp256k1.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) {
+		require_defineProperty._defineProperty(this, "type", void 0);
+		require_defineProperty._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(__noble_curves_secp256k1.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 __scure_base.bech32.encode(BECH32_PUBKEY_ACC_PREFIX, __scure_base.bech32.toWords(hexToUint8Array(this.toHex())));
+	}
+	toAddress() {
+		const decompressedPublicKey = decompressPubKey(this.toHex());
+		const addressBuffer = (0, viem.keccak256)((0, viem.toBytes)(decompressedPublicKey.startsWith("0x") ? decompressedPublicKey : "0x" + decompressedPublicKey), "bytes").subarray(-20);
+		return Address.fromHex(uint8ArrayToHex(addressBuffer).toLowerCase());
+	}
+	toProto() {
+		const proto = __injectivelabs_core_proto_ts_v2_generated_injective_crypto_v1beta1_ethsecp256k1_keys_pb.PubKey.create();
+		proto.key = this.key;
+		return proto;
+	}
+	toAny() {
+		const proto = this.toProto();
+		const message = __injectivelabs_core_proto_ts_v2_generated_google_protobuf_any_pb.Any.create();
+		message.typeUrl = this.type;
+		message.value = __injectivelabs_core_proto_ts_v2_generated_injective_crypto_v1beta1_ethsecp256k1_keys_pb.PubKey.toBinary(proto);
+		return message;
+	}
+};
+
+//#endregion
+//#region src/core/tx/utils/helpers.ts
+const createAnyMessage = (msg) => {
+	const message = __injectivelabs_core_proto_ts_v2_generated_google_protobuf_any_pb.Any.create();
+	message.typeUrl = `${msg.type.startsWith("/") ? "" : "/"}${msg.type}`;
+	message.value = msg.value;
+	return message;
+};
+const createAny = (value, type) => {
+	const message = __injectivelabs_core_proto_ts_v2_generated_google_protobuf_any_pb.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 = __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb.PubKey.create();
+		baseProto = __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb.PubKey;
+		path = "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+	} else if (chainId.startsWith("evmos")) {
+		proto = __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb.PubKey.create();
+		baseProto = __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb.PubKey;
+		path = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+	} else {
+		proto = __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb.PubKey.create();
+		baseProto = __injectivelabs_core_proto_ts_v2_generated_cosmos_crypto_secp256k1_keys_pb.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 = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.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 = __injectivelabs_core_proto_ts_v2_generated_cosmos_base_v1beta1_coin_pb.Coin.create();
+	feeAmount.amount = fee.amount;
+	feeAmount.denom = fee.denom;
+	const feeProto = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.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 = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.ModeInfo_Single.create();
+	single.mode = mode;
+	const modeInfo = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.ModeInfo.create();
+	modeInfo.sum = {
+		oneofKind: "single",
+		single
+	};
+	const signerInfo = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.SignerInfo.create();
+	signerInfo.publicKey = pubKey;
+	signerInfo.sequence = BigInt(sequence);
+	signerInfo.modeInfo = modeInfo;
+	return signerInfo;
+};
+const createAuthInfo = ({ signerInfo, fee }) => {
+	const authInfo = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.AuthInfo.create();
+	authInfo.signerInfos = signerInfo;
+	authInfo.fee = fee;
+	return authInfo;
+};
+const createSignDoc = ({ bodyBytes, authInfoBytes, chainId, accountNumber }) => {
+	const signDoc = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.SignDoc.create();
+	signDoc.accountNumber = BigInt(accountNumber);
+	signDoc.chainId = chainId;
+	signDoc.bodyBytes = bodyBytes;
+	signDoc.authInfoBytes = authInfoBytes;
+	return signDoc;
+};
+const createSignDocFromTransaction = (args) => {
+	return __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.SignDoc.create({
+		bodyBytes: args.txRaw.bodyBytes,
+		authInfoBytes: args.txRaw.authInfoBytes,
+		accountNumber: BigInt(args.accountNumber),
+		chainId: args.chainId
+	});
+};
+const createTxRawEIP712 = (txRaw, extension, nonCriticalExtension) => {
+	const body = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.TxBody.fromBinary(txRaw.bodyBytes);
+	body.extensionOptions = [createAny(__injectivelabs_core_proto_ts_v2_generated_injective_types_v1beta1_tx_ext_pb.ExtensionOptionsWeb3Tx.toBinary(extension), "/injective.types.v1beta1.ExtensionOptionsWeb3Tx")];
+	if (nonCriticalExtension) body.nonCriticalExtensionOptions = Array.isArray(nonCriticalExtension) ? nonCriticalExtension : [nonCriticalExtension];
+	txRaw.bodyBytes = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.TxBody.toBinary(body);
+	return txRaw;
+};
+const createWeb3Extension = ({ evmChainId, feePayer, feePayerSig }) => {
+	const web3Extension = __injectivelabs_core_proto_ts_v2_generated_injective_types_v1beta1_tx_ext_pb.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 = __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.AuthInfo.fromBinary(txRaw.authInfoBytes);
+	return {
+		body: __injectivelabs_core_proto_ts_v2_generated_cosmos_tx_v1beta1_tx_pb.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: (0, __injectivelabs_utils.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 (0, snakecase_keys.default)(object)) {
+		let propertyValue = (0, snakecase_keys.default)(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 __injectivelabs_exceptions.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 __injectivelabs_exceptions.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: (0, __injectivelabs_utils.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 __injectivelabs_exceptions.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: (0, __injectivelabs_utils.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 __injectivelabs_exceptions.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 __injectivelabs_exceptions.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" + (0, __injectivelabs_utils.toBigNumber)(evmChainId).toString(16),
+		salt: "0",
+		verifyingContract: "cosmos"
+	} };
+};
+const getEip712DomainV2 = (evmChainId) => {
+	return { domain: {
+		name: "Injective Web3",
+		version: "1.0.0",
+		chainId: "0x" + (0, __injectivelabs_utils.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 = (0, __injectivelabs_utils.getDefaultStdFee)();
+	if (!params) return { fee: defaultStdFee };
+	const { amount, gas, feePayer } = {
+		amount: params.amount || defaultStdFee.amount,
+		gas: params.gas || __injectivelabs_utils.DEFAULT_GAS_LIMIT.toFixed(),
+		feePayer: params.feePayer
+	};
+	return { fee: {
+		...feePayer && { feePayer },
+		gas,
+		amount
+	} };
+};
+const getEip712FeeV2 = (params) => {
+	const defaultStdFee = (0, __injectivelabs_utils.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 || __injectivelabs_utils.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) {
+		require_defineProperty._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 __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb.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 __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb.MsgSignData.toBinary(this.toProto());
+	}
+};
+
+//#endregion
+//#region src/core/modules/exchange/msgs/MsgIncreasePositionMargin.ts
+const createMessage = (params) => {
+	return __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb.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: (0, __injectivelabs_utils.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: (0, __injectivelabs_utils.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 __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb.MsgIncreasePositionMargin.toBinary(this.toProto());
+	}
+};
+
+//#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 = __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb.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 = __injectivelabs_core_proto_ts_v2_generated_injective_exchange_v1beta1_tx_pb.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) {
+		require_defineProperty._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 = (0, bip39.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 ethers.Wallet(ethers.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 ethers.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 ethers.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 = (0, viem.keccak256)(messageBytes);
+		const signature = wallet.signingKey.sign(msgHash);
+		const splittedSignature = ethers.Signature.from(signature);
+		return (0, ethers.getBytes)((0, ethers.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 = (0, viem.keccak256)(messageBytes);
+		const privateKey = hexToUint8Array(wallet.privateKey.startsWith("0x") ? wallet.privateKey.slice(2) : wallet.privateKey);
+		return __noble_curves_secp256k1.secp256k1.sign((0, viem.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 = ethers.Signature.from(signature);
+		return (0, ethers.getBytes)((0, ethers.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 __noble_curves_secp256k1.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 = (0, viem.hashTypedData)(TypedDataUtilsSanitizeData(eip712Data));
+		const privateKey = hexToUint8Array(privateKeyHex);
+		const sig = __noble_curves_secp256k1.secp256k1.sign((0, viem.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 __noble_curves_secp256k1.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 __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error("Validation of multiple signers is not supported"));
+		if (body.messages.length > 1) throw new __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error("Validation of multiple messages is not supported"));
+		const getChainIds = () => {
+			if (!body.extensionOptions.length) return {
+				chainId: __injectivelabs_ts_types.ChainId.Mainnet,
+				EvmChainId: __injectivelabs_ts_types.EvmChainId.Mainnet
+			};
+			const extension = body.extensionOptions.find((extension$1) => extension$1.typeUrl.includes("ExtensionOptionsWeb3Tx"));
+			if (!extension) return {
+				chainId: __injectivelabs_ts_types.ChainId.Mainnet,
+				EvmChainId: __injectivelabs_ts_types.EvmChainId.Mainnet
+			};
+			const decodedExtension = __injectivelabs_core_proto_ts_v2_generated_injective_types_v1beta1_tx_ext_pb.ExtensionOptionsWeb3Tx.fromBinary(extension.value);
+			const evmChainId$1 = Number(decodedExtension.typedDataChainID);
+			return {
+				evmChainId: __injectivelabs_ts_types.EvmChainId,
+				chainId: [
+					__injectivelabs_ts_types.EvmChainId.Kovan,
+					__injectivelabs_ts_types.EvmChainId.Goerli,
+					__injectivelabs_ts_types.EvmChainId.Sepolia
+				].includes(evmChainId$1) ? __injectivelabs_ts_types.ChainId.Testnet : __injectivelabs_ts_types.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 __noble_curves_secp256k1.secp256k1.verify((0, viem.toBytes)(sigHex), (0, viem.toBytes)((0, viem.keccak256)(signDoc)), (0, viem.toBytes)(pubHex));
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Address', {
+  enumerable: true,
+  get: function () {
+    return Address;
+  }
+});
+Object.defineProperty(exports, 'BECH32_ADDR_ACC_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BECH32_ADDR_ACC_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'BECH32_ADDR_CONS_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BECH32_ADDR_CONS_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'BECH32_ADDR_VAL_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BECH32_ADDR_VAL_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'BECH32_PUBKEY_ACC_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BECH32_PUBKEY_ACC_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'BECH32_PUBKEY_CONS_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BECH32_PUBKEY_CONS_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'BECH32_PUBKEY_VAL_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BECH32_PUBKEY_VAL_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_DERIVATION_PATH', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_DERIVATION_PATH;
+  }
+});
+Object.defineProperty(exports, 'MsgBase', {
+  enumerable: true,
+  get: function () {
+    return MsgBase;
+  }
+});
+Object.defineProperty(exports, 'MsgDecoder', {
+  enumerable: true,
+  get: function () {
+    return MsgDecoder;
+  }
+});
+Object.defineProperty(exports, 'MsgIncreasePositionMargin', {
+  enumerable: true,
+  get: function () {
+    return MsgIncreasePositionMargin;
+  }
+});
+Object.defineProperty(exports, 'MsgSignData', {
+  enumerable: true,
+  get: function () {
+    return MsgSignData;
+  }
+});
+Object.defineProperty(exports, 'PrivateKey', {
+  enumerable: true,
+  get: function () {
+    return PrivateKey;
+  }
+});
+Object.defineProperty(exports, 'PublicKey', {
+  enumerable: true,
+  get: function () {
+    return PublicKey;
+  }
+});
+Object.defineProperty(exports, 'SignTypedDataVersionV4', {
+  enumerable: true,
+  get: function () {
+    return SignTypedDataVersionV4;
+  }
+});
+Object.defineProperty(exports, 'TypedDataUtilsHashStruct', {
+  enumerable: true,
+  get: function () {
+    return TypedDataUtilsHashStruct;
+  }
+});
+Object.defineProperty(exports, 'TypedDataUtilsSanitizeData', {
+  enumerable: true,
+  get: function () {
+    return TypedDataUtilsSanitizeData;
+  }
+});
+Object.defineProperty(exports, '__commonJS', {
+  enumerable: true,
+  get: function () {
+    return __commonJS;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'addHexPrefix', {
+  enumerable: true,
+  get: function () {
+    return addHexPrefix;
+  }
+});
+Object.defineProperty(exports, 'amountToCosmosSdkDecAmount', {
+  enumerable: true,
+  get: function () {
+    return amountToCosmosSdkDecAmount;
+  }
+});
+Object.defineProperty(exports, 'base64ToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return base64ToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'binaryToBase64', {
+  enumerable: true,
+  get: function () {
+    return binaryToBase64;
+  }
+});
+Object.defineProperty(exports, 'concatUint8Arrays', {
+  enumerable: true,
+  get: function () {
+    return concatUint8Arrays;
+  }
+});
+Object.defineProperty(exports, 'cosmosSdkDecToBigNumber', {
+  enumerable: true,
+  get: function () {
+    return cosmosSdkDecToBigNumber;
+  }
+});
+Object.defineProperty(exports, 'createAny', {
+  enumerable: true,
+  get: function () {
+    return createAny;
+  }
+});
+Object.defineProperty(exports, 'createAnyMessage', {
+  enumerable: true,
+  get: function () {
+    return createAnyMessage;
+  }
+});
+Object.defineProperty(exports, 'createAuthInfo', {
+  enumerable: true,
+  get: function () {
+    return createAuthInfo;
+  }
+});
+Object.defineProperty(exports, 'createBody', {
+  enumerable: true,
+  get: function () {
+    return createBody;
+  }
+});
+Object.defineProperty(exports, 'createFee', {
+  enumerable: true,
+  get: function () {
+    return createFee;
+  }
+});
+Object.defineProperty(exports, 'createNonCriticalExtensionFromObject', {
+  enumerable: true,
+  get: function () {
+    return createNonCriticalExtensionFromObject;
+  }
+});
+Object.defineProperty(exports, 'createSignDoc', {
+  enumerable: true,
+  get: function () {
+    return createSignDoc;
+  }
+});
+Object.defineProperty(exports, 'createSignDocFromTransaction', {
+  enumerable: true,
+  get: function () {
+    return createSignDocFromTransaction;
+  }
+});
+Object.defineProperty(exports, 'createSignerInfo', {
+  enumerable: true,
+  get: function () {
+    return createSignerInfo;
+  }
+});
+Object.defineProperty(exports, 'createSigners', {
+  enumerable: true,
+  get: function () {
+    return createSigners;
+  }
+});
+Object.defineProperty(exports, 'createTxRawEIP712', {
+  enumerable: true,
+  get: function () {
+    return createTxRawEIP712;
+  }
+});
+Object.defineProperty(exports, 'createWeb3Extension', {
+  enumerable: true,
+  get: function () {
+    return createWeb3Extension;
+  }
+});
+Object.defineProperty(exports, 'decompressPubKey', {
+  enumerable: true,
+  get: function () {
+    return decompressPubKey;
+  }
+});
+Object.defineProperty(exports, 'denomAmountFromChainDenomAmount', {
+  enumerable: true,
+  get: function () {
+    return denomAmountFromChainDenomAmount;
+  }
+});
+Object.defineProperty(exports, 'denomAmountFromChainDenomAmountToFixed', {
+  enumerable: true,
+  get: function () {
+    return denomAmountFromChainDenomAmountToFixed;
+  }
+});
+Object.defineProperty(exports, 'denomAmountFromGrpcChainDenomAmount', {
+  enumerable: true,
+  get: function () {
+    return denomAmountFromGrpcChainDenomAmount;
+  }
+});
+Object.defineProperty(exports, 'denomAmountToChainDenomAmount', {
+  enumerable: true,
+  get: function () {
+    return denomAmountToChainDenomAmount;
+  }
+});
+Object.defineProperty(exports, 'denomAmountToChainDenomAmountToFixed', {
+  enumerable: true,
+  get: function () {
+    return denomAmountToChainDenomAmountToFixed;
+  }
+});
+Object.defineProperty(exports, 'denomAmountToGrpcChainDenomAmount', {
+  enumerable: true,
+  get: function () {
+    return denomAmountToGrpcChainDenomAmount;
+  }
+});
+Object.defineProperty(exports, 'derivativeMarginFromChainMargin', {
+  enumerable: true,
+  get: function () {
+    return derivativeMarginFromChainMargin;
+  }
+});
+Object.defineProperty(exports, 'derivativeMarginFromChainMarginToFixed', {
+  enumerable: true,
+  get: function () {
+    return derivativeMarginFromChainMarginToFixed;
+  }
+});
+Object.defineProperty(exports, 'derivativeMarginToChainMargin', {
+  enumerable: true,
+  get: function () {
+    return derivativeMarginToChainMargin;
+  }
+});
+Object.defineProperty(exports, 'derivativeMarginToChainMarginToFixed', {
+  enumerable: true,
+  get: function () {
+    return derivativeMarginToChainMarginToFixed;
+  }
+});
+Object.defineProperty(exports, 'derivativePriceFromChainPrice', {
+  enumerable: true,
+  get: function () {
+    return derivativePriceFromChainPrice;
+  }
+});
+Object.defineProperty(exports, 'derivativePriceFromChainPriceToFixed', {
+  enumerable: true,
+  get: function () {
+    return derivativePriceFromChainPriceToFixed;
+  }
+});
+Object.defineProperty(exports, 'derivativePriceToChainPrice', {
+  enumerable: true,
+  get: function () {
+    return derivativePriceToChainPrice;
+  }
+});
+Object.defineProperty(exports, 'derivativePriceToChainPriceToFixed', {
+  enumerable: true,
+  get: function () {
+    return derivativePriceToChainPriceToFixed;
+  }
+});
+Object.defineProperty(exports, 'derivativeQuantityFromChainQuantity', {
+  enumerable: true,
+  get: function () {
+    return derivativeQuantityFromChainQuantity;
+  }
+});
+Object.defineProperty(exports, 'derivativeQuantityFromChainQuantityToFixed', {
+  enumerable: true,
+  get: function () {
+    return derivativeQuantityFromChainQuantityToFixed;
+  }
+});
+Object.defineProperty(exports, 'derivativeQuantityToChainQuantity', {
+  enumerable: true,
+  get: function () {
+    return derivativeQuantityToChainQuantity;
+  }
+});
+Object.defineProperty(exports, 'derivativeQuantityToChainQuantityToFixed', {
+  enumerable: true,
+  get: function () {
+    return derivativeQuantityToChainQuantityToFixed;
+  }
+});
+Object.defineProperty(exports, 'domainHash', {
+  enumerable: true,
+  get: function () {
+    return domainHash;
+  }
+});
+Object.defineProperty(exports, 'formatAmountToAllowableAmount', {
+  enumerable: true,
+  get: function () {
+    return formatAmountToAllowableAmount;
+  }
+});
+Object.defineProperty(exports, 'formatAmountToAllowableDecimals', {
+  enumerable: true,
+  get: function () {
+    return formatAmountToAllowableDecimals;
+  }
+});
+Object.defineProperty(exports, 'formatNumberToAllowableDecimals', {
+  enumerable: true,
+  get: function () {
+    return formatNumberToAllowableDecimals;
+  }
+});
+Object.defineProperty(exports, 'formatNumberToAllowableTensMultiplier', {
+  enumerable: true,
+  get: function () {
+    return formatNumberToAllowableTensMultiplier;
+  }
+});
+Object.defineProperty(exports, 'formatPriceToAllowableDecimals', {
+  enumerable: true,
+  get: function () {
+    return formatPriceToAllowableDecimals;
+  }
+});
+Object.defineProperty(exports, 'formatPriceToAllowablePrice', {
+  enumerable: true,
+  get: function () {
+    return formatPriceToAllowablePrice;
+  }
+});
+Object.defineProperty(exports, 'fromBase64', {
+  enumerable: true,
+  get: function () {
+    return fromBase64;
+  }
+});
+Object.defineProperty(exports, 'fromUtf8', {
+  enumerable: true,
+  get: function () {
+    return fromUtf8;
+  }
+});
+Object.defineProperty(exports, 'getAddressFromInjectiveAddress', {
+  enumerable: true,
+  get: function () {
+    return getAddressFromInjectiveAddress;
+  }
+});
+Object.defineProperty(exports, 'getAminoStdSignDoc', {
+  enumerable: true,
+  get: function () {
+    return getAminoStdSignDoc;
+  }
+});
+Object.defineProperty(exports, 'getChecksumAddress', {
+  enumerable: true,
+  get: function () {
+    return getChecksumAddress;
+  }
+});
+Object.defineProperty(exports, 'getDefaultEip712Types', {
+  enumerable: true,
+  get: function () {
+    return getDefaultEip712Types;
+  }
+});
+Object.defineProperty(exports, 'getDefaultEip712TypesV2', {
+  enumerable: true,
+  get: function () {
+    return getDefaultEip712TypesV2;
+  }
+});
+Object.defineProperty(exports, 'getDefaultSubaccountId', {
+  enumerable: true,
+  get: function () {
+    return getDefaultSubaccountId;
+  }
+});
+Object.defineProperty(exports, 'getEip712Domain', {
+  enumerable: true,
+  get: function () {
+    return getEip712Domain;
+  }
+});
+Object.defineProperty(exports, 'getEip712DomainV2', {
+  enumerable: true,
+  get: function () {
+    return getEip712DomainV2;
+  }
+});
+Object.defineProperty(exports, 'getEip712Fee', {
+  enumerable: true,
+  get: function () {
+    return getEip712Fee;
+  }
+});
+Object.defineProperty(exports, 'getEip712FeeV2', {
+  enumerable: true,
+  get: function () {
+    return getEip712FeeV2;
+  }
+});
+Object.defineProperty(exports, 'getEip712TypedData', {
+  enumerable: true,
+  get: function () {
+    return getEip712TypedData;
+  }
+});
+Object.defineProperty(exports, 'getEip712TypedDataV2', {
+  enumerable: true,
+  get: function () {
+    return getEip712TypedDataV2;
+  }
+});
+Object.defineProperty(exports, 'getEipTxContext', {
+  enumerable: true,
+  get: function () {
+    return getEipTxContext;
+  }
+});
+Object.defineProperty(exports, 'getEipTxDetails', {
+  enumerable: true,
+  get: function () {
+    return getEipTxDetails;
+  }
+});
+Object.defineProperty(exports, 'getEthereumAddress', {
+  enumerable: true,
+  get: function () {
+    return getEthereumAddress;
+  }
+});
+Object.defineProperty(exports, 'getEthereumSignerAddress', {
+  enumerable: true,
+  get: function () {
+    return getEthereumSignerAddress;
+  }
+});
+Object.defineProperty(exports, 'getInjectiveAddress', {
+  enumerable: true,
+  get: function () {
+    return getInjectiveAddress;
+  }
+});
+Object.defineProperty(exports, 'getInjectiveAddressFromSubaccountId', {
+  enumerable: true,
+  get: function () {
+    return getInjectiveAddressFromSubaccountId;
+  }
+});
+Object.defineProperty(exports, 'getInjectiveSignerAddress', {
+  enumerable: true,
+  get: function () {
+    return getInjectiveSignerAddress;
+  }
+});
+Object.defineProperty(exports, 'getObjectEip712PropertyType', {
+  enumerable: true,
+  get: function () {
+    return getObjectEip712PropertyType;
+  }
+});
+Object.defineProperty(exports, 'getPublicKey', {
+  enumerable: true,
+  get: function () {
+    return getPublicKey;
+  }
+});
+Object.defineProperty(exports, 'getSubaccountId', {
+  enumerable: true,
+  get: function () {
+    return getSubaccountId;
+  }
+});
+Object.defineProperty(exports, 'getTensMultiplier', {
+  enumerable: true,
+  get: function () {
+    return getTensMultiplier;
+  }
+});
+Object.defineProperty(exports, 'getTransactionPartsFromTxRaw', {
+  enumerable: true,
+  get: function () {
+    return getTransactionPartsFromTxRaw;
+  }
+});
+Object.defineProperty(exports, 'getTypesIncludingFeePayer', {
+  enumerable: true,
+  get: function () {
+    return getTypesIncludingFeePayer;
+  }
+});
+Object.defineProperty(exports, 'hashToHex', {
+  enumerable: true,
+  get: function () {
+    return hashToHex;
+  }
+});
+Object.defineProperty(exports, 'hexToBase64', {
+  enumerable: true,
+  get: function () {
+    return hexToBase64;
+  }
+});
+Object.defineProperty(exports, 'hexToBuff', {
+  enumerable: true,
+  get: function () {
+    return hexToBuff;
+  }
+});
+Object.defineProperty(exports, 'hexToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return hexToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'isCw20ContractAddress', {
+  enumerable: true,
+  get: function () {
+    return isCw20ContractAddress;
+  }
+});
+Object.defineProperty(exports, 'isNumber', {
+  enumerable: true,
+  get: function () {
+    return isNumber;
+  }
+});
+Object.defineProperty(exports, 'messageHash', {
+  enumerable: true,
+  get: function () {
+    return messageHash;
+  }
+});
+Object.defineProperty(exports, 'numberToCosmosSdkDecString', {
+  enumerable: true,
+  get: function () {
+    return numberToCosmosSdkDecString;
+  }
+});
+Object.defineProperty(exports, 'numberTypeToReflectionNumberType', {
+  enumerable: true,
+  get: function () {
+    return numberTypeToReflectionNumberType;
+  }
+});
+Object.defineProperty(exports, 'objectKeysToEip712Types', {
+  enumerable: true,
+  get: function () {
+    return objectKeysToEip712Types;
+  }
+});
+Object.defineProperty(exports, 'prepareSignBytes', {
+  enumerable: true,
+  get: function () {
+    return prepareSignBytes;
+  }
+});
+Object.defineProperty(exports, 'privateKeyHashToPublicKey', {
+  enumerable: true,
+  get: function () {
+    return privateKeyHashToPublicKey;
+  }
+});
+Object.defineProperty(exports, 'privateKeyHashToPublicKeyBase64', {
+  enumerable: true,
+  get: function () {
+    return privateKeyHashToPublicKeyBase64;
+  }
+});
+Object.defineProperty(exports, 'privateKeyToPublicKey', {
+  enumerable: true,
+  get: function () {
+    return privateKeyToPublicKey;
+  }
+});
+Object.defineProperty(exports, 'privateKeyToPublicKeyBase64', {
+  enumerable: true,
+  get: function () {
+    return privateKeyToPublicKeyBase64;
+  }
+});
+Object.defineProperty(exports, 'protoTypeToAminoType', {
+  enumerable: true,
+  get: function () {
+    return protoTypeToAminoType;
+  }
+});
+Object.defineProperty(exports, 'publicKeyToAddress', {
+  enumerable: true,
+  get: function () {
+    return publicKeyToAddress;
+  }
+});
+Object.defineProperty(exports, 'recoverTypedSignaturePubKey', {
+  enumerable: true,
+  get: function () {
+    return recoverTypedSignaturePubKey;
+  }
+});
+Object.defineProperty(exports, 'removeHexPrefix', {
+  enumerable: true,
+  get: function () {
+    return removeHexPrefix;
+  }
+});
+Object.defineProperty(exports, 'ripemd160', {
+  enumerable: true,
+  get: function () {
+    return ripemd160;
+  }
+});
+Object.defineProperty(exports, 'sanitizeTypedData', {
+  enumerable: true,
+  get: function () {
+    return sanitizeTypedData;
+  }
+});
+Object.defineProperty(exports, 'sha256', {
+  enumerable: true,
+  get: function () {
+    return sha256;
+  }
+});
+Object.defineProperty(exports, 'spotPriceFromChainPrice', {
+  enumerable: true,
+  get: function () {
+    return spotPriceFromChainPrice;
+  }
+});
+Object.defineProperty(exports, 'spotPriceFromChainPriceToFixed', {
+  enumerable: true,
+  get: function () {
+    return spotPriceFromChainPriceToFixed;
+  }
+});
+Object.defineProperty(exports, 'spotPriceToChainPrice', {
+  enumerable: true,
+  get: function () {
+    return spotPriceToChainPrice;
+  }
+});
+Object.defineProperty(exports, 'spotPriceToChainPriceToFixed', {
+  enumerable: true,
+  get: function () {
+    return spotPriceToChainPriceToFixed;
+  }
+});
+Object.defineProperty(exports, 'spotQuantityFromChainQuantity', {
+  enumerable: true,
+  get: function () {
+    return spotQuantityFromChainQuantity;
+  }
+});
+Object.defineProperty(exports, 'spotQuantityFromChainQuantityToFixed', {
+  enumerable: true,
+  get: function () {
+    return spotQuantityFromChainQuantityToFixed;
+  }
+});
+Object.defineProperty(exports, 'spotQuantityToChainQuantity', {
+  enumerable: true,
+  get: function () {
+    return spotQuantityToChainQuantity;
+  }
+});
+Object.defineProperty(exports, 'spotQuantityToChainQuantityToFixed', {
+  enumerable: true,
+  get: function () {
+    return spotQuantityToChainQuantityToFixed;
+  }
+});
+Object.defineProperty(exports, 'stringToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return stringToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'stringTypeToReflectionStringType', {
+  enumerable: true,
+  get: function () {
+    return stringTypeToReflectionStringType;
+  }
+});
+Object.defineProperty(exports, 'toBase64', {
+  enumerable: true,
+  get: function () {
+    return toBase64;
+  }
+});
+Object.defineProperty(exports, 'toUtf8', {
+  enumerable: true,
+  get: function () {
+    return toUtf8;
+  }
+});
+Object.defineProperty(exports, 'uint8ArrayToBase64', {
+  enumerable: true,
+  get: function () {
+    return uint8ArrayToBase64;
+  }
+});
+Object.defineProperty(exports, 'uint8ArrayToHex', {
+  enumerable: true,
+  get: function () {
+    return uint8ArrayToHex;
+  }
+});
+Object.defineProperty(exports, 'uint8ArrayToString', {
+  enumerable: true,
+  get: function () {
+    return uint8ArrayToString;
+  }
+});