@mememax/sdk-core 0.0.1

package/dist/OrbixSDK.js

@@ -0,0 +1,506 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedOrbixSDK = exports.Orbix = exports.OrbixWallet = exports.OrbixSignerTypes = exports.OrbixTx = void 0;
+const constant_1 = require("./constant");
+const util_1 = require("./util");
+const tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+const grpc_web_node_http_transport_1 = require("@improbable-eng/grpc-web-node-http-transport");
+const clients = __importStar(require("./clients"));
+const clients_1 = require("./clients");
+const GasFee_1 = __importDefault(require("./clients/GasFee"));
+const GrpcQueryClient_1 = __importDefault(require("./clients/GrpcQueryClient"));
+const modules_1 = require("./modules");
+const grant_1 = require("./modules/grant");
+const staking_1 = require("./modules/staking");
+const provider_1 = require("./provider");
+const MetaMask_1 = require("./provider/metamask/MetaMask");
+const RainbowKitAccount_1 = __importDefault(require("./provider/rainbowKit/RainbowKitAccount"));
+const number_1 = require("./util/number");
+const wallet_1 = require("./wallet");
+const auth_1 = require("./util/auth");
+var util_2 = require("./util");
+Object.defineProperty(exports, "OrbixTx", { enumerable: true, get: function () { return util_2.OrbixTx; } });
+var wallet_2 = require("./wallet");
+Object.defineProperty(exports, "OrbixSignerTypes", { enumerable: true, get: function () { return wallet_2.OrbixSignerTypes; } });
+Object.defineProperty(exports, "OrbixWallet", { enumerable: true, get: function () { return wallet_2.OrbixWallet; } });
+exports.Orbix = __importStar(require("./codec/orbix-models"));
+const DEFAULT_SDK_INIT_OPTS = {
+    network: constant_1.DEFAULT_NETWORK,
+};
+/**
+ * Orbix SDK
+ *
+ *
+ */
+class OrbixSDK {
+    constructor(opts) {
+        this.initialized = false;
+        this.network = opts.network ?? constant_1.DEFAULT_NETWORK;
+        this.configOverride = opts.config ?? {};
+        this.networkConfig = util_1.GenericUtils.overrideConfig(constant_1.NetworkConfigs[this.network], this.configOverride);
+        this.useTmAbciQuery = opts.useTmAbciQuery ?? false;
+        this.gasFee = opts.gasFee;
+        this.tmClient = opts.tmClient;
+        this.wallet = opts.wallet;
+        this.chainId = opts.chainId ?? constant_1.OrbixChainIDs[this.network] ?? constant_1.OrbixChainIDs[constant_1.Network.MainNet];
+        this.evmChainId = opts.evmChainId ?? constant_1.OrbixEvmChainIDs[this.network] ?? constant_1.OrbixEvmChainIDs[constant_1.Network.MainNet];
+        let orbixQueryClient;
+        if (!opts.query) {
+            let grpcClient;
+            if (opts.useTmAbciQuery !== true && this.networkConfig.grpcUrl) {
+                const transport = typeof window === "undefined" ? (0, grpc_web_node_http_transport_1.NodeHttpTransport)() : undefined;
+                grpcClient =
+                    opts.grpcQueryClient ??
+                        new GrpcQueryClient_1.default(this.networkConfig.restUrl, {
+                            transport,
+                        });
+            }
+            orbixQueryClient = new clients_1.OrbixQueryClient({
+                tmClient: this.tmClient,
+                grpcClient,
+            });
+        }
+        this.query = (opts.query ?? orbixQueryClient);
+        this.insights = opts.insights ?? new clients_1.InsightsQueryClient(this.networkConfig);
+        this.token = opts.token ?? clients_1.TokenClient.instance(this.query, this);
+        this.hydrogen = opts.hydrogen ?? new clients_1.HydrogenClient(this.networkConfig, this.token);
+        this.admin = new modules_1.AdminModule(this);
+        this.alliance = new modules_1.AllianceModule(this);
+        this.order = new modules_1.OrderModule(this);
+        this.perpspool = new modules_1.PerpspoolModule(this);
+        this.grant = new grant_1.GrantModule(this);
+        this.subaccount = new modules_1.SubAccountModule(this);
+        this.leverage = new modules_1.LeverageModule(this);
+        this.market = new modules_1.MarketModule(this);
+        this.broker = new modules_1.BrokerModule(this);
+        this.position = new modules_1.PositionModule(this);
+        this.coin = new modules_1.CoinModule(this);
+        this.oracle = new modules_1.OracleModule(this);
+        this.gov = new modules_1.GovModule(this);
+        this.staking = new staking_1.StakingModule(this);
+        this.bank = new modules_1.BankModule(this);
+        this.fee = new modules_1.FeeModule(this);
+        this.ibc = new modules_1.IBCModule(this);
+        this.evm = new modules_1.EvmModule(this);
+        this.evmmerge = new modules_1.EvmMergeModule(this);
+        this.bridge = new modules_1.BridgeModule(this);
+    }
+    static async instance(opts = DEFAULT_SDK_INIT_OPTS) {
+        const network = opts.network ?? constant_1.DEFAULT_NETWORK;
+        const configOverride = opts.config ?? {};
+        const defaultTimeoutBlocks = opts.defaultTimeoutBlocks;
+        const networkConfig = util_1.GenericUtils.overrideConfig(constant_1.NetworkConfigs[network], configOverride);
+        const tmClient = opts.tmClient ?? new tendermint_rpc_1.Tendermint37Client(new clients.BatchQueryClient(networkConfig.tmRpcUrl)); // fallback tmClient
+        let chainId = networkConfig.chainId; // fallback chain ID
+        let normalInit = true;
+        try {
+            chainId = (await tmClient.status())?.nodeInfo.network;
+        }
+        catch (error) {
+            console.warn("tm client init failed");
+            console.error(error);
+            normalInit = false;
+        }
+        const sdk = new OrbixSDK({
+            network,
+            config: configOverride,
+            tmClient,
+            defaultTimeoutBlocks,
+            chainId,
+            evmChainId: configOverride.evmChainId, // 🔧 Pass evmChainId from config
+            useTmAbciQuery: opts.useTmAbciQuery,
+        });
+        if (!normalInit)
+            return sdk;
+        if (opts.wallet) {
+            await sdk.connect(opts.wallet);
+        }
+        if (opts.skipInit !== true) {
+            await sdk.initialize();
+        }
+        return sdk;
+    }
+    static async instanceWithWallet(wallet, sdkOpts = DEFAULT_SDK_INIT_OPTS) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connect(wallet);
+    }
+    static async instanceWithPrivateKey(privateKey, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithPrivateKey(privateKey, walletOpts);
+    }
+    static async instanceWithMnemonic(mnemonic, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithMnemonic(mnemonic, walletOpts);
+    }
+    static async instanceWithSigner(signer, publicKeyBase64, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithSigner(signer, publicKeyBase64, walletOpts);
+    }
+    static async instanceWithLedger(ledger, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithLedger(ledger, walletOpts);
+    }
+    static async instanceWithKeplr(keplr, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithKeplr(keplr, walletOpts);
+    }
+    static async instanceWithLeap(leap, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithLeap(leap, walletOpts);
+    }
+    static async instanceWithMetamask(metamask, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithMetamask(metamask, walletOpts);
+    }
+    static async instanceWithRainbowKit(rainbowKit, sdkOpts = DEFAULT_SDK_INIT_OPTS, rainbowKitWalletOpts, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectWithRainbowKit(rainbowKit, rainbowKitWalletOpts, walletOpts);
+    }
+    static async instanceViewOnly(bech32Address, sdkOpts = DEFAULT_SDK_INIT_OPTS, walletOpts) {
+        const sdk = await OrbixSDK.instance(sdkOpts);
+        return sdk.connectViewOnly(bech32Address, walletOpts);
+    }
+    async initialize() {
+        const fees = await this.getGasFee();
+        const chainId = await this.query.chain.getChainId();
+        this.chainId = chainId;
+        this.gasFee = fees;
+        await this.token.initialize();
+        if (this.wallet) {
+            await this.wallet.initialize(this.query, fees);
+        }
+        this.initialized = true;
+        return this;
+    }
+    async getGasFee() {
+        if (this.gasFee)
+            return this.gasFee;
+        const queryClient = this.query;
+        const { msgGasCosts } = await queryClient.fee.MsgGasCostAll({
+            pagination: constant_1.PAGINATE_10K,
+        });
+        const txGasCosts = msgGasCosts.reduce((result, item) => {
+            result[item.msgType] = (0, number_1.bnOrZero)(item.gasCost);
+            return result;
+        }, {});
+        const { minGasPrices } = await queryClient.fee.MinGasPriceAll({
+            pagination: constant_1.PAGINATE_10K,
+        });
+        const txGasPrices = minGasPrices.reduce((result, item) => {
+            result[item.denom] = (0, number_1.bnOrZero)(item.gasPrice).shiftedBy(-18); // sdk.Dec shifting
+            return result;
+        }, {});
+        return new GasFee_1.default(txGasCosts, txGasPrices);
+    }
+    clone() {
+        return new OrbixSDK(this.generateOpts());
+    }
+    generateOpts() {
+        return {
+            network: this.network,
+            config: this.configOverride,
+            chainId: this.chainId,
+            evmChainId: this.evmChainId,
+            useTmAbciQuery: this.useTmAbciQuery,
+            gasFee: this.gasFee,
+            wallet: this.wallet,
+            tmClient: this.tmClient,
+            token: this.token,
+            query: this.query,
+            hydrogen: this.hydrogen,
+            insights: this.insights,
+        };
+    }
+    async connect(wallet, opts) {
+        if (!wallet.initialized) {
+            try {
+                // Perform initialize function as per normal, but add try-catch statement to check err message
+                const overrideConfig = {
+                    chainId: this.chainId,
+                    evmChainId: this.evmChainId,
+                };
+                const gasFee = await this.getGasFee();
+                await wallet.initialize(this.query, gasFee, overrideConfig, opts);
+            }
+            catch (err) {
+                const errorTyped = err;
+                // In the case where account does not exist on chain, still allow wallet connection.
+                // Else, throw an error as per normal
+                if (!errorTyped.message.includes("Account does not exist on chain. Send some tokens there before trying to query sequence.")) {
+                    throw new Error(errorTyped.message);
+                }
+            }
+        }
+        this.wallet = wallet;
+        return this;
+    }
+    disconnect() {
+        if (this.wallet?.isSigner(wallet_1.OrbixSignerTypes.Ledger)) {
+            this.wallet.signer.ledger.disconnect();
+        }
+        const opts = this.generateOpts();
+        delete opts.wallet;
+        return new OrbixSDK(opts);
+    }
+    async connectWithPrivateKey(privateKey, opts) {
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "privateKey",
+            privateKey,
+            network: this.network,
+            config: this.configOverride,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithMnemonic(mnemonic, opts) {
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "mnemonic",
+            mnemonic,
+            network: this.network,
+            config: this.configOverride,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithSigner(signer, publicKeyBase64, opts) {
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "customSigner",
+            signer,
+            publicKeyBase64,
+            network: this.network,
+            config: this.configOverride,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithLedger(ledger, opts) {
+        const publicKeyBuffer = await ledger.getPubKey();
+        const publicKeyBase64 = publicKeyBuffer.toString("base64");
+        const signer = new wallet_1.OrbixLedgerSigner(ledger);
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "customSigner",
+            signer,
+            publicKeyBase64,
+            network: this.network,
+            config: this.configOverride,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithKeplr(keplr, opts) {
+        const chainInfo = await provider_1.KeplrAccount.getChainInfo(this);
+        const chainId = chainInfo.chainId;
+        await keplr.experimentalSuggestChain(chainInfo);
+        const keplrKey = await keplr.getKey(chainId);
+        await keplr.enable(chainId);
+        const signer = keplrKey.isNanoLedger
+            ? provider_1.KeplrAccount.createKeplrSignerAmino(keplr, chainInfo, keplrKey)
+            : provider_1.KeplrAccount.createKeplrSigner(keplr, chainInfo, keplrKey);
+        const publicKeyBase64 = Buffer.from(keplrKey.pubKey).toString("base64");
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "customSigner",
+            signer,
+            publicKeyBase64,
+            network: this.network,
+            config: this.configOverride,
+            providerAgent: constant_1.ProviderAgent.KeplrExtension,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithLeap(leap, opts) {
+        const chainId = this.chainId;
+        const chainInfo = await provider_1.LeapAccount.getChainInfo(this);
+        await leap.experimentalSuggestChain(chainInfo);
+        const leapKey = await leap.getKey(chainId);
+        await leap.enable(chainId);
+        const signer = leapKey.isNanoLedger ? provider_1.LeapAccount.createLeapSignerAmino(leap, chainId) : provider_1.LeapAccount.createLeapSigner(leap, chainId);
+        const publicKeyBase64 = Buffer.from(leapKey.pubKey).toString("base64");
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "customSigner",
+            signer,
+            publicKeyBase64,
+            network: this.network,
+            config: this.configOverride,
+            providerAgent: constant_1.ProviderAgent.LeapExtension,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithMetamask(metamask, opts, evmWalletOpts) {
+        const evmChainId = this.evmChainId;
+        const addressOptions = {
+            network: this.networkConfig.network,
+            bech32Prefix: this.networkConfig.Bech32Prefix,
+        };
+        const noJwtProvided = opts?.enableJwtAuth && !opts?.jwt;
+        const signMessageRequired = !evmWalletOpts?.publicKeyBase64 || noJwtProvided;
+        let pubKey = evmWalletOpts?.publicKeyBase64;
+        let message;
+        let signature;
+        if (signMessageRequired) {
+            const result = await MetaMask_1.MetaMask.signAndRecoverPubKey(metamask, opts?.enableJwtAuth, opts?.authMessage);
+            pubKey = result.publicKey;
+            message = result.message;
+            signature = result.signature;
+        }
+        const signer = MetaMask_1.MetaMask.createMetamaskSigner(metamask, evmChainId, pubKey, addressOptions);
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "customSigner",
+            signer,
+            publicKeyBase64: pubKey,
+            network: this.network,
+            config: this.configOverride,
+            providerAgent: constant_1.ProviderAgent.MetamaskExtension,
+        });
+        if (noJwtProvided) {
+            const authRequest = {
+                grant_type: auth_1.GrantType.SignatureEth,
+                message: message,
+                public_key: Buffer.from(pubKey, "base64").toString("hex"),
+                signature: signature,
+            };
+            await wallet.reloadJwtToken(authRequest, opts?.authMessage);
+        }
+        return this.connect(wallet, opts);
+    }
+    async connectWithRainbowKit(rainbowKit, rainbowKitWalletOpts, opts) {
+        const evmChainId = this.evmChainId;
+        const addressOptions = {
+            network: this.networkConfig.network,
+            bech32Prefix: this.networkConfig.Bech32Prefix,
+        };
+        const noJwtProvided = opts?.enableJwtAuth && !opts?.jwt;
+        const signMessageRequired = !rainbowKitWalletOpts?.publicKeyBase64 || noJwtProvided;
+        let pubKey = rainbowKitWalletOpts?.publicKeyBase64;
+        let message;
+        let signature;
+        if (signMessageRequired) {
+            const result = await RainbowKitAccount_1.default.signAndRecoverPubKey(rainbowKit, opts?.enableJwtAuth, opts?.authMessage);
+            pubKey = result.publicKey;
+            message = result.message;
+            signature = result.signature;
+        }
+        const signer = RainbowKitAccount_1.default.createRainbowKitSigner(rainbowKit, evmChainId, pubKey, addressOptions);
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "customSigner",
+            signer,
+            publicKeyBase64: pubKey,
+            network: this.network,
+            config: this.configOverride,
+            providerAgent: rainbowKitWalletOpts.walletProvider,
+            isRainbowKit: true,
+        });
+        if (noJwtProvided) {
+            const authRequest = {
+                grant_type: auth_1.GrantType.SignatureEth,
+                message: message,
+                public_key: Buffer.from(pubKey, "base64").toString("hex"),
+                signature: signature,
+            };
+            await wallet.reloadJwtToken(authRequest, opts?.authMessage);
+        }
+        return this.connect(wallet, opts);
+    }
+    async connectViewOnly(bech32Address, opts) {
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "viewOnly",
+            bech32Address,
+            network: this.network,
+            config: this.configOverride,
+        });
+        return this.connect(wallet, opts);
+    }
+    async connectWithQr(granteeMnemonic, granterAddress, expiry, opts) {
+        const wallet = new wallet_1.OrbixWallet({
+            ...opts,
+            mode: "qr",
+            mnemonic: granteeMnemonic,
+            granter: granterAddress,
+            bech32Address: granterAddress,
+            expiry,
+            network: this.network,
+            config: this.configOverride,
+        });
+        return this.connect(wallet, opts);
+    }
+    getConfig() {
+        return this.networkConfig;
+    }
+    getTokenClient() {
+        return this.token;
+    }
+    getConnectedWallet() {
+        return this.checkWallet();
+    }
+    log(...args) {
+        console.log.apply(console.log, [this.constructor.name, ...args]);
+    }
+    checkWallet() {
+        if (!this.wallet) {
+            throw new Error("wallet not connected");
+        }
+        return this.wallet;
+    }
+}
+OrbixSDK.DEFAULT_NETWORK = constant_1.DEFAULT_NETWORK;
+OrbixSDK.DenomPrefix = constant_1.DenomPrefix;
+OrbixSDK.parseNetwork = util_1.NetworkUtils.parseNetwork;
+class ConnectedOrbixSDK extends OrbixSDK {
+    constructor(wallet, opts) {
+        super(opts);
+        this.wallet = wallet;
+    }
+    clone() {
+        return new ConnectedOrbixSDK(this.wallet, this.generateOpts());
+    }
+}
+exports.ConnectedOrbixSDK = ConnectedOrbixSDK;
+(function (OrbixSDK) {
+    OrbixSDK.Network = constant_1.Network;
+    OrbixSDK.OrbixQueryClient = clients.OrbixQueryClient;
+    OrbixSDK.ETHClient = clients.ETHClient;
+    OrbixSDK.HydrogenClient = clients.HydrogenClient;
+    OrbixSDK.InsightsQueryClient = clients.InsightsQueryClient;
+    OrbixSDK.TokenClient = clients.TokenClient;
+})(OrbixSDK || (OrbixSDK = {}));
+exports.default = OrbixSDK;

