@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/esm/core/stargate/SigningStargateClient.js

@@ -0,0 +1,257 @@
+import { encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino, } from '@cosmjs/amino';
+import { Int53, Uint53 } from '@cosmjs/math';
+import { Registry, makeSignDoc, encodePubkey, isOfflineDirectSigner, makeAuthInfoBytes, } from '@cosmjs/proto-signing';
+import { Tendermint37Client, } from '@cosmjs/tendermint-rpc';
+import { assert, assertDefined } from '@cosmjs/utils';
+import { MsgWithdrawDelegatorReward } from 'cosmjs-types/cosmos/distribution/v1beta1/tx.js';
+import { MsgDelegate, MsgUndelegate, } from 'cosmjs-types/cosmos/staking/v1beta1/tx.js';
+import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing.js';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
+import { MsgTransfer } from 'cosmjs-types/ibc/applications/transfer/v1/tx.js';
+import { AminoTypes } from '@cosmjs/stargate';
+import { calculateFee } from '@cosmjs/stargate';
+import { createAuthzAminoConverters, createBankAminoConverters, createDistributionAminoConverters, createFeegrantAminoConverters, createGovAminoConverters, createIbcAminoConverters, createStakingAminoConverters, createVestingAminoConverters, } from '@cosmjs/stargate';
+import { defaultRegistryTypes, } from '@cosmjs/stargate';
+import { StargateClient } from './StargateClient.js';
+import { getPublicKey } from '../tx/index.js';
+export function createDefaultAminoConverters() {
+    return {
+        ...createAuthzAminoConverters(),
+        ...createBankAminoConverters(),
+        ...createDistributionAminoConverters(),
+        ...createGovAminoConverters(),
+        ...createStakingAminoConverters(),
+        ...createIbcAminoConverters(),
+        ...createFeegrantAminoConverters(),
+        ...createVestingAminoConverters(),
+    };
+}
+export class SigningStargateClient extends StargateClient {
+    registry;
+    broadcastTimeoutMs;
+    broadcastPollIntervalMs;
+    signer;
+    aminoTypes;
+    gasPrice;
+    /**
+     * Creates an instance by connecting to the given Tendermint RPC endpoint.
+     *
+     * For now this uses the Tendermint 0.34 client. If you need Tendermint 0.37
+     * support, see `createWithSigner`.
+     */
+    static async connectWithSigner(endpoint, signer, options = {}) {
+        const tmClient = await Tendermint37Client.connect(endpoint);
+        return SigningStargateClient.createWithSigner(tmClient, signer, options);
+    }
+    /**
+     * Creates an instance from a manually created Tendermint client.
+     * Use this to use `Tendermint37Client` instead of `Tendermint37Client`.
+     */
+    static async createWithSigner(tmClient, signer, options = {}) {
+        return new SigningStargateClient(tmClient, signer, options);
+    }
+    /**
+     * Creates a client in offline mode.
+     *
+     * This should only be used in niche cases where you know exactly what you're doing,
+     * e.g. when building an offline signing application.
+     *
+     * When you try to use online functionality with such a signer, an
+     * exception will be raised.
+     */
+    static async offline(signer, options = {}) {
+        return new SigningStargateClient(undefined, signer, options);
+    }
+    constructor(tmClient, signer, options) {
+        super(tmClient, options);
+        const { registry = new Registry(defaultRegistryTypes), aminoTypes = new AminoTypes(createDefaultAminoConverters()), } = options;
+        this.registry = registry;
+        this.aminoTypes = aminoTypes;
+        this.signer = signer;
+        this.broadcastTimeoutMs = options.broadcastTimeoutMs;
+        this.broadcastPollIntervalMs = options.broadcastPollIntervalMs;
+        this.gasPrice = options.gasPrice;
+    }
+    async simulate(signerAddress, messages, memo) {
+        const anyMsgs = messages.map((m) => this.registry.encodeAsAny(m));
+        const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
+        if (!accountFromSigner) {
+            throw new Error('Failed to retrieve account from signer');
+        }
+        const pubkey = encodeSecp256k1Pubkey(accountFromSigner.pubkey);
+        const { sequence } = await this.getSequence(signerAddress);
+        const { gasInfo } = await this.forceGetQueryClient().tx.simulate(anyMsgs, memo, pubkey, sequence);
+        assertDefined(gasInfo);
+        return Uint53.fromString(gasInfo.gasUsed.toString()).toNumber();
+    }
+    async sendTokens(senderAddress, recipientAddress, amount, fee, memo = '') {
+        const sendMsg = {
+            typeUrl: '/cosmos.bank.v1beta1.MsgSend',
+            value: {
+                fromAddress: senderAddress,
+                toAddress: recipientAddress,
+                amount: [...amount],
+            },
+        };
+        return this.signAndBroadcast(senderAddress, [sendMsg], fee, memo);
+    }
+    async delegateTokens(delegatorAddress, validatorAddress, amount, fee, memo = '') {
+        const delegateMsg = {
+            typeUrl: '/cosmos.staking.v1beta1.MsgDelegate',
+            value: MsgDelegate.fromPartial({
+                delegatorAddress: delegatorAddress,
+                validatorAddress: validatorAddress,
+                amount: amount,
+            }),
+        };
+        return this.signAndBroadcast(delegatorAddress, [delegateMsg], fee, memo);
+    }
+    async undelegateTokens(delegatorAddress, validatorAddress, amount, fee, memo = '') {
+        const undelegateMsg = {
+            typeUrl: '/cosmos.staking.v1beta1.MsgUndelegate',
+            value: MsgUndelegate.fromPartial({
+                delegatorAddress: delegatorAddress,
+                validatorAddress: validatorAddress,
+                amount: amount,
+            }),
+        };
+        return this.signAndBroadcast(delegatorAddress, [undelegateMsg], fee, memo);
+    }
+    async withdrawRewards(delegatorAddress, validatorAddress, fee, memo = '') {
+        const withdrawMsg = {
+            typeUrl: '/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward',
+            value: MsgWithdrawDelegatorReward.fromPartial({
+                delegatorAddress: delegatorAddress,
+                validatorAddress: validatorAddress,
+            }),
+        };
+        return this.signAndBroadcast(delegatorAddress, [withdrawMsg], fee, memo);
+    }
+    async sendIbcTokens(senderAddress, recipientAddress, transferAmount, sourcePort, sourceChannel, timeoutHeight, 
+    /** timeout in seconds */
+    timeoutTimestamp, fee, memo = '') {
+        const timeoutTimestampNanoseconds = timeoutTimestamp
+            ? BigInt(timeoutTimestamp) * BigInt(1_000_000_000)
+            : undefined;
+        const transferMsg = {
+            typeUrl: '/ibc.applications.transfer.v1.MsgTransfer',
+            value: MsgTransfer.fromPartial({
+                sourcePort: sourcePort,
+                sourceChannel: sourceChannel,
+                sender: senderAddress,
+                receiver: recipientAddress,
+                token: transferAmount,
+                timeoutHeight: timeoutHeight,
+                timeoutTimestamp: timeoutTimestampNanoseconds,
+            }),
+        };
+        return this.signAndBroadcast(senderAddress, [transferMsg], fee, memo);
+    }
+    async signAndBroadcast(signerAddress, messages, fee, memo = '') {
+        let usedFee;
+        if (fee == 'auto' || typeof fee === 'number') {
+            assertDefined(this.gasPrice, 'Gas price must be set in the client options when auto gas is used.');
+            const gasEstimation = await this.simulate(signerAddress, messages, memo);
+            const multiplier = typeof fee === 'number' ? fee : 1.3;
+            usedFee = calculateFee(Math.round(gasEstimation * multiplier), this.gasPrice);
+        }
+        else {
+            usedFee = fee;
+        }
+        const txRaw = await this.sign(signerAddress, messages, usedFee, memo);
+        const txBytes = TxRaw.encode(txRaw).finish();
+        return this.broadcastTx(txBytes, this.broadcastTimeoutMs, this.broadcastPollIntervalMs);
+    }
+    /**
+     * Gets account number and sequence from the API, creates a sign doc,
+     * creates a single signature and assembles the signed transaction.
+     *
+     * The sign mode (SIGN_MODE_DIRECT or SIGN_MODE_LEGACY_AMINO_JSON) is determined by this client's signer.
+     *
+     * You can pass signer data (account number, sequence and chain ID) explicitly instead of querying them
+     * from the chain. This is needed when signing for a multisig account, but it also allows for offline signing
+     * (See the SigningStargateClient.offline constructor).
+     */
+    async sign(signerAddress, messages, fee, memo, explicitSignerData) {
+        let signerData;
+        if (explicitSignerData) {
+            signerData = explicitSignerData;
+        }
+        else {
+            const { accountNumber, sequence } = await this.getSequence(signerAddress);
+            const chainId = await this.getChainId();
+            signerData = {
+                accountNumber: accountNumber,
+                sequence: sequence,
+                chainId: chainId,
+            };
+        }
+        return isOfflineDirectSigner(this.signer)
+            ? this.signDirect(signerAddress, messages, fee, memo, signerData)
+            : this.signAmino(signerAddress, messages, fee, memo, signerData);
+    }
+    async signAmino(signerAddress, messages, fee, memo, { accountNumber, sequence, chainId }) {
+        assert(!isOfflineDirectSigner(this.signer));
+        const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
+        if (!accountFromSigner) {
+            throw new Error('Failed to retrieve account from signer');
+        }
+        const pubkey = chainId.startsWith('injective')
+            ? getPublicKey({
+                chainId,
+                key: Buffer.from(accountFromSigner.pubkey).toString('base64'),
+            })
+            : encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+        const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+        const msgs = messages.map((msg) => this.aminoTypes.toAmino(msg));
+        const signDoc = makeSignDocAmino(msgs, fee, chainId, memo, accountNumber, sequence);
+        const { signature, signed } = await this.signer.signAmino(signerAddress, signDoc);
+        const signedTxBody = {
+            messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
+            memo: signed.memo,
+        };
+        const signedTxBodyEncodeObject = {
+            typeUrl: '/cosmos.tx.v1beta1.TxBody',
+            value: signedTxBody,
+        };
+        const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
+        const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber();
+        const signedSequence = Int53.fromString(signed.sequence).toNumber();
+        const signedAuthInfoBytes = makeAuthInfoBytes([{ pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, signed.fee.granter, signed.fee.payer, signMode);
+        return TxRaw.fromPartial({
+            bodyBytes: signedTxBodyBytes,
+            authInfoBytes: signedAuthInfoBytes,
+            signatures: [Buffer.from(signature.signature, 'base64')],
+        });
+    }
+    async signDirect(signerAddress, messages, fee, memo, { accountNumber, sequence, chainId }) {
+        assert(isOfflineDirectSigner(this.signer));
+        const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
+        if (!accountFromSigner) {
+            throw new Error('Failed to retrieve account from signer');
+        }
+        const pubkey = chainId.startsWith('injective')
+            ? getPublicKey({
+                chainId,
+                key: Buffer.from(accountFromSigner.pubkey).toString('base64'),
+            })
+            : encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+        const txBodyEncodeObject = {
+            typeUrl: '/cosmos.tx.v1beta1.TxBody',
+            value: {
+                messages: messages,
+                memo: memo,
+            },
+        };
+        const txBodyBytes = this.registry.encode(txBodyEncodeObject);
+        const gasLimit = Int53.fromString(fee.gas).toNumber();
+        const authInfoBytes = makeAuthInfoBytes([{ pubkey, sequence }], fee.amount, gasLimit, fee.granter, fee.payer);
+        const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
+        const { signature, signed } = await this.signer.signDirect(signerAddress, signDoc);
+        return TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [Buffer.from(signature.signature, 'base64')],
+        });
+    }
+}

