@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/cjs/core/tx/broadcaster/MsgBroadcasterWithPk.d.ts

@@ -0,0 +1,107 @@
+import { PrivateKey } from '../../accounts/index.js';
+import { Msgs } from '../../modules/msgs.js';
+import { ChainId, EthereumChainId } from '@injectivelabs/ts-types';
+import { Network, NetworkEndpoints } from '@injectivelabs/networks';
+import { AccountDetails } from '../../../types/auth.js';
+interface MsgBroadcasterTxOptions {
+    msgs: Msgs | Msgs[];
+    memo?: string;
+    gas?: {
+        gasPrice?: string;
+        gas?: number; /** gas limit */
+        feePayer?: string;
+        granter?: string;
+    };
+}
+interface MsgBroadcasterWithPkOptions {
+    network?: Network;
+    /**
+     * Only used if we want to override the default
+     * endpoints taken from the network param
+     */
+    endpoints?: {
+        indexer: string;
+        grpc: string;
+        rest: string;
+    };
+    privateKey: string | PrivateKey;
+    ethereumChainId?: EthereumChainId;
+    chainId?: ChainId;
+    simulateTx?: boolean;
+    loggingEnabled?: boolean;
+    useRest?: boolean;
+    txTimeout?: number;
+    gasBufferCoefficient?: number;
+    txTimeoutOnFeeDelegation?: boolean;
+}
+/**
+ * This class is used to broadcast transactions
+ * using a privateKey as a signer
+ * for the transactions and broadcasting
+ * the transactions directly to the node
+ *
+ * Mainly used for working in a Node Environment
+ */
+export declare class MsgBroadcasterWithPk {
+    endpoints: NetworkEndpoints;
+    chainId: ChainId;
+    ethereumChainId?: EthereumChainId;
+    privateKey: PrivateKey;
+    simulateTx: boolean;
+    txTimeoutOnFeeDelegation: boolean;
+    useRest: boolean;
+    gasBufferCoefficient: number;
+    txTimeout: number;
+    constructor(options: MsgBroadcasterWithPkOptions);
+    /**
+     * Broadcasting the transaction using the client
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcast(transaction: MsgBroadcasterTxOptions, accountDetails?: AccountDetails): Promise<import("../types/tx.js").TxResponse>;
+    /**
+     * Broadcasting the transaction with fee delegation services
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    broadcastWithFeeDelegation(transaction: MsgBroadcasterTxOptions): Promise<import("../types/tx.js").TxResponse>;
+    /**
+     * Broadcasting the transaction using the client
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    simulate(transaction: MsgBroadcasterTxOptions, accountDetails?: AccountDetails): Promise<{
+        result: {
+            data: string | Uint8Array<ArrayBufferLike>;
+            log: string;
+            eventsList: import("@injectivelabs/core-proto-ts/cjs/tendermint/abci/types.js").Event[];
+            events?: import("@injectivelabs/core-proto-ts/cjs/tendermint/abci/types.js").Event[] | undefined;
+            msgResponses?: import("@injectivelabs/core-proto-ts/cjs/google/protobuf/any.js").Any[] | undefined;
+        };
+        gasInfo: {
+            gasWanted: number;
+            gasUsed: number;
+        };
+    }>;
+    /**
+     * In case we don't want to simulate the transaction
+     * we get the gas limit based on the message type.
+     *
+     * If we want to simulate the transaction we set the
+     * gas limit based on the simulation and add a small multiplier
+     * to be safe (factor of 1.1 (or user specified))
+     */
+    private getTxWithStdFee;
+    /**
+     * Create TxRaw and simulate it
+     */
+    private simulateTxRaw;
+    private prepareTxForBroadcast;
+    private getAccountDetails;
+    private getTimeoutHeight;
+    private broadcastTxRaw;
+}
+export {};

