carbon-js-sdk 0.3.9 → 0.3.11

package/lib/clients/CarbonTendermintClient.d.ts

@@ -0,0 +1,117 @@
+import { Stream } from "xstream";
+import { JsonRpcSuccessResponse } from "@cosmjs/json-rpc/build/types";
+import * as requests from "@cosmjs/tendermint-rpc/build/tendermint34/requests";
+import * as responses from "@cosmjs/tendermint-rpc/build/tendermint34/responses";
+export interface SubscriptionEvent {
+    readonly query: string;
+    readonly data: {
+        readonly type: string;
+        readonly value: any;
+    };
+}
+export declare type JsonRpcId = number | string;
+export interface JsonRpcRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: JsonRpcId;
+    readonly method: string;
+    readonly params: JsonCompatibleArray | JsonCompatibleDictionary;
+}
+export interface JsonCompatibleArray extends ReadonlyArray<JsonCompatibleValue> {
+}
+export interface JsonCompatibleDictionary {
+    readonly [key: string]: JsonCompatibleValue | readonly JsonCompatibleValue[];
+}
+export declare type JsonCompatibleValue = JsonCompatibleDictionary | JsonCompatibleArray | string | number | boolean | null;
+export interface RpcClient {
+    readonly execute: (request: JsonRpcRequest) => Promise<JsonRpcSuccessResponse>;
+    readonly disconnect: () => void;
+}
+export declare function instanceOfRpcStreamingClient(client: RpcClient): client is RpcStreamingClient;
+export interface RpcStreamingClient extends RpcClient {
+    readonly listen: (request: JsonRpcRequest) => Stream<SubscriptionEvent>;
+}
+export default class CarbonTendermintClient {
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint: string): Promise<CarbonTendermintClient>;
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient: RpcClient): Promise<CarbonTendermintClient>;
+    private static detectVersion;
+    private readonly client;
+    private readonly p;
+    private readonly r;
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    private constructor();
+    disconnect(): void;
+    abciInfo(): Promise<responses.AbciInfoResponse>;
+    abciQuery(params: requests.AbciQueryParams): Promise<responses.AbciQueryResponse>;
+    block(height?: number): Promise<responses.BlockResponse>;
+    blockResults(height?: number): Promise<responses.BlockResultsResponse>;
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params: requests.BlockSearchParams): Promise<responses.BlockSearchResponse>;
+    blockSearchAll(params: requests.BlockSearchParams): Promise<responses.BlockSearchResponse>;
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight?: number, maxHeight?: number): Promise<responses.BlockchainResponse>;
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxSyncResponse>;
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxAsyncResponse>;
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxCommitResponse>;
+    commit(height?: number): Promise<responses.CommitResponse>;
+    genesis(): Promise<responses.GenesisResponse>;
+    health(): Promise<responses.HealthResponse>;
+    numUnconfirmedTxs(): Promise<responses.NumUnconfirmedTxsResponse>;
+    status(): Promise<responses.StatusResponse>;
+    subscribeNewBlock(): Stream<responses.NewBlockEvent>;
+    subscribeNewBlockHeader(): Stream<responses.NewBlockHeaderEvent>;
+    subscribeTx(query?: string): Stream<responses.TxEvent>;
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params: requests.TxParams): Promise<responses.TxResponse>;
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params: requests.TxSearchParams): Promise<responses.TxSearchResponse>;
+    txSearchAll(params: requests.TxSearchParams): Promise<responses.TxSearchResponse>;
+    validators(params: requests.ValidatorsParams): Promise<responses.ValidatorsResponse>;
+    validatorsAll(height?: number): Promise<responses.ValidatorsResponse>;
+    private doCall;
+    private subscribe;
+}