package/dist/esm/core/stargate/StargateClient.d.ts

@@ -0,0 +1,4 @@
+import { Account, StargateClient as CosmjsStargateClient } from '@cosmjs/stargate';
+export declare class StargateClient extends CosmjsStargateClient {
+    getAccount(searchAddress: string): Promise<Account | null>;
+}

package/dist/esm/core/stargate/StargateClient.js

@@ -0,0 +1,24 @@
+import { StargateClient as CosmjsStargateClient, accountFromAny, } from '@cosmjs/stargate';
+import { accountParser as injectiveAccountParser } from '../accounts/AccountParser.js';
+export class StargateClient extends CosmjsStargateClient {
+    async getAccount(searchAddress) {
+        try {
+            const chainId = await this.getChainId();
+            const isInjective = chainId.startsWith('injective');
+            const account = await this.forceGetQueryClient().auth.account(searchAddress);
+            if (!account) {
+                return null;
+            }
+            if (isInjective) {
+                return injectiveAccountParser(account);
+            }
+            return accountFromAny(account);
+        }
+        catch (error) {
+            if (/rpc error: code = NotFound/i.test(error.toString())) {
+                return null;
+            }
+            throw error;
+        }
+    }
+}

package/dist/esm/core/stargate/index.d.ts

@@ -0,0 +1,2 @@
+export { StargateClient as InjectiveStargateClient } from './StargateClient.js';
+export { SigningStargateClient as InjectiveSigningStargateClient } from './SigningStargateClient.js';