package/dist/cjs/core/tx/broadcaster/MsgBroadcasterWithPk.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgBroadcasterWithPk = void 0;
+const index_js_1 = require("../../accounts/index.js");
+const tx_js_1 = require("../tx.js");
+const TxGrpcApi_js_1 = require("../api/TxGrpcApi.js");
+const index_js_2 = require("../../../client/chain/grpc/index.js");
+const index_js_3 = require("../../../client/chain/rest/index.js");
+const utils_1 = require("@injectivelabs/utils");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const networks_1 = require("@injectivelabs/networks");
+const msgs_js_1 = require("../../../utils/msgs.js");
+const index_js_4 = require("../../../client/index.js");
+const index_js_5 = require("../../../json/index.js");
+/**
+ * This class is used to broadcast transactions
+ * using a privateKey as a signer
+ * for the transactions and broadcasting
+ * the transactions directly to the node
+ *
+ * Mainly used for working in a Node Environment
+ */
+class MsgBroadcasterWithPk {
+    endpoints;
+    chainId;
+    ethereumChainId;
+    privateKey;
+    simulateTx = false;
+    txTimeoutOnFeeDelegation = false;
+    useRest = false;
+    gasBufferCoefficient = 1.1;
+    txTimeout = utils_1.DEFAULT_BLOCK_TIMEOUT_HEIGHT;
+    constructor(options) {
+        const network = options.network || networks_1.Network.MainnetSentry;
+        const networkInfo = (0, networks_1.getNetworkInfo)(network);
+        const endpoints = (0, networks_1.getNetworkEndpoints)(network);
+        this.useRest = options.useRest || false;
+        this.gasBufferCoefficient = options.gasBufferCoefficient || 1.1;
+        this.simulateTx = options.simulateTx || false;
+        this.chainId = options.chainId || networkInfo.chainId;
+        this.txTimeout = options.txTimeout || utils_1.DEFAULT_BLOCK_TIMEOUT_HEIGHT;
+        this.ethereumChainId =
+            options.ethereumChainId || networkInfo.ethereumChainId;
+        this.endpoints = { ...endpoints, ...(options.endpoints || {}) };
+        this.privateKey =
+            options.privateKey instanceof index_js_1.PrivateKey
+                ? options.privateKey
+                : index_js_1.PrivateKey.fromHex(options.privateKey);
+        this.txTimeoutOnFeeDelegation =
+            options.txTimeoutOnFeeDelegation || this.txTimeoutOnFeeDelegation;
+    }
+    /**
+     * Broadcasting the transaction using the client
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    async broadcast(transaction, accountDetails) {
+        const { privateKey } = this;
+        if (index_js_5.ofacWallets.includes(privateKey.toHex())) {
+            throw new exceptions_1.GeneralException(new Error('You cannot execute this transaction'));
+        }
+        const { txRaw } = await this.prepareTxForBroadcast(transaction, accountDetails);
+        return await this.broadcastTxRaw(txRaw);
+    }
+    /**
+     * Broadcasting the transaction with fee delegation services
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    async broadcastWithFeeDelegation(transaction) {
+        const { simulateTx, privateKey, ethereumChainId, endpoints, txTimeoutOnFeeDelegation, txTimeout, } = this;
+        const ethereumWallet = this.privateKey.toHex();
+        if (index_js_5.ofacWallets.includes(ethereumWallet)) {
+            throw new exceptions_1.GeneralException(new Error('You cannot execute this transaction'));
+        }
+        const msgs = Array.isArray(transaction.msgs)
+            ? transaction.msgs
+            : [transaction.msgs];
+        const tx = {
+            ...transaction,
+            msgs: msgs,
+            ethereumAddress: ethereumWallet,
+        };
+        const web3Msgs = msgs.map((msg) => msg.toWeb3());
+        if (!ethereumChainId) {
+            throw new exceptions_1.GeneralException(new Error('Please provide ethereumChainId'));
+        }
+        let timeoutHeight = undefined;
+        if (txTimeoutOnFeeDelegation) {
+            const latestBlock = await new index_js_2.ChainGrpcTendermintApi(endpoints.grpc).fetchLatestBlock();
+            const latestHeight = latestBlock.header.height;
+            timeoutHeight = new utils_1.BigNumberInBase(latestHeight)
+                .plus(txTimeout)
+                .toNumber();
+        }
+        const transactionApi = new index_js_4.IndexerGrpcWeb3GwApi(endpoints.web3gw || endpoints.indexer);
+        const txResponse = await transactionApi.prepareTxRequest({
+            memo: tx.memo,
+            message: web3Msgs,
+            address: tx.ethereumAddress,
+            chainId: ethereumChainId,
+            gasLimit: (0, msgs_js_1.getGasPriceBasedOnMessage)(msgs),
+            estimateGas: simulateTx || false,
+            timeoutHeight,
+        });
+        const signature = await privateKey.signTypedData(JSON.parse(txResponse.data));
+        const response = await transactionApi.broadcastTxRequest({
+            txResponse,
+            message: web3Msgs,
+            chainId: ethereumChainId,
+            signature: `0x${Buffer.from(signature).toString('hex')}`,
+        });
+        return await new TxGrpcApi_js_1.TxGrpcApi(endpoints.grpc).fetchTxPoll(response.txHash);
+    }
+    /**
+     * Broadcasting the transaction using the client
+     *
+     * @param tx
+     * @returns {string} transaction hash
+     */
+    async simulate(transaction, accountDetails) {
+        const { privateKey, endpoints, chainId } = this;
+        const ethereumWallet = this.privateKey.toHex();
+        if (index_js_5.ofacWallets.includes(ethereumWallet)) {
+            throw new exceptions_1.GeneralException(new Error('You cannot execute this transaction'));
+        }
+        const tx = {
+            ...transaction,
+            msgs: Array.isArray(transaction.msgs)
+                ? transaction.msgs
+                : [transaction.msgs],
+        };
+        /** Account Details * */
+        const publicKey = privateKey.toPublicKey();
+        const actualAccountDetails = await this.getAccountDetails(accountDetails);
+        /** Block Details */
+        const timeoutHeight = await this.getTimeoutHeight();
+        /** Prepare the Transaction * */
+        const { txRaw } = (0, tx_js_1.createTransaction)({
+            memo: tx.memo || '',
+            fee: utils_1.DEFAULT_STD_FEE,
+            message: tx.msgs,
+            timeoutHeight: timeoutHeight.toNumber(),
+            pubKey: publicKey.toBase64(),
+            sequence: actualAccountDetails.sequence,
+            accountNumber: actualAccountDetails.accountNumber,
+            chainId: chainId,
+        });
+        /** Append Blank Signatures */
+        txRaw.signatures = [new Uint8Array(0)];
+        /** Simulate transaction */
+        const simulationResponse = await new TxGrpcApi_js_1.TxGrpcApi(endpoints.grpc).simulate(txRaw);
+        return simulationResponse;
+    }
+    /**
+     * In case we don't want to simulate the transaction
+     * we get the gas limit based on the message type.
+     *
+     * If we want to simulate the transaction we set the
+     * gas limit based on the simulation and add a small multiplier
+     * to be safe (factor of 1.1 (or user specified))
+     */
+    async getTxWithStdFee(args) {
+        const { simulateTx, gasBufferCoefficient } = this;
+        if (!simulateTx) {
+            return (0, tx_js_1.createTransaction)(args);
+        }
+        const result = await this.simulateTxRaw(args);
+        if (!result.gasInfo?.gasUsed) {
+            return (0, tx_js_1.createTransaction)(args);
+        }
+        const stdGasFee = (0, utils_1.getStdFee)({
+            ...args.fee,
+            gas: new utils_1.BigNumberInBase(result.gasInfo.gasUsed)
+                .times(gasBufferCoefficient)
+                .toFixed(),
+        });
+        return (0, tx_js_1.createTransaction)({ ...args, fee: stdGasFee });
+    }
+    /**
+     * Create TxRaw and simulate it
+     */
+    async simulateTxRaw(args) {
+        const { endpoints } = this;
+        const { txRaw } = (0, tx_js_1.createTransaction)(args);
+        txRaw.signatures = [new Uint8Array(0)];
+        const simulationResponse = await new TxGrpcApi_js_1.TxGrpcApi(endpoints.grpc).simulate(txRaw);
+        return simulationResponse;
+    }
+    async prepareTxForBroadcast(transaction, accountDetails) {
+        const { chainId, privateKey } = this;
+        const msgs = Array.isArray(transaction.msgs)
+            ? transaction.msgs
+            : [transaction.msgs];
+        const tx = {
+            ...transaction,
+            msgs: msgs,
+        };
+        /** Account Details * */
+        const publicKey = privateKey.toPublicKey();
+        const actualAccountDetails = await this.getAccountDetails(accountDetails);
+        /** Block Details */
+        const timeoutHeight = await this.getTimeoutHeight();
+        const gas = (transaction.gas?.gas || (0, msgs_js_1.getGasPriceBasedOnMessage)(msgs)).toString();
+        /** Prepare the Transaction * */
+        const { signBytes, txRaw } = await this.getTxWithStdFee({
+            memo: tx.memo || '',
+            message: msgs,
+            fee: (0, utils_1.getStdFee)({ ...tx.gas, gas }),
+            timeoutHeight: timeoutHeight.toNumber(),
+            pubKey: publicKey.toBase64(),
+            sequence: actualAccountDetails.sequence,
+            accountNumber: actualAccountDetails.accountNumber,
+            chainId: chainId,
+        });
+        /** Sign transaction */
+        const signature = await privateKey.sign(Buffer.from(signBytes));
+        /** Append Signatures */
+        txRaw.signatures = [signature];
+        return { txRaw, accountDetails: actualAccountDetails };
+    }
+    async getAccountDetails(accountDetails) {
+        const { useRest } = this;
+        if (accountDetails) {
+            return accountDetails;
+        }
+        if (useRest) {
+            const { privateKey, endpoints } = this;
+            const accountDetailsResponse = await new index_js_3.ChainRestAuthApi(endpoints.grpc).fetchAccount(privateKey.toBech32());
+            const baseAccount = accountDetailsResponse.account.base_account;
+            return {
+                accountNumber: parseInt(baseAccount.account_number),
+                sequence: parseInt(baseAccount.sequence),
+                address: baseAccount.address,
+                pubKey: baseAccount.pub_key
+                    ? {
+                        key: baseAccount.pub_key.key,
+                        type: baseAccount.pub_key['@type'],
+                    }
+                    : {
+                        key: '',
+                        type: '',
+                    },
+            };
+        }
+        const { privateKey, endpoints } = this;
+        const accountDetailsResponse = await new index_js_2.ChainGrpcAuthApi(endpoints.grpc).fetchAccount(privateKey.toBech32());
+        const baseAccount = accountDetailsResponse.baseAccount;
+        return {
+            accountNumber: baseAccount.accountNumber,
+            sequence: baseAccount.sequence,
+            address: baseAccount.address,
+            pubKey: baseAccount.pubKey
+                ? {
+                    key: baseAccount.pubKey.key,
+                    type: baseAccount.pubKey.typeUrl,
+                }
+                : {
+                    key: '',
+                    type: '',
+                },
+        };
+    }
+    async getTimeoutHeight() {
+        const { useRest, endpoints, txTimeout } = this;
+        if (useRest) {
+            const latestBlock = await new index_js_3.ChainRestTendermintApi(endpoints.grpc).fetchLatestBlock();
+            const latestHeight = latestBlock.header.height;
+            return new utils_1.BigNumberInBase(latestHeight).plus(txTimeout);
+        }
+        const latestBlock = await new index_js_2.ChainGrpcTendermintApi(endpoints.grpc).fetchLatestBlock();
+        const latestHeight = latestBlock.header.height;
+        return new utils_1.BigNumberInBase(latestHeight).plus(txTimeout);
+    }
+    async broadcastTxRaw(txRaw) {
+        const { endpoints, txTimeout } = this;
+        const txResponse = await new TxGrpcApi_js_1.TxGrpcApi(endpoints.grpc).broadcast(txRaw, {
+            txTimeout,
+        });
+        if (txResponse.code !== 0) {
+            throw new exceptions_1.GeneralException(new Error(`Transaction failed to be broadcasted - ${txResponse.rawLog} - ${txResponse.txHash}`));
+        }
+        return txResponse;
+    }
+}
+exports.MsgBroadcasterWithPk = MsgBroadcasterWithPk;