package/lib/clients/CarbonTendermintClient.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfRpcStreamingClient = void 0;
+const jsonrpc_1 = require("@cosmjs/tendermint-rpc/build/jsonrpc");
+const httpclient_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/httpclient");
+const adaptor_1 = require("@cosmjs/tendermint-rpc/build/tendermint34/adaptor");
+const requests = __importStar(require("@cosmjs/tendermint-rpc/build/tendermint34/requests"));
+function instanceOfRpcStreamingClient(client) {
+    return typeof client.listen === "function";
+}
+exports.instanceOfRpcStreamingClient = instanceOfRpcStreamingClient;
+class CarbonTendermintClient {
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    constructor(client) {
+        this.client = client;
+        this.p = adaptor_1.adaptor34.params;
+        this.r = adaptor_1.adaptor34.responses;
+    }
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const useHttp = endpoint.startsWith("http://") || endpoint.startsWith("https://");
+            if (!useHttp) {
+                throw new Error('this client only uses httpClient.');
+            }
+            const rpcClient = new httpclient_1.HttpClient(endpoint);
+            return CarbonTendermintClient.create(rpcClient);
+        });
+    }
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // For some very strange reason I don't understand, tests start to fail on some systems
+            // (our CI) when skipping the status call before doing other queries. Sleeping a little
+            // while did not help. Thus we query the version as a way to say "hi" to the backend,
+            // even in cases where we don't use the result.
+            const _version = yield this.detectVersion(rpcClient);
+            return new CarbonTendermintClient(rpcClient);
+        });
+    }
+    static detectVersion(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = (0, jsonrpc_1.createJsonRpcRequest)(requests.Method.Status);
+            const response = yield client.execute(req);
+            const result = response.result;
+            if (!result || !result.node_info) {
+                throw new Error("Unrecognized format for status response");
+            }
+            const version = result.node_info.version;
+            if (typeof version !== "string") {
+                throw new Error("Unrecognized version format: must be string");
+            }
+            return version;
+        });
+    }
+    disconnect() {
+        this.client.disconnect();
+    }
+    abciInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.AbciInfo };
+            return this.doCall(query, this.p.encodeAbciInfo, this.r.decodeAbciInfo);
+        });
+    }
+    abciQuery(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.AbciQuery };
+            return this.doCall(query, this.p.encodeAbciQuery, this.r.decodeAbciQuery);
+        });
+    }
+    block(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Block, params: { height: height } };
+            return this.doCall(query, this.p.encodeBlock, this.r.decodeBlock);
+        });
+    }
+    blockResults(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.BlockResults,
+                params: { height: height },
+            };
+            return this.doCall(query, this.p.encodeBlockResults, this.r.decodeBlockResults);
+        });
+    }
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BlockSearch };
+            const resp = yield this.doCall(query, this.p.encodeBlockSearch, this.r.decodeBlockSearch);
+            return Object.assign(Object.assign({}, resp), { 
+                // make sure we sort by height, as tendermint may be sorting by string value of the height
+                blocks: [...resp.blocks].sort((a, b) => a.block.header.height - b.block.header.height) });
+        });
+    }
+    // this should paginate through all blockSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    //
+    // NOTE
+    // This method will error on any node that is running a Tendermint version lower than 0.34.9.
+    blockSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const blocks = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.blockSearch(Object.assign(Object.assign({}, params), { page: page }));
+                blocks.push(...resp.blocks);
+                if (blocks.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            // make sure we sort by height, as tendermint may be sorting by string value of the height
+            // and the earlier items may be in a higher page than the later items
+            blocks.sort((a, b) => a.block.header.height - b.block.header.height);
+            return {
+                totalCount: blocks.length,
+                blocks: blocks,
+            };
+        });
+    }
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight, maxHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Blockchain,
+                params: {
+                    minHeight: minHeight,
+                    maxHeight: maxHeight,
+                },
+            };
+            return this.doCall(query, this.p.encodeBlockchain, this.r.decodeBlockchain);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxSync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxSync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxAsync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxAsync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxCommit };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxCommit);
+        });
+    }
+    commit(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Commit, params: { height: height } };
+            return this.doCall(query, this.p.encodeCommit, this.r.decodeCommit);
+        });
+    }
+    genesis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Genesis };
+            return this.doCall(query, this.p.encodeGenesis, this.r.decodeGenesis);
+        });
+    }
+    health() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Health };
+            return this.doCall(query, this.p.encodeHealth, this.r.decodeHealth);
+        });
+    }
+    numUnconfirmedTxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.NumUnconfirmedTxs };
+            return this.doCall(query, this.p.encodeNumUnconfirmedTxs, this.r.decodeNumUnconfirmedTxs);
+        });
+    }
+    status() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Status };
+            return this.doCall(query, this.p.encodeStatus, this.r.decodeStatus);
+        });
+    }
+    subscribeNewBlock() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlock },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockEvent);
+    }
+    subscribeNewBlockHeader() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlockHeader },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockHeaderEvent);
+    }
+    subscribeTx(query) {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: {
+                type: requests.SubscriptionEventType.Tx,
+                raw: query,
+            },
+        };
+        return this.subscribe(request, this.r.decodeTxEvent);
+    }
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.Tx };
+            return this.doCall(query, this.p.encodeTx, this.r.decodeTx);
+        });
+    }
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.TxSearch };
+            return this.doCall(query, this.p.encodeTxSearch, this.r.decodeTxSearch);
+        });
+    }
+    // this should paginate through all txSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    txSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const txs = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.txSearch(Object.assign(Object.assign({}, params), { page: page }));
+                txs.push(...resp.txs);
+                if (txs.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                totalCount: txs.length,
+                txs: txs,
+            };
+        });
+    }
+    validators(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Validators,
+                params: params,
+            };
+            return this.doCall(query, this.p.encodeValidators, this.r.decodeValidators);
+        });
+    }
+    validatorsAll(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validators = [];
+            let page = 1;
+            let done = false;
+            let blockHeight = height;
+            while (!done) {
+                const response = yield this.validators({
+                    per_page: 50,
+                    height: blockHeight,
+                    page: page,
+                });
+                validators.push(...response.validators);
+                blockHeight = blockHeight || response.blockHeight;
+                if (validators.length < response.total) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                // NOTE: Default value is for type safety but this should always be set
+                blockHeight: blockHeight !== null && blockHeight !== void 0 ? blockHeight : 0,
+                count: validators.length,
+                total: validators.length,
+                validators: validators,
+            };
+        });
+    }
+    // doCall is a helper to handle the encode/call/decode logic
+    doCall(request, encode, decode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = encode(request);
+            const result = yield this.client.execute(req);
+            return decode(result);
+        });
+    }
+    subscribe(request, decode) {
+        if (!instanceOfRpcStreamingClient(this.client)) {
+            throw new Error("This RPC client type cannot subscribe to events");
+        }
+        const req = this.p.encodeSubscribe(request);
+        const eventStream = this.client.listen(req);
+        return eventStream.map((event) => {
+            return decode(event);
+        });
+    }
+}
+exports.default = CarbonTendermintClient;