package/dist/esm/core/stargate/index.js

@@ -0,0 +1,2 @@
+export { StargateClient as InjectiveStargateClient } from './StargateClient.js';
+export { SigningStargateClient as InjectiveSigningStargateClient } from './SigningStargateClient.js';

package/dist/esm/core/tx/api/TxGrpcApi.d.ts

@@ -0,0 +1,26 @@
+import { TxConcreteApi, TxClientBroadcastOptions, TxClientBroadcastResponse } from '../types/tx.js';
+import { TxResponse } from '../types/tx.js';
+import { CosmosTxV1Beta1Service, CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+export declare class TxGrpcApi implements TxConcreteApi {
+    txService: CosmosTxV1Beta1Service.ServiceClientImpl;
+    endpoint: string;
+    constructor(endpoint: string);
+    fetchTx(hash: string): Promise<TxResponse>;
+    fetchTxPoll(txHash: string, timeout?: number): Promise<TxResponse>;
+    simulate(txRaw: CosmosTxV1Beta1Tx.TxRaw): 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;
+        };
+    }>;
+    broadcast(txRaw: CosmosTxV1Beta1Tx.TxRaw, options?: TxClientBroadcastOptions): Promise<TxResponse>;
+    /** @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async */
+    broadcastBlock(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<TxClientBroadcastResponse>;
+}