package/dist/cjs/core/tx/broadcaster/index.d.ts

@@ -0,0 +1 @@
+export * from './MsgBroadcasterWithPk.js';

package/dist/cjs/core/tx/broadcaster/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MsgBroadcasterWithPk.js"), exports);

package/dist/cjs/core/tx/eip712/MsgDecoder.d.ts

@@ -0,0 +1,5 @@
+import { GoogleProtobufAny } from '@injectivelabs/core-proto-ts';
+import { Msgs } from '../../modules/msgs.js';
+export declare class MsgDecoder {
+    static decode(message: GoogleProtobufAny.Any): Msgs;
+}

package/dist/cjs/core/tx/eip712/MsgDecoder.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgDecoder = void 0;
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const index_js_1 = require("../../modules/exchange/index.js");
+const index_js_2 = require("../../../utils/index.js");
+class MsgDecoder {
+    static decode(message) {
+        const type = message.typeUrl;
+        switch (true) {
+            case type.includes('MsgIncreasePositionMargin'): {
+                const msg = core_proto_ts_1.InjectiveExchangeV1Beta1Tx.MsgIncreasePositionMargin.decode(message.value);
+                return index_js_1.MsgIncreasePositionMargin.fromJSON({
+                    marketId: msg.marketId,
+                    injectiveAddress: msg.sender,
+                    srcSubaccountId: msg.sourceSubaccountId,
+                    dstSubaccountId: msg.destinationSubaccountId,
+                    amount: msg.amount,
+                });
+            }
+            case type.includes('MsgSignData'): {
+                const msg = core_proto_ts_1.InjectiveExchangeV1Beta1Tx.MsgSignData.decode(message.value);
+                return index_js_1.MsgSignData.fromJSON({
+                    data: Buffer.from(msg.Data).toString('utf-8'),
+                    sender: (0, index_js_2.getInjectiveAddress)(Buffer.from(msg.Signer).toString('hex')),
+                });
+            }
+            default:
+                throw new Error('Unknown message type');
+        }
+    }
+}
+exports.MsgDecoder = MsgDecoder;