package/lib/constant/ibc.js

@@ -101,6 +101,7 @@ exports.ibcWhitelist = [
     ChainIds.Evmos,
     ChainIds.Axelar,
     ChainIds.Stride,
+    ChainIds.Kujira,
 ];
 exports.EmbedChainInfosInit = {
     [ChainIds.Osmosis]: {
@@ -1728,7 +1729,7 @@ exports.swthChannels = {
 };
 exports.ibcTokenRegex = /^ibc\/([a-f\d]+)$/i;
 exports.ibcNetworkRegex = /^([a-z\d_-]+)-([\d]+)$/i;
-exports.ibcDefaultGas = 150000;
+exports.ibcDefaultGas = 200000;
 exports.DefaultGasPriceStep = {
     low: 0.01,
     average: 0.025,

package/lib/util/blockchain.js

@@ -141,7 +141,7 @@ const blockchainForChainId = (chainId) => {
             return Blockchain.Axelar;
         case 313: // mainnet
             return Blockchain.Stride;
-        case 314: //mainnet
+        case 314: // mainnnet
             return Blockchain.Kujira;
         default:
             return undefined;

package/lib/wallet/CarbonTendermintClient.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonTendermintClient = exports.instanceOfRpcStreamingClient = void 0;
+const jsonrpc_1 = require("../jsonrpc");
+const rpcclients_1 = require("../rpcclients");
+const adaptor_1 = require("./adaptor");
+const requests = __importStar(require("./requests"));
+function instanceOfRpcStreamingClient(client) {
+    return typeof client.listen === "function";
+}
+exports.instanceOfRpcStreamingClient = instanceOfRpcStreamingClient;
+class CarbonTendermintClient {
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    constructor(client) {
+        this.client = client;
+        this.p = adaptor_1.adaptor34.params;
+        this.r = adaptor_1.adaptor34.responses;
+    }
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const useHttp = endpoint.startsWith("http://") || endpoint.startsWith("https://");
+            if (!useHttp) {
+                throw new Error('this client only uses httpClient.');
+            }
+            const rpcClient = new rpcclients_1.HttpClient(endpoint);
+            return CarbonTendermintClient.create(rpcClient);
+        });
+    }
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // For some very strange reason I don't understand, tests start to fail on some systems
+            // (our CI) when skipping the status call before doing other queries. Sleeping a little
+            // while did not help. Thus we query the version as a way to say "hi" to the backend,
+            // even in cases where we don't use the result.
+            const _version = yield this.detectVersion(rpcClient);
+            return new CarbonTendermintClient(rpcClient);
+        });
+    }
+    static detectVersion(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = (0, jsonrpc_1.createJsonRpcRequest)(requests.Method.Status);
+            const response = yield client.execute(req);
+            const result = response.result;
+            if (!result || !result.node_info) {
+                throw new Error("Unrecognized format for status response");
+            }
+            const version = result.node_info.version;
+            if (typeof version !== "string") {
+                throw new Error("Unrecognized version format: must be string");
+            }
+            return version;
+        });
+    }
+    disconnect() {
+        this.client.disconnect();
+    }
+    abciInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.AbciInfo };
+            return this.doCall(query, this.p.encodeAbciInfo, this.r.decodeAbciInfo);
+        });
+    }
+    abciQuery(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.AbciQuery };
+            return this.doCall(query, this.p.encodeAbciQuery, this.r.decodeAbciQuery);
+        });
+    }
+    block(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Block, params: { height: height } };
+            return this.doCall(query, this.p.encodeBlock, this.r.decodeBlock);
+        });
+    }
+    blockResults(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.BlockResults,
+                params: { height: height },
+            };
+            return this.doCall(query, this.p.encodeBlockResults, this.r.decodeBlockResults);
+        });
+    }
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BlockSearch };
+            const resp = yield this.doCall(query, this.p.encodeBlockSearch, this.r.decodeBlockSearch);
+            return Object.assign(Object.assign({}, resp), { 
+                // make sure we sort by height, as tendermint may be sorting by string value of the height
+                blocks: [...resp.blocks].sort((a, b) => a.block.header.height - b.block.header.height) });
+        });
+    }
+    // this should paginate through all blockSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    //
+    // NOTE
+    // This method will error on any node that is running a Tendermint version lower than 0.34.9.
+    blockSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const blocks = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.blockSearch(Object.assign(Object.assign({}, params), { page: page }));
+                blocks.push(...resp.blocks);
+                if (blocks.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            // make sure we sort by height, as tendermint may be sorting by string value of the height
+            // and the earlier items may be in a higher page than the later items
+            blocks.sort((a, b) => a.block.header.height - b.block.header.height);
+            return {
+                totalCount: blocks.length,
+                blocks: blocks,
+            };
+        });
+    }
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight, maxHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Blockchain,
+                params: {
+                    minHeight: minHeight,
+                    maxHeight: maxHeight,
+                },
+            };
+            return this.doCall(query, this.p.encodeBlockchain, this.r.decodeBlockchain);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxSync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxSync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxAsync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxAsync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxCommit };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxCommit);
+        });
+    }
+    commit(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Commit, params: { height: height } };
+            return this.doCall(query, this.p.encodeCommit, this.r.decodeCommit);
+        });
+    }
+    genesis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Genesis };
+            return this.doCall(query, this.p.encodeGenesis, this.r.decodeGenesis);
+        });
+    }
+    health() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Health };
+            return this.doCall(query, this.p.encodeHealth, this.r.decodeHealth);
+        });
+    }
+    numUnconfirmedTxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.NumUnconfirmedTxs };
+            return this.doCall(query, this.p.encodeNumUnconfirmedTxs, this.r.decodeNumUnconfirmedTxs);
+        });
+    }
+    status() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Status };
+            return this.doCall(query, this.p.encodeStatus, this.r.decodeStatus);
+        });
+    }
+    subscribeNewBlock() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlock },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockEvent);
+    }
+    subscribeNewBlockHeader() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlockHeader },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockHeaderEvent);
+    }
+    subscribeTx(query) {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: {
+                type: requests.SubscriptionEventType.Tx,
+                raw: query,
+            },
+        };
+        return this.subscribe(request, this.r.decodeTxEvent);
+    }
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.Tx };
+            return this.doCall(query, this.p.encodeTx, this.r.decodeTx);
+        });
+    }
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.TxSearch };
+            return this.doCall(query, this.p.encodeTxSearch, this.r.decodeTxSearch);
+        });
+    }
+    // this should paginate through all txSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    txSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const txs = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.txSearch(Object.assign(Object.assign({}, params), { page: page }));
+                txs.push(...resp.txs);
+                if (txs.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                totalCount: txs.length,
+                txs: txs,
+            };
+        });
+    }
+    validators(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Validators,
+                params: params,
+            };
+            return this.doCall(query, this.p.encodeValidators, this.r.decodeValidators);
+        });
+    }
+    validatorsAll(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validators = [];
+            let page = 1;
+            let done = false;
+            let blockHeight = height;
+            while (!done) {
+                const response = yield this.validators({
+                    per_page: 50,
+                    height: blockHeight,
+                    page: page,
+                });
+                validators.push(...response.validators);
+                blockHeight = blockHeight || response.blockHeight;
+                if (validators.length < response.total) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                // NOTE: Default value is for type safety but this should always be set
+                blockHeight: blockHeight !== null && blockHeight !== void 0 ? blockHeight : 0,
+                count: validators.length,
+                total: validators.length,
+                validators: validators,
+            };
+        });
+    }
+    // doCall is a helper to handle the encode/call/decode logic
+    doCall(request, encode, decode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = encode(request);
+            const result = yield this.client.execute(req);
+            return decode(result);
+        });
+    }
+    subscribe(request, decode) {
+        if (!(0, rpcclients_1.instanceOfRpcStreamingClient)(this.client)) {
+            throw new Error("This RPC client type cannot subscribe to events");
+        }
+        const req = this.p.encodeSubscribe(request);
+        const eventStream = this.client.listen(req);
+        return eventStream.map((event) => {
+            return decode(event);
+        });
+    }
+}
+exports.CarbonTendermintClient = CarbonTendermintClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carbon-js-sdk",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "TypeScript SDK for Carbon blockchain",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/codec/bank/tx.d.ts