package/dist/esm/core/tx/api/TxGrpcApi.js

@@ -0,0 +1,176 @@
+import { GeneralException, TransactionException, grpcErrorCodeToErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { BigNumberInBase, DEFAULT_BLOCK_TIME_IN_SECONDS, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS, } from '@injectivelabs/utils';
+import BaseGrpcWebConsumer from '../../../client/base/BaseGrpcWebConsumer.js';
+import { CosmosTxV1Beta1Service, CosmosTxV1Beta1Tx, } from '@injectivelabs/core-proto-ts';
+export class TxGrpcApi {
+    txService;
+    endpoint;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.txService = new CosmosTxV1Beta1Service.ServiceClientImpl(BaseGrpcWebConsumer.getGrpcWebImpl(endpoint));
+    }
+    async fetchTx(hash) {
+        const request = CosmosTxV1Beta1Service.GetTxRequest.create();
+        request.hash = hash;
+        try {
+            const response = await this.txService.GetTx(request);
+            const txResponse = response.txResponse;
+            if (!txResponse) {
+                throw new GrpcUnaryRequestException(new Error(`The transaction with ${hash} is not found`), {
+                    context: 'TxGrpcApi',
+                    contextModule: 'fetch-tx',
+                });
+            }
+            if (txResponse.code !== 0) {
+                throw new TransactionException(new Error(txResponse.rawLog), {
+                    contextCode: txResponse.code,
+                    contextModule: txResponse.codespace,
+                });
+            }
+            return {
+                ...txResponse,
+                height: parseInt(txResponse.height, 10),
+                gasWanted: parseInt(txResponse.gasWanted, 10),
+                gasUsed: parseInt(txResponse.gasUsed, 10),
+                txHash: txResponse.txhash,
+            };
+        }
+        catch (e) {
+            // Transaction has failed on the chain
+            if (e instanceof TransactionException) {
+                throw e;
+            }
+            // Failed to query the transaction on the chain
+            if (e instanceof CosmosTxV1Beta1Service.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                });
+            }
+            // The response itself failed
+            throw new GrpcUnaryRequestException(new Error('There was an issue while fetching transaction details'), {
+                context: 'TxGrpcApi',
+                contextModule: 'fetch-tx',
+            });
+        }
+    }
+    async fetchTxPoll(txHash, timeout = DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS || 60000) {
+        const POLL_INTERVAL = DEFAULT_BLOCK_TIME_IN_SECONDS * 1000;
+        for (let i = 0; i <= timeout / POLL_INTERVAL; i += 1) {
+            try {
+                const txResponse = await this.fetchTx(txHash);
+                if (txResponse) {
+                    return txResponse;
+                }
+            }
+            catch (e) {
+                // We throw only if the transaction failed on chain
+                if (e instanceof TransactionException) {
+                    throw e;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+        }
+        // Transaction was not included in the block in the desired timeout
+        throw new GrpcUnaryRequestException(new Error(`Transaction was not included in a block before timeout of ${timeout}ms`), {
+            context: 'TxGrpcApi',
+            contextModule: 'fetch-tx-poll',
+        });
+    }
+    async simulate(txRaw) {
+        const { txService } = this;
+        const txRawClone = CosmosTxV1Beta1Tx.TxRaw.fromPartial({ ...txRaw });
+        const simulateRequest = CosmosTxV1Beta1Service.SimulateRequest.create();
+        if (txRawClone.signatures.length === 0) {
+            txRawClone.signatures = [new Uint8Array(0)];
+        }
+        simulateRequest.txBytes =
+            CosmosTxV1Beta1Tx.TxRaw.encode(txRawClone).finish();
+        try {
+            const response = await txService.Simulate(simulateRequest);
+            const result = {
+                ...response.result,
+                data: response.result ? response.result.data : '',
+                log: response.result ? response.result.log : '',
+                eventsList: response.result ? response.result.events : [],
+            };
+            const gasInfo = {
+                ...response.gasInfo,
+                gasWanted: response.gasInfo
+                    ? parseInt(response.gasInfo.gasWanted, 10)
+                    : 0,
+                gasUsed: response.gasInfo ? parseInt(response.gasInfo.gasUsed, 10) : 0,
+            };
+            return {
+                result: result,
+                gasInfo: gasInfo,
+            };
+        }
+        catch (e) {
+            throw new TransactionException(new Error(e));
+        }
+    }
+    async broadcast(txRaw, options) {
+        const { txService } = this;
+        const mode = options?.mode || CosmosTxV1Beta1Service.BroadcastMode.BROADCAST_MODE_SYNC;
+        const timeout = options?.timeout ||
+            new BigNumberInBase(options?.txTimeout || DEFAULT_BLOCK_TIMEOUT_HEIGHT)
+                .times(DEFAULT_BLOCK_TIME_IN_SECONDS * 1000)
+                .toNumber();
+        const broadcastTxRequest = CosmosTxV1Beta1Service.BroadcastTxRequest.create();
+        broadcastTxRequest.txBytes = CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish();
+        broadcastTxRequest.mode = mode;
+        try {
+            const response = await txService.BroadcastTx(broadcastTxRequest);
+            const txResponse = response.txResponse;
+            if (txResponse.code !== 0) {
+                throw new TransactionException(new Error(txResponse.rawLog), {
+                    contextCode: txResponse.code,
+                    contextModule: txResponse.codespace,
+                });
+            }
+            const result = await this.fetchTxPoll(txResponse.txhash, timeout);
+            return result;
+        }
+        catch (e) {
+            if (e instanceof TransactionException) {
+                throw e;
+            }
+            throw new TransactionException(new Error(e));
+        }
+    }
+    /** @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async */
+    async broadcastBlock(txRaw) {
+        const { txService } = this;
+        const broadcastTxRequest = CosmosTxV1Beta1Service.BroadcastTxRequest.create();
+        broadcastTxRequest.txBytes = CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish();
+        broadcastTxRequest.mode =
+            CosmosTxV1Beta1Service.BroadcastMode.BROADCAST_MODE_BLOCK;
+        try {
+            const response = await txService.BroadcastTx(broadcastTxRequest);
+            const txResponse = response.txResponse;
+            if (!txResponse) {
+                throw new GeneralException(new Error('There was an issue broadcasting the transaction'));
+            }
+            const result = {
+                ...txResponse,
+                height: parseInt(txResponse.height, 10),
+                gasWanted: parseInt(txResponse.gasWanted, 10),
+                gasUsed: parseInt(txResponse.gasUsed, 10),
+                txHash: txResponse.txhash,
+            };
+            if (result.code !== 0) {
+                throw new TransactionException(new Error(result.rawLog), {
+                    contextCode: result.code,
+                    contextModule: result.codespace,
+                });
+            }
+            return result;
+        }
+        catch (e) {
+            if (e instanceof TransactionException) {
+                throw e;
+            }
+            throw new TransactionException(new Error(e));
+        }
+    }
+}

package/dist/esm/core/tx/api/TxRestApi.d.ts

@@ -0,0 +1,55 @@
+import { HttpClient } from '@injectivelabs/utils';
+import { TxClientBroadcastOptions, TxConcreteApi } from '../types/tx.js';
+import { TxResponse } from '../types/tx.js';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+/**
+ * It is recommended to use TxGrpcClient instead of TxRestApi
+ */
+export declare class TxRestApi implements TxConcreteApi {
+    httpClient: HttpClient;
+    constructor(endpoint: string, options?: {
+        timeout?: number;
+    });
+    fetchTx(txHash: string, params?: any): Promise<TxResponse>;
+    fetchTxPoll(txHash: string, timeout?: number): Promise<TxResponse>;
+    simulate(txRaw: CosmosTxV1Beta1Tx.TxRaw): Promise<{
+        result: {
+            data: string;
+            log: string;
+            eventsList: {
+                type: string;
+                attributes: {
+                    key: string;
+                    value: string;
+                }[];
+            }[];
+        };
+        gasInfo: {
+            gasWanted: number;
+            gasUsed: number;
+        };
+    }>;
+    broadcast(tx: CosmosTxV1Beta1Tx.TxRaw, options?: TxClientBroadcastOptions): Promise<TxResponse>;
+    /**
+     * Broadcast the transaction using the "block" mode, waiting for its inclusion in the blockchain.
+     * @param tx transaction to broadcast
+     *
+     * @deprecated - the BLOCk mode broadcasting is deprecated now, use either sync or async
+     */
+    broadcastBlock(tx: CosmosTxV1Beta1Tx.TxRaw): Promise<{
+        txHash: string;
+        rawLog: string;
+        gasWanted: number;
+        gasUsed: number;
+        height: number;
+        logs: import("../types/tx-rest-client.js").RestTxLog[];
+        code: number;
+        codespace: string;
+        data: string;
+        info: string;
+        timestamp: string;
+    }>;
+    private broadcastTx;
+    private getRaw;
+    private postRaw;
+}