package/dist/cjs/core/tx/eip712/eip712.d.ts

@@ -0,0 +1,88 @@
+import { Msgs } from '../../modules/msgs.js';
+import { EthereumChainId } from '@injectivelabs/ts-types';
+import { Eip712ConvertFeeArgs, Eip712ConvertTxArgs } from './types.js';
+export declare const getEip712TypedData: ({ msgs, tx, fee, ethereumChainId, }: {
+    msgs: Msgs | Msgs[];
+    tx: Eip712ConvertTxArgs;
+    fee?: Eip712ConvertFeeArgs;
+    ethereumChainId: EthereumChainId;
+}) => {
+    message: {
+        msgs: {
+            type: string;
+            value: any;
+        }[];
+        fee: {
+            amount: {
+                amount: string;
+                denom: string;
+            }[];
+            gas: string;
+            feePayer?: string;
+        };
+        account_number: string;
+        chain_id: string;
+        sequence: string;
+        timeout_height: string;
+        memo: string;
+    };
+    domain: {
+        name: string;
+        version: string;
+        chainId: string;
+        salt: string;
+        verifyingContract: string;
+    };
+    primaryType: string;
+    types: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Tx: {
+            name: string;
+            type: string;
+        }[];
+        Fee: {
+            name: string;
+            type: string;
+        }[];
+        Coin: {
+            name: string;
+            type: string;
+        }[];
+        Msg: {
+            name: string;
+            type: string;
+        }[];
+    };
+};
+export declare const getEip712TypedDataV2: ({ msgs, tx, fee, ethereumChainId, }: {
+    msgs: Msgs | Msgs[];
+    tx: Eip712ConvertTxArgs;
+    fee?: Eip712ConvertFeeArgs;
+    ethereumChainId: EthereumChainId;
+}) => {
+    message: {
+        context: string;
+        msgs: string;
+    };
+    domain: {
+        name: string;
+        version: string;
+        chainId: string;
+        verifyingContract: string;
+        salt: string;
+    };
+    primaryType: string;
+    types: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Tx: {
+            name: string;
+            type: string;
+        }[];
+    };
+};

