example-js-sdk 0.0.1

package/lib/wallet/CarbonWallet.js

@@ -0,0 +1,790 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonWallet = void 0;
+const CarbonSDK_1 = require("../CarbonSDK");
+const codec_1 = require("../codec");
+const auth_1 = require("../codec/cosmos/auth/v1beta1/auth");
+const web3_1 = require("../codec/ethermint/types/v1/web3");
+const constant_1 = require("../constant");
+const grant_1 = require("../constant/grant");
+const walletProvider_1 = require("../constant/walletProvider");
+const grant_2 = require("../modules/grant");
+const util_1 = require("../util");
+const address_1 = require("../util/address");
+const auth_2 = require("../util/auth");
+const blockchain_1 = require("../util/blockchain");
+const ethermint_1 = require("../util/ethermint");
+const evm_1 = require("../util/evm");
+const fetch_1 = require("../util/fetch");
+const generic_1 = require("../util/generic");
+const number_1 = require("../util/number");
+const tx_1 = require("../util/tx");
+const amino_1 = require("@cosmjs/amino");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+const responses_1 = require("@cosmjs/tendermint-rpc/build/tendermint37/responses");
+const utils_1 = require("@cosmjs/utils");
+const axios_1 = __importDefault(require("axios"));
+const tx_2 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const ethers_1 = require("ethers");
+const jwt_decode_1 = require("jwt-decode");
+const CarbonSigner_1 = require("./CarbonSigner");
+const CarbonSigningClient_1 = require("./CarbonSigningClient");
+const bytes_1 = require("../util/bytes");
+dayjs_1.default.extend(utc_1.default);
+class CarbonWallet {
+    constructor(opts) {
+        this.initialized = false;
+        this.isRainbowKit = false;
+        this.sequenceInvalidated = false;
+        this.isAccountNotFoundError = (error, address) => {
+            return error.message?.includes(`account ${address} not found`);
+        };
+        this.isTxHashNotFound = (error, hash) => {
+            return error.message?.includes(`tx (${hash}) not found`);
+        };
+        this.isNonceMismatchError = (error) => {
+            const errorMessage = 'account sequence mismatch';
+            const includes = error?.message.includes(errorMessage);
+            if (includes) {
+                return {
+                    message: error?.message,
+                };
+            }
+            return false;
+        };
+        const network = opts.network ?? constant_1.DEFAULT_NETWORK;
+        this.network = network;
+        this.txDefaultBroadCastMode = opts.txDefaultBroadcastMode;
+        this.networkConfig = constant_1.NetworkConfigs[network];
+        this.configOverride = opts.config ?? {};
+        this.providerAgent = opts.providerAgent;
+        this.defaultTimeoutBlocks = opts.defaultTimeoutBlocks ?? 30; // default ~1 minute
+        this.disableRetryOnSequenceError = opts.disableRetryOnSequenceError ?? false;
+        this.triggerMerge = opts.triggerMerge ?? false;
+        this.jwt = opts?.jwt;
+        this.gasFee = opts.gasFee;
+        this.updateNetwork(network);
+        this.isRainbowKit = opts.isRainbowKit ?? false;
+        this.onRequestSign = opts.onRequestSign;
+        this.onSignComplete = opts.onSignComplete;
+        this.onBroadcastTxSuccess = opts.onBroadcastTxSuccess;
+        this.onBroadcastTxFail = opts.onBroadcastTxFail;
+        this.onRequestAuth = opts.onRequestAuth;
+        this.onAuthComplete = opts.onAuthComplete;
+        this.txDispatchManager = new generic_1.QueueManager(this.dispatchTx.bind(this));
+        this.txSignManager = new generic_1.QueueManager(this.signTx.bind(this));
+        // this.mnemonic = opts.mnemonic;
+        // if (this.mnemonic) {
+        //   this.privateKey = AddressUtils.SWTHAddress.mnemonicToPrivateKey(this.mnemonic);
+        // } else if ("privateKey" in opts && opts.privateKey) {
+        //   this.privateKey = AddressUtils.stringOrBufferToBuffer(opts.privateKey)!;
+        // }
+        const addressOpts = {
+            network,
+            ...(this.configOverride.Bech32Prefix && {
+                bech32Prefix: this.configOverride.Bech32Prefix,
+            }),
+        };
+        switch (opts.mode) {
+            case "mnemonic": {
+                this.mnemonic = opts.mnemonic;
+                this.privateKey = util_1.AddressUtils.SWTHAddress.mnemonicToPrivateKey(this.mnemonic);
+                this.publicKey = util_1.AddressUtils.SWTHAddress.privateToPublicKey(this.privateKey);
+                this.bech32Address = util_1.AddressUtils.SWTHAddress.publicKeyToAddress(this.publicKey, addressOpts);
+                let prefix = addressOpts.bech32Prefix;
+                if (!addressOpts.bech32Prefix)
+                    prefix = address_1.SWTHAddress.getBech32Prefix(addressOpts?.network, addressOpts?.bech32Prefix);
+                if (!prefix)
+                    throw new Error("cannot instantiate wallet signer, no prefix");
+                this.signer = new CarbonSigner_1.CarbonPrivateKeySigner((0, bytes_1.toUint8Array)(this.privateKey), prefix);
+                break;
+            }
+            case "privateKey": {
+                this.privateKey = util_1.AddressUtils.stringOrBufferToBuffer(opts.privateKey);
+                this.publicKey = util_1.AddressUtils.SWTHAddress.privateToPublicKey(this.privateKey);
+                this.bech32Address = util_1.AddressUtils.SWTHAddress.publicKeyToAddress(this.publicKey, addressOpts);
+                let prefix = addressOpts.bech32Prefix;
+                if (!addressOpts.bech32Prefix)
+                    prefix = address_1.SWTHAddress.getBech32Prefix(addressOpts?.network, addressOpts?.bech32Prefix);
+                if (!prefix)
+                    throw new Error("cannot instantiate wallet signer, no prefix");
+                this.signer = new CarbonSigner_1.CarbonPrivateKeySigner((0, bytes_1.toUint8Array)(this.privateKey), prefix);
+                break;
+            }
+            case "customSigner": {
+                this.signer = opts.signer;
+                this.publicKey = Buffer.from(opts.publicKeyBase64, "base64");
+                this.bech32Address = util_1.AddressUtils.SWTHAddress.publicKeyToAddress(this.publicKey, addressOpts);
+                break;
+            }
+            case "viewOnly": {
+                this.signer = new CarbonSigner_1.CarbonNonSigner();
+                this.publicKey = Buffer.from([]);
+                this.bech32Address = opts.bech32Address;
+                break;
+            }
+            case "qr": {
+                if (!opts.mnemonic || !opts.expiry || !opts.granter)
+                    throw new Error("grantor, grantee and expiry must be provided to create grantee wallet");
+                this.publicKey = Buffer.from([]);
+                this.bech32Address = opts.granter;
+                let prefix = addressOpts.bech32Prefix;
+                if (!addressOpts.bech32Prefix)
+                    prefix = address_1.SWTHAddress.getBech32Prefix(addressOpts?.network, addressOpts?.bech32Prefix);
+                if (!prefix)
+                    throw new Error("cannot instantiate wallet signer, no prefix");
+                const pkSigner = new CarbonSigner_1.CarbonPrivateKeySigner((0, bytes_1.toUint8Array)(util_1.AddressUtils.SWTHAddress.mnemonicToPrivateKey(opts.mnemonic)), prefix);
+                this.signer = pkSigner;
+                this.setGrantee({
+                    expiry: opts.expiry,
+                    signer: pkSigner,
+                });
+                break;
+            }
+        }
+        const addressBytes = util_1.AddressUtils.SWTHAddress.getAddressBytes(this.bech32Address, this.network);
+        this.hexAddress = `0x${Buffer.from(addressBytes).toString("hex")}`;
+        this.evmHexAddress = this.bech32Address ? '' : util_1.AddressUtils.ETHAddress.publicKeyToAddress(this.publicKey, addressOpts);
+        this.evmBech32Address = this.bech32Address ? '' : util_1.AddressUtils.ETHAddress.publicKeyToBech32Address(this.publicKey, addressOpts);
+    }
+    async initialize(queryClient, gasFee, fallbackConfig = null, opts) {
+        this.query = queryClient;
+        this.gasFee = gasFee;
+        const promises = [
+            this.reloadAccountSequence(),
+            this.reloadMergeAccountStatus(),
+        ];
+        if (!this.tmClient)
+            promises.push(this.reconnectTmClient(fallbackConfig));
+        if (opts?.enableJwtAuth && !this.isViewOnlyWallet())
+            promises.push(this.reloadJwtToken(undefined, opts?.authMessage));
+        if (this.isViewOnlyWallet())
+            promises.push(this.queryViewOnlyEvmHexAddress());
+        await Promise.all(promises);
+        this.initialized = true;
+        return this;
+    }
+    async reloadJwtToken(request, authMessage = evm_1.DEFAULT_PUBLIC_KEY_MESSAGE) {
+        const network = this.network;
+        if (this.jwt) {
+            const { iss, exp } = (0, jwt_decode_1.jwtDecode)(this.jwt.access_token);
+            if (!(0, auth_2.isValidIssuer)(iss, network))
+                return this.getNewJwtToken(authMessage, request);
+            const accessTokenExpired = (0, auth_2.hasExpired)(exp);
+            if (accessTokenExpired) {
+                if (!(0, auth_2.hasRefreshTokenExpired)(this.jwt.refresh_token))
+                    return this.refreshJwtToken(this.jwt.refresh_token);
+                return this.getNewJwtToken(authMessage, request);
+            }
+            return;
+        }
+        return this.getNewJwtToken(authMessage, request);
+    }
+    async queryViewOnlyEvmHexAddress() {
+        const queryClient = this.getQueryClient();
+        const response = await queryClient.evmmerge.MappedAddress({ address: this.bech32Address });
+        const evmBech32Address = response?.mappedAddress;
+        if (!evmBech32Address)
+            return;
+        this.evmBech32Address = evmBech32Address;
+        const addressBytes = address_1.SWTHAddress.getAddressBytes(evmBech32Address, this.network);
+        if (addressBytes.length === 20) {
+            const lowerCaseAddress = '0x' + Buffer.from(addressBytes).toString('hex');
+            this.evmHexAddress = ethers_1.utils.getAddress(lowerCaseAddress);
+        }
+    }
+    async refreshJwtToken(refreshToken) {
+        const request = {
+            grant_type: auth_2.GrantType.RefreshToken,
+            refresh_token: refreshToken,
+        };
+        const response = await axios_1.default.post(this.networkConfig.authUrl, request);
+        this.jwt = response.data.result;
+    }
+    async getNewJwtToken(authMessage, request) {
+        const req = request ?? await this.constructGrantRequest(authMessage);
+        const response = await axios_1.default.post(this.networkConfig.authUrl, req);
+        this.jwt = response.data.result;
+    }
+    async constructGrantRequest(authMessage) {
+        try {
+            await util_1.GenericUtils.callIgnoreError(() => this.onRequestAuth?.());
+            const address = this.isEvmWallet() ? this.evmHexAddress : this.bech32Address;
+            const message = util_1.AuthUtils.getAuthMessage(authMessage);
+            const signature = await this.signer.signMessage(address, message);
+            return {
+                grant_type: this.isEvmWallet() ? auth_2.GrantType.SignatureEth : auth_2.GrantType.SignatureCosmos,
+                message,
+                public_key: this.publicKey.toString('hex'),
+                signature,
+            };
+        }
+        finally {
+            await util_1.GenericUtils.callIgnoreError(() => this.onAuthComplete?.());
+        }
+    }
+    setGrantee(grantee) {
+        this.grantee = grantee;
+    }
+    isGranteeValid() {
+        if (!this.grantee)
+            return false;
+        const { expiry } = this.grantee;
+        const hasNotExpired = dayjs_1.default.utc(expiry).isAfter(dayjs_1.default.utc().add(grant_1.BUFFER_PERIOD, 'seconds'));
+        return hasNotExpired && !!this.grantee.signer;
+    }
+    updateNetwork(network) {
+        this.network = network;
+        this.networkConfig = util_1.GenericUtils.overrideConfig(constant_1.NetworkConfigs[network], this.configOverride);
+        delete this.signingClient;
+        return this;
+    }
+    setAuthorizedMsgs(msgs) {
+        this.authorizedMsgs = msgs;
+    }
+    async getSignedTx(signerAddress, messages, sequence, opts, granterAddress) {
+        const { memo = "", accountNumber, explicitSignerData, feeDenom } = opts;
+        const signingClient = await this.getSigningClient();
+        const [account] = await this.signer.getAccounts();
+        let signature = null;
+        const evmChainId = this.evmChainId;
+        try {
+            await util_1.GenericUtils.callIgnoreError(() => this.onRequestSign?.(messages));
+            const signerData = {
+                accountNumber: accountNumber ?? this.accountInfo.accountNumber,
+                chainId: this.getChainId(),
+                sequence,
+                ...explicitSignerData,
+                evmChainId,
+            };
+            const fee = opts?.fee ?? this.estimateTxFee(messages, feeDenom);
+            const txRaw = await signingClient.sign(signerAddress, messages, fee, memo, signerData, granterAddress);
+            let sig;
+            if ((0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer)) {
+                if (this.signer.legacyEip712SignMode) {
+                    const feePayerSigBz = web3_1.ExtensionOptionsWeb3Tx.decode(tx_2.TxBody.decode(txRaw.bodyBytes).extensionOptions[0].value).feePayerSig;
+                    sig = Uint8Array.from(Buffer.from(feePayerSigBz.slice(0, -1)));
+                }
+                else {
+                    sig = txRaw.signatures[0];
+                }
+                signature = (0, amino_1.encodeSecp256k1Signature)(account.pubkey, sig);
+                signature = {
+                    ...signature,
+                    pub_key: { ...signature.pub_key, type: ethermint_1.ETH_SECP256K1_TYPE },
+                };
+                return txRaw;
+            }
+            signature = (0, amino_1.encodeSecp256k1Signature)(account.pubkey, txRaw.signatures[0]);
+            return txRaw;
+        }
+        finally {
+            await util_1.GenericUtils.callIgnoreError(() => this.onSignComplete?.(signature));
+        }
+    }
+    /**
+     * broadcast TX and wait for block confirmation
+     *
+     */
+    async broadcastTx(txRaw, opts = {}) {
+        const { pollIntervalMs = 3000, timeoutMs = 60000 } = opts;
+        const tx = CarbonWallet.TxRaw.encode(txRaw).finish();
+        const carbonClient = await this.getSigningClient();
+        const response = await carbonClient.broadcastTx(tx, timeoutMs, pollIntervalMs);
+        if ((0, stargate_1.isDeliverTxFailure)(response)) {
+            // tx failed
+            throw new tx_1.CarbonCustomError(`[${response.code}] ${response.rawLog}`, tx_1.ErrorType.BLOCK_FAIL, response);
+        }
+        return response;
+    }
+    /**
+     * broadcast TX to mempool but doesnt wait for block confirmation
+     *
+     */
+    async broadcastTxToMempoolWithoutConfirm(txRaw) {
+        const tx = CarbonWallet.TxRaw.encode(txRaw).finish();
+        const tmClient = await this.getTmClient();
+        const response = await tmClient.broadcastTxSync({ tx });
+        if (!(0, responses_1.broadcastTxSyncSuccess)(response)) {
+            // tx failed
+            throw new tx_1.CarbonCustomError(`[${response.code}] ${response.log}`, tx_1.ErrorType.BROADCAST_FAIL, response);
+        }
+        return response;
+    }
+    /**
+     * broadcast TX but doesnt wait for block confirmation nor submission to mempool
+     *
+     */
+    async broadcastTxWithoutConfirm(txRaw) {
+        const tx = CarbonWallet.TxRaw.encode(txRaw).finish();
+        const tmClient = await this.getTmClient();
+        return tmClient.broadcastTxAsync({ tx });
+    }
+    async signAndBroadcast(messages, signOpts, broadcastOpts) {
+        const promise = new Promise((resolve, reject) => {
+            const msgs = signOpts?.processMsgs?.(messages) ?? messages;
+            this.txSignManager.enqueue({
+                signerAddress: this.bech32Address,
+                messages: msgs,
+                broadcastOpts,
+                signOpts,
+                handler: { resolve, reject },
+            });
+        });
+        return promise;
+    }
+    async signTx(txRequest) {
+        const { reattempts, signerAddress, signOpts, broadcastOpts, messages, handler: { resolve, reject }, } = txRequest;
+        const isAuthorized = messages.every((message) => this.authorizedMsgs?.includes(message.typeUrl));
+        if (this.isGranteeValid() && isAuthorized) {
+            await this.signWithGrantee(txRequest);
+        }
+        else {
+            try {
+                if (!this.accountInfo
+                    || this.accountInfo?.address === this.evmBech32Address // refresh to check if carbon acc is present
+                    || this.sequenceInvalidated)
+                    await this.reloadAccountSequence();
+                let timeoutHeight;
+                // timeoutHeight is not supported for EIP-712
+                if (!(0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer)) {
+                    timeoutHeight = await this.getTimeoutHeight();
+                }
+                let sequence;
+                if (!this.accountInfo) {
+                    sequence = signOpts?.sequence ?? 0;
+                }
+                else {
+                    sequence = this.accountInfo.sequence;
+                    this.accountInfo = {
+                        ...this.accountInfo,
+                        sequence: sequence + 1,
+                    };
+                }
+                const _signOpts = {
+                    ...signOpts,
+                    explicitSignerData: {
+                        timeoutHeight,
+                        ...signOpts?.explicitSignerData,
+                    },
+                };
+                const signedTx = await this.getSignedTx(signerAddress, messages, sequence, _signOpts);
+                this.txDispatchManager.enqueue({
+                    reattempts,
+                    signerAddress,
+                    messages,
+                    signedTx,
+                    broadcastOpts,
+                    signOpts: _signOpts,
+                    handler: { resolve, reject, requestId: `${sequence}` },
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+    }
+    async signWithGrantee(txRequest) {
+        const { reattempts, signOpts, messages, handler: { resolve, reject }, } = txRequest;
+        try {
+            if (!this.grantee) {
+                throw new Error("grantee not set");
+            }
+            const signer = this.grantee.signer;
+            const accounts = await signer.getAccounts();
+            if (!accounts.length) {
+                throw Error("cannot retrieve grantee accounts");
+            }
+            const granteeAddress = accounts[0].address;
+            const accountInfo = await this.getAccount(granteeAddress);
+            if (!accountInfo) {
+                throw new Error("grantee account not initialized");
+            }
+            const msgExecMessages = grant_2.GrantModule.wrapInMsgExec(granteeAddress, messages);
+            const timeoutHeight = await this.getTimeoutHeight();
+            const fee = signOpts?.fee ?? this.estimateTxFee(msgExecMessages, signOpts?.feeDenom);
+            const memo = signOpts?.memo ?? "";
+            const sequence = signOpts?.sequence ?? accountInfo.sequence;
+            const accountNumber = signOpts?.accountNumber ?? accountInfo.accountNumber;
+            const _signOpts = {
+                ...signOpts,
+                explicitSignerData: {
+                    timeoutHeight,
+                    ...signOpts?.explicitSignerData,
+                },
+            };
+            const signerData = {
+                accountNumber,
+                chainId: this.getChainId(),
+                sequence,
+                ...signOpts?.explicitSignerData,
+            };
+            const tmClient = await this.getTmClient();
+            const signingClient = new CarbonSigningClient_1.CarbonSigningClient(tmClient, signer);
+            const signedTx = await signingClient.sign(granteeAddress, msgExecMessages, fee, memo, signerData, this.bech32Address);
+            this.txDispatchManager.enqueue({
+                ...txRequest,
+                reattempts,
+                signedTx,
+                signOpts: _signOpts,
+                handler: { resolve, reject, requestId: `${sequence}` },
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    }
+    getBroadcastFunc(broadcastMode) {
+        switch (broadcastMode) {
+            case tx_1.BroadcastTxMode.BroadcastTxSync: return this.broadcastTxToMempoolWithoutConfirm.bind(this);
+            case tx_1.BroadcastTxMode.BroadcastTxAsync: return this.broadcastTxWithoutConfirm.bind(this);
+        }
+        return this.broadcastTx.bind(this);
+    }
+    async dispatchTx(txRequest) {
+        const { broadcastOpts, signedTx, handler: { resolve, reject }, } = txRequest;
+        const broadcastMode = broadcastOpts?.mode ?? this.txDefaultBroadCastMode;
+        const broadcastFunc = this.getBroadcastFunc(broadcastMode);
+        try {
+            const result = await broadcastFunc(signedTx, broadcastOpts);
+            resolve(result);
+        }
+        catch (error) {
+            const reattempts = txRequest.reattempts ?? 0;
+            // retry sendTx if nonce error once.
+            if (!this.disableRetryOnSequenceError && reattempts < 1 && this.isNonceMismatchError(error)) {
+                // invalidate account sequence for reload on next signTx call
+                this.sequenceInvalidated = true;
+                // requeue transaction for signTx
+                this.txSignManager.enqueue({
+                    reattempts: (reattempts ?? 0) + 1,
+                    signerAddress: txRequest.signerAddress,
+                    messages: txRequest.messages,
+                    broadcastOpts,
+                    signOpts: txRequest.signOpts,
+                    handler: { resolve, reject },
+                });
+            }
+            else {
+                reject(error);
+            }
+        }
+    }
+    async sendTxs(msgs, opts) {
+        if (this.triggerMerge || opts?.triggerMerge) {
+            await this.sendInitialMergeAccountTx(msgs, opts);
+        }
+        try {
+            const result = await this.signAndBroadcast(msgs, opts);
+            if (msgs[0].typeUrl === util_1.CarbonTx.Types.MsgMergeAccount) {
+                this.updateMergeAccountStatus();
+            }
+            await util_1.GenericUtils.callIgnoreError(() => this.onBroadcastTxSuccess?.(msgs));
+            return result;
+        }
+        catch (error) {
+            await util_1.GenericUtils.callIgnoreError(() => this.onBroadcastTxFail?.(msgs));
+            throw error;
+        }
+    }
+    async sendInitialMergeAccountTx(msgs, opts) {
+        let msg;
+        await this.reloadMergeAccountStatus();
+        if (!this.accountMerged && msgs[0].typeUrl !== util_1.CarbonTx.Types.MsgMergeAccount) {
+            const accountInfo = await this.reloadAccountInfo();
+            if (!accountInfo) {
+                throw new Error('Account not found!');
+            }
+            const { address, sequence, accountNumber } = accountInfo;
+            try {
+                msg = {
+                    typeUrl: util_1.CarbonTx.Types.MsgMergeAccount,
+                    value: CarbonSDK_1.Carbon.Evmmerge.MsgMergeAccount.fromPartial({
+                        creator: address,
+                        pubKey: this.publicKey.toString('hex'),
+                    }),
+                };
+                const modifiedOpts = {
+                    ...opts,
+                    sequence,
+                    accountNumber,
+                };
+                await this.signAndBroadcast([msg], modifiedOpts, { mode: tx_1.BroadcastTxMode.BroadcastTxBlock });
+                this.updateMergeAccountStatus();
+                await util_1.GenericUtils.callIgnoreError(() => this.onBroadcastTxSuccess?.([msg]));
+            }
+            catch (error) {
+                await util_1.GenericUtils.callIgnoreError(() => this.onBroadcastTxFail?.([msg]));
+                throw error;
+            }
+        }
+    }
+    async sendTxsWithoutConfirm(msgs, opts) {
+        await this.reloadMergeAccountStatus();
+        if (this.triggerMerge || opts?.triggerMerge) {
+            await this.sendInitialMergeAccountTx(msgs, opts);
+        }
+        const result = await this.signAndBroadcast(msgs, opts, { mode: tx_1.BroadcastTxMode.BroadcastTxSync });
+        return result;
+    }
+    async sendTx(msg, opts) {
+        return this.sendTxs([msg], opts);
+    }
+    async waitForTx(txHash, throwIfNotIncludedInBlock = false, timeoutMs = 30000, pollIntervalMs = 500) {
+        const txId = txHash.toUpperCase();
+        let timedOut = false;
+        const txPollTimeout = setTimeout(() => {
+            timedOut = true;
+        }, timeoutMs);
+        const pollForTx = async (txId) => {
+            try {
+                if (timedOut) {
+                    throw new stargate_1.TimeoutError(`Transaction with ID ${txId} was submitted but was not yet found on the chain. You might want to check later. There was a wait of ${timeoutMs / 1000} seconds.`, txId);
+                }
+                const hash = Uint8Array.from(Buffer.from(txId, 'hex'));
+                const tmClient = await this.getTmClient();
+                const response = await tmClient.tx({ hash });
+                const { result } = response;
+                const isDeliverTxFailure = result.code !== 0;
+                if (isDeliverTxFailure && throwIfNotIncludedInBlock)
+                    throw new tx_1.CarbonCustomError(`[${result.code}] ${result.log}`, tx_1.ErrorType.BLOCK_FAIL, response);
+                return response;
+            }
+            catch (err) {
+                const error = err;
+                if (this.isTxHashNotFound(error, txId)) {
+                    await (0, utils_1.sleep)(pollIntervalMs);
+                    return pollForTx(txId);
+                }
+                throw err;
+            }
+        };
+        return new Promise((resolve, reject) => pollForTx(txId).then((value) => {
+            clearTimeout(txPollTimeout);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(txPollTimeout);
+            reject(error);
+        }));
+    }
+    async getSigningClient() {
+        const tmClient = await this.getTmClient();
+        if (!this.signingClient) {
+            this.signingClient = new CarbonSigningClient_1.CarbonSigningClient(tmClient, this.signer);
+        }
+        return this.signingClient;
+    }
+    async getTimeoutHeight() {
+        try {
+            const cacheBuster = ~~(new Date().getTime() / 1000);
+            const response = await (0, fetch_1.fetch)(`${this.networkConfig.tmRpcUrl}/blockchain?cache=${cacheBuster}`);
+            const body = await response.json();
+            if (!body.result?.last_height)
+                return undefined;
+            return (0, number_1.bnOrZero)(body.result?.last_height).plus(this.defaultTimeoutBlocks).toNumber();
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async getTmClient(reconnect = false) {
+        if (!this.tmClient || reconnect) {
+            this.tmClient = await tendermint_rpc_1.Tendermint37Client.connect(this.networkConfig.tmRpcUrl);
+            const status = await this.tmClient.status();
+            this.chainId = status.nodeInfo.network;
+            this.evmChainId = constant_1.CarbonEvmChainIDs[this.network];
+        }
+        return this.tmClient;
+    }
+    getChainId() {
+        if (!this.chainId)
+            throw new Error("CarbonWallet is not initialized");
+        return this.chainId;
+    }
+    getEvmChainId() {
+        if (!this.evmChainId)
+            throw new Error("CarbonWallet is not initialized");
+        return this.evmChainId;
+    }
+    isSigner(signerType) {
+        return this.signer.type === signerType;
+    }
+    isLedgerSigner() {
+        return this.isSigner(CarbonSigner_1.CarbonSignerTypes.Ledger) || this.isLedgerViaBrowserExtension();
+    }
+    isLedgerViaBrowserExtension() {
+        return (this.providerAgent === walletProvider_1.ProviderAgent.KeplrExtension || this.providerAgent === walletProvider_1.ProviderAgent.LeapExtension) && !(0, proto_signing_1.isOfflineDirectSigner)(this.signer);
+    }
+    isPrivateKeySigner() {
+        return this.isSigner(CarbonSigner_1.CarbonSignerTypes.PrivateKey);
+    }
+    isBrowserInjectedSigner() {
+        return this.isSigner(CarbonSigner_1.CarbonSignerTypes.BrowserInjected);
+    }
+    isNonSigner() {
+        return this.isSigner(CarbonSigner_1.CarbonSignerTypes.PublicKey);
+    }
+    isSmartWalletEnabled() {
+        return !!(this.mnemonic || this.privateKey);
+    }
+    getSmartWalletPrivateKey(blockchain = blockchain_1.SmartWalletBlockchain.Ethereum) {
+        if (this.mnemonic) {
+            switch (blockchain) {
+                case blockchain_1.SmartWalletBlockchain.Ethereum:
+                case blockchain_1.SmartWalletBlockchain.BinanceSmartChain:
+                    return address_1.ETHAddress.mnemonicToPrivateKey(this.mnemonic);
+                default:
+                    return null;
+            }
+        }
+        if (this.privateKey)
+            return this.privateKey;
+        return null;
+    }
+    async reconnectTmClient(fallbackConfig) {
+        try {
+            await this.getTmClient(true);
+        }
+        catch (err) {
+            const errorTyped = err;
+            if (errorTyped.message.includes("Failed to fetch") && fallbackConfig) {
+                this.chainId = fallbackConfig.chainId;
+                this.evmChainId = fallbackConfig.evmChainId;
+            }
+        }
+    }
+    async reloadAccountInfo() {
+        // carbon account always takes priority
+        let evmBech32Acc = null;
+        const bech32Acc = this.bech32Address && await this.getAccount(this.bech32Address);
+        if (!bech32Acc && this.evmBech32Address) {
+            evmBech32Acc = await this.getAccount(this.evmBech32Address);
+        }
+        return bech32Acc ?? evmBech32Acc ?? undefined;
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async getAccount(queryAddress, retryCount = 0) {
+        try {
+            const result = await this.getQueryClient().auth.Account({ address: queryAddress });
+            if (result?.account) {
+                const { accountNumber, sequence, address } = auth_1.BaseAccount.decode(result.account.value);
+                return {
+                    address,
+                    pubkey: null,
+                    accountNumber: accountNumber.toNumber(),
+                    sequence: sequence.toNumber(),
+                };
+            }
+        }
+        catch (error) {
+            if (!this.isAccountNotFoundError(error, queryAddress))
+                throw error;
+        }
+        // when grant is just created, querying grantee account info immediately may fail maybe due to backend caching
+        // retry query after 1s to buffer for backend to catch up
+        if (retryCount < 1) {
+            await this.delay(1000);
+            return this.getAccount(queryAddress, retryCount + 1);
+        }
+        return undefined;
+    }
+    async reloadAccountSequence() {
+        if (this.sequenceInvalidated)
+            this.sequenceInvalidated = false;
+        const info = await this.reloadAccountInfo();
+        const pubkey = this.accountInfo?.pubkey ?? {
+            type: "tendermint/PubKeySecp256k1",
+            value: this.publicKey.toString("base64"),
+        };
+        const chainId = this.accountInfo?.chainId ?? this.chainId ?? (await this.getQueryClient().chain.getChainId());
+        if (info) {
+            this.accountInfo = {
+                ...info,
+                pubkey,
+                chainId,
+            };
+        }
+    }
+    async reloadMergeAccountStatus() {
+        if (this.accountMerged)
+            return;
+        const queryClient = this.getQueryClient();
+        const response = await queryClient.evmmerge.MappedAddress({ address: this.bech32Address });
+        this.accountMerged = !!response?.mappedAddress;
+        this.sequenceInvalidated = true;
+    }
+    updateMergeAccountStatus() {
+        this.accountMerged = true;
+        // invalidate sequence after merging
+        this.sequenceInvalidated = true;
+    }
+    isEvmWallet() {
+        return this.providerAgent === walletProvider_1.ProviderAgent.MetamaskExtension || this.isRainbowKit;
+    }
+    isViewOnlyWallet() {
+        return this.signer.type === CarbonSigner_1.CarbonSignerTypes.PublicKey;
+    }
+    estimateTxFee(messages, feeDenom = constant_1.DEFAULT_FEE_DENOM) {
+        const denomGasPrice = this.gasFee?.getGasPrice(feeDenom);
+        const totalGasCost = this.getTotalGasCost(messages);
+        let totalFees = totalGasCost.times(denomGasPrice ?? number_1.BN_ZERO);
+        // override zero gas cost tx with some gas for tx execution
+        // set overall fee to zero, implying 0 gas price.
+        if (totalGasCost.isZero()) {
+            totalFees = number_1.BN_ZERO;
+        }
+        return {
+            amount: [
+                {
+                    amount: totalFees.toString(10),
+                    denom: feeDenom,
+                },
+            ],
+            gas: constant_1.DEFAULT_GAS.toString(10),
+        };
+    }
+    getTotalGasCost(messages) {
+        let totalGasCost = number_1.BN_ZERO;
+        for (const message of messages) {
+            const gasCost = this.gasFee?.getGasCost(message.typeUrl);
+            const additionalGasCost = this.addAdditionalGasCost(message);
+            totalGasCost = totalGasCost.plus(gasCost ?? number_1.BN_ZERO).plus(additionalGasCost);
+        }
+        return totalGasCost;
+    }
+    addAdditionalGasCost(message) {
+        switch (message.typeUrl) {
+            case codec_1.TxTypes.MsgExec: return this.getExecGasCost(message.value);
+        }
+        return number_1.BN_ZERO;
+    }
+    getExecGasCost(message) {
+        const msgs = message.msgs;
+        const encodedMsgs = msgs.map(m => {
+            const decoded = codec_1.registry.decode(m);
+            return {
+                typeUrl: m.typeUrl,
+                value: decoded,
+            };
+        });
+        return this.getTotalGasCost(encodedMsgs);
+    }
+    getQueryClient() {
+        if (!this.query)
+            throw new Error("wallet not initialized");
+        return this.query;
+    }
+}
+exports.CarbonWallet = CarbonWallet;
+(function (CarbonWallet) {
+    CarbonWallet.TxRaw = { ...tx_2.TxRaw };
+})(CarbonWallet || (exports.CarbonWallet = CarbonWallet = {}));