@@ -1,64 +0,0 @@
-import Long from "long";
-import _m0 from "protobufjs/minimal";
-export declare const protobufPackage = "Switcheo.carbon.bank";
-export interface MsgEnableSend {
-    creator: string;
-    denom: string;
-}
-export interface MsgEnableSendResponse {
-    denom: string;
-}
-export interface MsgDisableSend {
-    creator: string;
-    denom: string;
-}
-export interface MsgDisableSendResponse {
-    denom: string;
-}
-export declare const MsgEnableSend: {
-    encode(message: MsgEnableSend, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgEnableSend;
-    fromJSON(object: any): MsgEnableSend;
-    toJSON(message: MsgEnableSend): unknown;
-    fromPartial(object: DeepPartial<MsgEnableSend>): MsgEnableSend;
-};
-export declare const MsgEnableSendResponse: {
-    encode(message: MsgEnableSendResponse, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgEnableSendResponse;
-    fromJSON(object: any): MsgEnableSendResponse;
-    toJSON(message: MsgEnableSendResponse): unknown;
-    fromPartial(object: DeepPartial<MsgEnableSendResponse>): MsgEnableSendResponse;
-};
-export declare const MsgDisableSend: {
-    encode(message: MsgDisableSend, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgDisableSend;
-    fromJSON(object: any): MsgDisableSend;
-    toJSON(message: MsgDisableSend): unknown;
-    fromPartial(object: DeepPartial<MsgDisableSend>): MsgDisableSend;
-};
-export declare const MsgDisableSendResponse: {
-    encode(message: MsgDisableSendResponse, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgDisableSendResponse;
-    fromJSON(object: any): MsgDisableSendResponse;
-    toJSON(message: MsgDisableSendResponse): unknown;
-    fromPartial(object: DeepPartial<MsgDisableSendResponse>): MsgDisableSendResponse;
-};
-/** Msg defines the Msg service. */
-export interface Msg {
-    EnableSend(request: MsgEnableSend): Promise<MsgEnableSendResponse>;
-    DisableSend(request: MsgDisableSend): Promise<MsgDisableSendResponse>;
-}
-export declare class MsgClientImpl implements Msg {
-    private readonly rpc;
-    constructor(rpc: Rpc);
-    EnableSend(request: MsgEnableSend): Promise<MsgEnableSendResponse>;
-    DisableSend(request: MsgDisableSend): Promise<MsgDisableSendResponse>;
-}
-interface Rpc {
-    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
-}
-declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : Partial<T>;
-export {};

package/lib/codec/bank/tx.js

@@ -1,236 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsgClientImpl = exports.MsgDisableSendResponse = exports.MsgDisableSend = exports.MsgEnableSendResponse = exports.MsgEnableSend = exports.protobufPackage = void 0;
-/* eslint-disable */
-const long_1 = __importDefault(require("long"));
-const minimal_1 = __importDefault(require("protobufjs/minimal"));
-exports.protobufPackage = "Switcheo.carbon.bank";
-const baseMsgEnableSend = { creator: "", denom: "" };
-exports.MsgEnableSend = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.creator !== "") {
-            writer.uint32(10).string(message.creator);
-        }
-        if (message.denom !== "") {
-            writer.uint32(18).string(message.denom);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = Object.assign({}, baseMsgEnableSend);
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.creator = reader.string();
-                    break;
-                case 2:
-                    message.denom = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        const message = Object.assign({}, baseMsgEnableSend);
-        message.creator =
-            object.creator !== undefined && object.creator !== null
-                ? String(object.creator)
-                : "";
-        message.denom =
-            object.denom !== undefined && object.denom !== null
-                ? String(object.denom)
-                : "";
-        return message;
-    },
-    toJSON(message) {
-        const obj = {};
-        message.creator !== undefined && (obj.creator = message.creator);
-        message.denom !== undefined && (obj.denom = message.denom);
-        return obj;
-    },
-    fromPartial(object) {
-        var _a, _b;
-        const message = Object.assign({}, baseMsgEnableSend);
-        message.creator = (_a = object.creator) !== null && _a !== void 0 ? _a : "";
-        message.denom = (_b = object.denom) !== null && _b !== void 0 ? _b : "";
-        return message;
-    },
-};
-const baseMsgEnableSendResponse = { denom: "" };
-exports.MsgEnableSendResponse = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.denom !== "") {
-            writer.uint32(10).string(message.denom);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = Object.assign({}, baseMsgEnableSendResponse);
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.denom = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        const message = Object.assign({}, baseMsgEnableSendResponse);
-        message.denom =
-            object.denom !== undefined && object.denom !== null
-                ? String(object.denom)
-                : "";
-        return message;
-    },
-    toJSON(message) {
-        const obj = {};
-        message.denom !== undefined && (obj.denom = message.denom);
-        return obj;
-    },
-    fromPartial(object) {
-        var _a;
-        const message = Object.assign({}, baseMsgEnableSendResponse);
-        message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
-        return message;
-    },
-};
-const baseMsgDisableSend = { creator: "", denom: "" };
-exports.MsgDisableSend = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.creator !== "") {
-            writer.uint32(10).string(message.creator);
-        }
-        if (message.denom !== "") {
-            writer.uint32(18).string(message.denom);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = Object.assign({}, baseMsgDisableSend);
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.creator = reader.string();
-                    break;
-                case 2:
-                    message.denom = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        const message = Object.assign({}, baseMsgDisableSend);
-        message.creator =
-            object.creator !== undefined && object.creator !== null
-                ? String(object.creator)
-                : "";
-        message.denom =
-            object.denom !== undefined && object.denom !== null
-                ? String(object.denom)
-                : "";
-        return message;
-    },
-    toJSON(message) {
-        const obj = {};
-        message.creator !== undefined && (obj.creator = message.creator);
-        message.denom !== undefined && (obj.denom = message.denom);
-        return obj;
-    },
-    fromPartial(object) {
-        var _a, _b;
-        const message = Object.assign({}, baseMsgDisableSend);
-        message.creator = (_a = object.creator) !== null && _a !== void 0 ? _a : "";
-        message.denom = (_b = object.denom) !== null && _b !== void 0 ? _b : "";
-        return message;
-    },
-};
-const baseMsgDisableSendResponse = { denom: "" };
-exports.MsgDisableSendResponse = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.denom !== "") {
-            writer.uint32(10).string(message.denom);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = Object.assign({}, baseMsgDisableSendResponse);
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.denom = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromJSON(object) {
-        const message = Object.assign({}, baseMsgDisableSendResponse);
-        message.denom =
-            object.denom !== undefined && object.denom !== null
-                ? String(object.denom)
-                : "";
-        return message;
-    },
-    toJSON(message) {
-        const obj = {};
-        message.denom !== undefined && (obj.denom = message.denom);
-        return obj;
-    },
-    fromPartial(object) {
-        var _a;
-        const message = Object.assign({}, baseMsgDisableSendResponse);
-        message.denom = (_a = object.denom) !== null && _a !== void 0 ? _a : "";
-        return message;
-    },
-};
-class MsgClientImpl {
-    constructor(rpc) {
-        this.rpc = rpc;
-        this.EnableSend = this.EnableSend.bind(this);
-        this.DisableSend = this.DisableSend.bind(this);
-    }
-    EnableSend(request) {
-        const data = exports.MsgEnableSend.encode(request).finish();
-        const promise = this.rpc.request("Switcheo.carbon.bank.Msg", "EnableSend", data);
-        return promise.then((data) => exports.MsgEnableSendResponse.decode(new minimal_1.default.Reader(data)));
-    }
-    DisableSend(request) {
-        const data = exports.MsgDisableSend.encode(request).finish();
-        const promise = this.rpc.request("Switcheo.carbon.bank.Msg", "DisableSend", data);
-        return promise.then((data) => exports.MsgDisableSendResponse.decode(new minimal_1.default.Reader(data)));
-    }
-}
-exports.MsgClientImpl = MsgClientImpl;
-if (minimal_1.default.util.Long !== long_1.default) {
-    minimal_1.default.util.Long = long_1.default;
-    minimal_1.default.configure();
-}