package/dist/cjs/core/tx/eip712/eip712.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEip712TypedDataV2 = exports.getEip712TypedData = void 0;
+const utils_js_1 = require("./utils.js");
+const utils_js_2 = require("./utils.js");
+const getEip712TypedData = ({ msgs, tx, fee, ethereumChainId, }) => {
+    const messages = Array.isArray(msgs) ? msgs : [msgs];
+    const eip712Msgs = messages.map((m) => m.toEip712());
+    const eip712MessageTypes = messages[0].toEip712Types();
+    const types = (0, utils_js_1.getDefaultEip712Types)();
+    const typesWithMessageTypes = {
+        types: {
+            ...types.types,
+            ...Object.fromEntries(eip712MessageTypes),
+        },
+    };
+    const typesWithFeePayer = (0, utils_js_1.getTypesIncludingFeePayer)({
+        fee,
+        types: typesWithMessageTypes,
+    });
+    return {
+        ...typesWithFeePayer,
+        primaryType: 'Tx',
+        ...(0, utils_js_1.getEip712Domain)(ethereumChainId),
+        message: {
+            ...(0, utils_js_1.getEipTxDetails)(tx),
+            ...(0, utils_js_1.getEip712Fee)(fee),
+            msgs: eip712Msgs,
+        },
+    };
+};
+exports.getEip712TypedData = getEip712TypedData;
+const getEip712TypedDataV2 = ({ msgs, tx, fee, ethereumChainId, }) => {
+    const messages = Array.isArray(msgs) ? msgs : [msgs];
+    const eip712Msgs = messages.map((m) => m.toEip712V2());
+    const types = (0, utils_js_1.getDefaultEip712TypesV2)();
+    return {
+        ...types,
+        primaryType: 'Tx',
+        ...(0, utils_js_1.getEip712DomainV2)(ethereumChainId),
+        message: {
+            context: JSON.stringify((0, utils_js_2.getEipTxContext)({ ...tx, fee })),
+            msgs: JSON.stringify(eip712Msgs),
+        },
+    };
+};
+exports.getEip712TypedDataV2 = getEip712TypedDataV2;

