carbon-js-sdk 0.3.4 → 0.3.6

package/lib/util/api.js

@@ -84,7 +84,7 @@ class HTTP {
          * Executes HTTP GET request with fetch
          */
         this.get = ({ url, headers }) => {
-            return fetch_1.fetch(url, {
+            return (0, fetch_1.fetch)(url, {
                 method: 'GET',
                 headers,
             });
@@ -93,7 +93,7 @@ class HTTP {
          * Executes HTTP POST request with fetch
          */
         this.post = (options) => {
-            return fetch_1.fetch(options.url, {
+            return (0, fetch_1.fetch)(options.url, {
                 method: 'POST',
                 headers: Object.assign({ 'Content-Type': options.content_type || 'application/json' }, options.headers),
                 body: JSON.stringify(options.body),
@@ -103,7 +103,7 @@ class HTTP {
          * Executes HTTP DELETE request with fetch
          */
         this.del = (options) => {
-            return fetch_1.fetch(options.url, {
+            return (0, fetch_1.fetch)(options.url, {
                 method: 'DELETE',
                 headers: Object.assign({ 'Content-Type': options.content_type || 'application/json' }, options.headers),
                 body: JSON.stringify(options.body),
@@ -114,7 +114,7 @@ class HTTP {
          */
         this.raw = (options) => {
             const { url } = options, otherOpts = __rest(options, ["url"]);
-            return fetch_1.fetch(url, otherOpts);
+            return (0, fetch_1.fetch)(url, otherOpts);
         };
         this.apiPrefix = apiPrefix;
         this.apiEndpoints = apiEndpoints;

package/lib/util/fetch.js

@@ -10,7 +10,7 @@ function fetch(url, init) {
         return window.fetch(url, Object.assign({}, init));
     }
     else {
-        return node_fetch_1.default(url, init);
+        return (0, node_fetch_1.default)(url, init);
     }
 }
 exports.fetch = fetch;

package/lib/util/generic.js

@@ -22,7 +22,7 @@ const overrideConfig = (defaults, override) => {
             continue;
         if (typeof member === "object") {
             // @ts-ignore
-            result[key] = exports.overrideConfig(result[key], member);
+            result[key] = (0, exports.overrideConfig)(result[key], member);
         }
         else {
             // @ts-ignore
@@ -41,7 +41,7 @@ const sortObject = (input) => {
     Object.keys(input)
         .sort()
         // @ts-ignore noImplicitAny
-        .forEach((key) => (output[key] = exports.sortObject(input[key])));
+        .forEach((key) => (output[key] = (0, exports.sortObject)(input[key])));
     return output;
 };
 exports.sortObject = sortObject;
@@ -56,7 +56,7 @@ exports.appendHexPrefix = appendHexPrefix;
 const computeTxHash = (bytes) => {
     if (!bytes)
         return bytes;
-    return exports.toTxHash(crypto_1.sha256(bytes));
+    return (0, exports.toTxHash)((0, crypto_1.sha256)(bytes));
 };
 exports.computeTxHash = computeTxHash;
 const toTxHash = (bytes) => {

package/lib/util/number.js

@@ -18,26 +18,26 @@ const parseBN = (input, defaultValue) => {
 };
 exports.parseBN = parseBN;
 const bnOrZero = (input, defaultValue = exports.BN_ZERO) => {
-    return exports.parseBN(input, defaultValue);
+    return (0, exports.parseBN)(input, defaultValue);
 };
 exports.bnOrZero = bnOrZero;
 const toHuman = (value, decimals) => {
     if (value === undefined || value === null)
         return undefined;
-    const valueBN = exports.bnOrZero(value);
+    const valueBN = (0, exports.bnOrZero)(value);
     if (!decimals)
         return valueBN; // decimals = 0 or nullish
-    const decimalsBN = exports.bnOrZero(decimals);
+    const decimalsBN = (0, exports.bnOrZero)(decimals);
     return valueBN.shiftedBy(decimalsBN.negated().toNumber());
 };
 exports.toHuman = toHuman;
 const toUnitless = (value, decimals) => {
     if (value === undefined || value === null)
         return undefined;
-    const valueBN = exports.bnOrZero(value);
+    const valueBN = (0, exports.bnOrZero)(value);
     if (!decimals)
         return valueBN; // decimals = 0 or nullish
-    const decimalsBN = exports.bnOrZero(decimals);
+    const decimalsBN = (0, exports.bnOrZero)(decimals);
     return valueBN.shiftedBy(decimalsBN.toNumber());
 };
 exports.toUnitless = toUnitless;

package/lib/wallet/CarbonSigner.js

@@ -106,9 +106,9 @@ class CarbonLedgerSigner {
         return __awaiter(this, void 0, void 0, function* () {
             const account = yield this.retrieveAccount();
             const { pubkey } = account;
-            const msg = JSON.stringify(generic_1.sortObject(doc));
+            const msg = JSON.stringify((0, generic_1.sortObject)(doc));
             const signBytes = yield this.ledger.sign(msg);
-            const signature = amino_1.encodeSecp256k1Signature(pubkey, signBytes);
+            const signature = (0, amino_1.encodeSecp256k1Signature)(pubkey, signBytes);
             return {
                 signed: doc,
                 signature,

package/lib/wallet/CarbonSigningClient.js

@@ -87,7 +87,7 @@ class CarbonSigningClient extends stargate_1.StargateClient {
      */
     sign(signerAddress, messages, fee, memo, signerData) {
         return __awaiter(this, void 0, void 0, function* () {
-            return proto_signing_1.isOfflineDirectSigner(this.signer)
+            return (0, proto_signing_1.isOfflineDirectSigner)(this.signer)
                 ? this.signDirect(signerAddress, messages, fee, memo, signerData)
                 : this.signAmino(signerAddress, messages, fee, memo, signerData);
         });
@@ -99,7 +99,7 @@ class CarbonSigningClient extends stargate_1.StargateClient {
             if (!accountFromSigner) {
                 throw new Error("Failed to retrieve account from signer");
             }
-            const pubkey = proto_signing_1.encodePubkey(amino_1.encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+            const pubkey = (0, proto_signing_1.encodePubkey)((0, amino_1.encodeSecp256k1Pubkey)(accountFromSigner.pubkey));
             const txBodyEncodeObject = {
                 typeUrl: "/cosmos.tx.v1beta1.TxBody",
                 value: Object.assign({ messages: messages, memo: memo }, timeoutHeight && {
@@ -108,13 +108,13 @@ class CarbonSigningClient extends stargate_1.StargateClient {
             };
             const txBodyBytes = this.registry.encode(txBodyEncodeObject);
             const gasLimit = math_1.Int53.fromString(fee.gas).toNumber();
-            const authInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey, sequence }], fee.amount, gasLimit);
-            const signDoc = proto_signing_1.makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
+            const authInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence }], fee.amount, gasLimit);
+            const signDoc = (0, proto_signing_1.makeSignDoc)(txBodyBytes, authInfoBytes, chainId, accountNumber);
             const { signature, signed } = yield signer.signDirect(signerAddress, signDoc);
             return tx_1.TxRaw.fromPartial({
                 bodyBytes: signed.bodyBytes,
                 authInfoBytes: signed.authInfoBytes,
-                signatures: [encoding_1.fromBase64(signature.signature)],
+                signatures: [(0, encoding_1.fromBase64)(signature.signature)],
             });
         });
     }
@@ -125,7 +125,7 @@ class CarbonSigningClient extends stargate_1.StargateClient {
             if (!accountFromSigner) {
                 throw new Error("Failed to retrieve account from signer");
             }
-            const pubkey = proto_signing_1.encodePubkey(amino_1.encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+            const pubkey = (0, proto_signing_1.encodePubkey)((0, amino_1.encodeSecp256k1Pubkey)(accountFromSigner.pubkey));
             const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
             const msgs = messages.map((msg) => this.aminoTypes.toAmino(msg));
             const signDoc = makeSignDocAmino(msgs, fee, chainId, memo, accountNumber, sequence, timeoutHeight !== null && timeoutHeight !== void 0 ? timeoutHeight : 0);
@@ -140,11 +140,11 @@ class CarbonSigningClient extends stargate_1.StargateClient {
             const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
             const signedGasLimit = math_1.Int53.fromString(signed.fee.gas).toNumber();
             const signedSequence = math_1.Int53.fromString(signed.sequence).toNumber();
-            const signedAuthInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, signMode);
+            const signedAuthInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, signMode);
             return tx_1.TxRaw.fromPartial({
                 bodyBytes: signedTxBodyBytes,
                 authInfoBytes: signedAuthInfoBytes,
-                signatures: [encoding_1.fromBase64(signature.signature)],
+                signatures: [(0, encoding_1.fromBase64)(signature.signature)],
             });
         });
     }

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/lib/wallet/CarbonWallet.js

@@ -148,7 +148,7 @@ class CarbonWallet {
                 const signerData = Object.assign({ accountNumber: this.accountInfo.accountNumber, chainId: this.getChainId(), sequence }, explicitSignerData);
                 const fee = (_a = opts === null || opts === void 0 ? void 0 : opts.fee) !== null && _a !== void 0 ? _a : this.estimateTxFee(messages, feeDenom);
                 const txRaw = yield signingClient.sign(signerAddress, messages, fee, memo, signerData);
-                signature = amino_1.encodeSecp256k1Signature(account.pubkey, txRaw.signatures[0]);
+                signature = (0, amino_1.encodeSecp256k1Signature)(account.pubkey, txRaw.signatures[0]);
                 return txRaw;
             }
             finally {
@@ -166,7 +166,7 @@ class CarbonWallet {
             const tx = CarbonWallet.TxRaw.encode(txRaw).finish();
             const carbonClient = this.getSigningClient();
             const response = yield carbonClient.broadcastTx(tx, timeoutMs, pollIntervalMs);
-            if (stargate_1.isDeliverTxFailure(response)) {
+            if ((0, stargate_1.isDeliverTxFailure)(response)) {
                 // tx failed
                 throw new tx_1.CarbonTxError(`[${response.code}] ${response.rawLog}`, response);
             }
@@ -205,9 +205,9 @@ class CarbonWallet {
             try {
                 if (!this.accountInfo || this.sequenceInvalidated)
                     yield this.reloadAccountSequence();
-                const heightResponse = yield fetch_1.fetch(`${this.networkConfig.tmRpcUrl}/blockchain?cache=${new Date().getTime()}`);
+                const heightResponse = yield (0, fetch_1.fetch)(`${this.networkConfig.tmRpcUrl}/blockchain?cache=${new Date().getTime()}`);
                 const heightRes = yield heightResponse.json();
-                const height = number_1.bnOrZero((_a = heightRes.result) === null || _a === void 0 ? void 0 : _a.last_height);
+                const height = (0, number_1.bnOrZero)((_a = heightRes.result) === null || _a === void 0 ? void 0 : _a.last_height);
                 const timeoutHeight = height.isZero() ? undefined : height.toNumber() + this.defaultTimeoutBlocks;
                 const sequence = this.accountInfo.sequence;
                 this.accountInfo = Object.assign(Object.assign({}, this.accountInfo), { sequence: sequence + 1 });
@@ -341,12 +341,12 @@ class CarbonWallet {
             const queryClient = this.getQueryClient();
             const { msgGasCosts } = yield queryClient.fee.MsgGasCostAll({});
             this.txGasCosts = msgGasCosts.reduce((result, item) => {
-                result[item.msgType] = number_1.bnOrZero(item.gasCost);
+                result[item.msgType] = (0, number_1.bnOrZero)(item.gasCost);
                 return result;
             }, {});
             const { minGasPrices } = yield queryClient.fee.MinGasPriceAll({});
             this.txGasPrices = minGasPrices.reduce((result, item) => {
-                result[item.denom] = number_1.bnOrZero(item.gasPrice).shiftedBy(-18); // sdk.Dec shifting
+                result[item.denom] = (0, number_1.bnOrZero)(item.gasPrice).shiftedBy(-18); // sdk.Dec shifting
                 return result;
             }, {});
             if (!this.txGasPrices[this.defaultFeeDenom]) {

package/lib/websocket/connector.js

@@ -171,7 +171,7 @@ class WSConnector {
             params = [params]; // eslint-disable-line no-param-reassign
         }
         for (const param of params) {
-            const channelId = channel_1.generateChannelId(param);
+            const channelId = (0, channel_1.generateChannelId)(param);
             const shouldSubscribe = this.channelHandlers[channelId] === undefined;
             this.channelHandlers[channelId] = handler;
             if (shouldSubscribe) {
@@ -193,7 +193,7 @@ class WSConnector {
         }
         const channelIds = [];
         for (const param of params) {
-            const channelId = channel_1.generateChannelId(param);
+            const channelId = (0, channel_1.generateChannelId)(param);
             delete this.channelHandlers[channelId];
         }
         this.send('unsubscribe', {
@@ -279,7 +279,7 @@ class WSConnector {
             if (!channelHandler) {
                 this.debugLog(`handler not found for channel: ${message.channel}`);
                 try {
-                    const params = channel_1.parseChannelId(message.channel);
+                    const params = (0, channel_1.parseChannelId)(message.channel);
                     this.unsubscribe({ channel: params.channel });
                 }
                 catch (error) {

package/package.json

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