package/dist/clients/BatchQueryClient.d.ts

@@ -0,0 +1,26 @@
+import { JsonRpcRequest, JsonRpcSuccessResponse } from "@cosmjs/json-rpc";
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc/build/rpcclients/httpclient";
+import { RpcClient } from "@cosmjs/tendermint-rpc/build/rpcclients/rpcclient";
+export interface BatchQueryClientOptions {
+    /** Interval for dispatching batches (in milliseconds) */
+    dispatchInterval: number;
+    /** Max number of items sent in one request */
+    batchSizeLimit: number;
+}
+declare class BatchQueryClient implements RpcClient {
+    protected readonly url: string;
+    protected readonly headers: Record<string, string> | undefined;
+    protected readonly options: BatchQueryClientOptions;
+    private timer?;
+    private readonly queue;
+    constructor(endpoint: string | HttpEndpoint, options?: Partial<BatchQueryClientOptions>);
+    disconnect(): void;
+    execute(request: JsonRpcRequest): Promise<JsonRpcSuccessResponse>;
+    private validate;
+    /**
+     * This is called in an interval where promise rejections cannot be handled.
+     * So this is not async and HTTP errors need to be handled by the queued promises.
+     */
+    private tick;
+}
+export default BatchQueryClient;

package/dist/clients/BatchQueryClient.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_rpc_1 = require("@cosmjs/json-rpc");
+const http_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/http");
+const rpcclient_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/rpcclient");
+// Those values are private and can change any time.
+// Does a user need to know them? I don't think so. You either set
+// a custom value or leave the option field unset.
+const defaultBatchQueryClientOptions = {
+    dispatchInterval: 20,
+    batchSizeLimit: 20,
+};
+class BatchQueryClient {
+    constructor(endpoint, options = {}) {
+        this.queue = [];
+        this.options = {
+            batchSizeLimit: options.batchSizeLimit ?? defaultBatchQueryClientOptions.batchSizeLimit,
+            dispatchInterval: options.dispatchInterval ?? defaultBatchQueryClientOptions.dispatchInterval,
+        };
+        if (typeof endpoint === "string") {
+            // accept host.name:port and assume http protocol
+            this.url = (0, rpcclient_1.hasProtocol)(endpoint) ? endpoint : "http://" + endpoint;
+        }
+        else {
+            this.url = endpoint.url;
+            this.headers = endpoint.headers;
+        }
+        this.timer = (setInterval(() => this.tick(), options.dispatchInterval));
+        this.validate();
+    }
+    disconnect() {
+        this.timer && clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    async execute(request) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ request, resolve, reject });
+            if (this.queue.length >= this.options.batchSizeLimit) {
+                // this train is full, let's go
+                this.tick();
+            }
+        });
+    }
+    validate() {
+        if (!this.options.batchSizeLimit ||
+            !Number.isSafeInteger(this.options.batchSizeLimit) ||
+            this.options.batchSizeLimit < 1) {
+            throw new Error("batchSizeLimit must be a safe integer >= 1");
+        }
+    }
+    /**
+     * This is called in an interval where promise rejections cannot be handled.
+     * So this is not async and HTTP errors need to be handled by the queued promises.
+     */
+    tick() {
+        // Avoid race conditions
+        const batch = this.queue.splice(0, this.options.batchSizeLimit);
+        if (!batch.length)
+            return;
+        const requests = batch.map((s) => s.request);
+        const requestIds = requests.map((request) => request.id);
+        (0, http_1.http)("POST", this.url, this.headers, requests).then((raw) => {
+            // Requests with a single entry return as an object
+            const arr = Array.isArray(raw) ? raw : [raw];
+            arr.forEach((el, i) => {
+                const req = batch[i];
+                if (!req)
+                    return;
+                const { reject, resolve } = req;
+                const response = (0, json_rpc_1.parseJsonRpcResponse)(el);
+                if ((0, json_rpc_1.isJsonRpcErrorResponse)(response)) {
+                    reject(new Error(JSON.stringify(response.error)));
+                }
+                else {
+                    resolve(response);
+                }
+            });
+        }, (error) => {
+            for (const requestId of requestIds) {
+                const req = batch.find((s) => s.request.id === requestId);
+                if (!req)
+                    return;
+                req.reject(error);
+            }
+        });
+    }
+}
+exports.default = BatchQueryClient;

package/dist/clients/BlockchainClient.d.ts

@@ -0,0 +1,16 @@
+import { StargateClient } from "@cosmjs/stargate";
+import { Tendermint37Client } from "@cosmjs/tendermint-rpc";
+/**
+ * BlockchainClient is functionally the same with StargateClient,
+ * with an additional static initializer:
+ *
+ * ```
+ * BlockchainClient.connectWithTm(tmClient: Tendermint37Client)
+ * ```
+ *
+ * @see StargateClient
+ */
+declare class BlockchainClient extends StargateClient {
+    static connectWithTm(tmClient: Tendermint37Client): BlockchainClient;
+}
+export default BlockchainClient;

package/dist/clients/BlockchainClient.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stargate_1 = require("@cosmjs/stargate");
+/**
+ * BlockchainClient is functionally the same with StargateClient,
+ * with an additional static initializer:
+ *
+ * ```
+ * BlockchainClient.connectWithTm(tmClient: Tendermint37Client)
+ * ```
+ *
+ * @see StargateClient
+ */
+class BlockchainClient extends stargate_1.StargateClient {
+    static connectWithTm(tmClient) {
+        return new BlockchainClient(tmClient, {});
+    }
+}
+exports.default = BlockchainClient;