package/dist/cjs/core/tx/eip712/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './maps.js';
+export * from './utils.js';
+export * from './eip712.js';
+export * from './MsgDecoder.js';

package/dist/cjs/core/tx/eip712/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./maps.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./eip712.js"), exports);
+__exportStar(require("./MsgDecoder.js"), exports);

package/dist/cjs/core/tx/eip712/maps.d.ts

@@ -0,0 +1,35 @@
+import { TypedDataField } from './types.js';
+/**
+ * ONLY USED FOR EIP712_V1
+ *
+ * Function used to generate EIP712 types based on a message object
+ * and its structure (recursive)
+ */
+export declare const objectKeysToEip712Types: ({ object, messageType, primaryType, }: {
+    object: Record<string, any>;
+    messageType?: string;
+    primaryType?: string;
+}) => Map<string, TypedDataField[]>;
+/**
+ * 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
+ */
+export declare const numberTypeToReflectionNumberType: (property?: string, messageType?: string) => "timeout_timestamp" | "int32" | "uint32" | "int64" | "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
+ */
+export declare const stringTypeToReflectionStringType: (property?: string) => string;
+export declare const getObjectEip712PropertyType: ({ property, parentProperty, messageType, }: {
+    property: string;
+    parentProperty: string;
+    messageType?: string;
+}) => string;
+/**
+ * Mapping a path type to amino type for messages
+ */
+export declare const protoTypeToAminoType: (type: string) => string;