@gnolang/tm2-js-client 1.0.3 → 1.0.5

package/bin/provider/errors/errors.d.ts

@@ -0,0 +1,59 @@
+declare class TM2Error extends Error {
+    log?: string;
+    constructor(message: string, log?: string);
+}
+declare class InternalError extends TM2Error {
+    constructor(log?: string);
+}
+declare class TxDecodeError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InvalidSequenceError extends TM2Error {
+    constructor(log?: string);
+}
+declare class UnauthorizedError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InsufficientFundsError extends TM2Error {
+    constructor(log?: string);
+}
+declare class UnknownRequestError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InvalidAddressError extends TM2Error {
+    constructor(log?: string);
+}
+declare class UnknownAddressError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InvalidPubKeyError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InsufficientCoinsError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InvalidCoinsError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InvalidGasWantedError extends TM2Error {
+    constructor(log?: string);
+}
+declare class OutOfGasError extends TM2Error {
+    constructor(log?: string);
+}
+declare class MemoTooLargeError extends TM2Error {
+    constructor(log?: string);
+}
+declare class InsufficientFeeError extends TM2Error {
+    constructor(log?: string);
+}
+declare class TooManySignaturesError extends TM2Error {
+    constructor(log?: string);
+}
+declare class NoSignaturesError extends TM2Error {
+    constructor(log?: string);
+}
+declare class GasOverflowError extends TM2Error {
+    constructor(log?: string);
+}
+export { TM2Error, InternalError, TxDecodeError, InvalidSequenceError, UnauthorizedError, InsufficientFundsError, UnknownRequestError, InvalidAddressError, UnknownAddressError, InvalidPubKeyError, InsufficientCoinsError, InvalidCoinsError, InvalidGasWantedError, OutOfGasError, MemoTooLargeError, InsufficientFeeError, TooManySignaturesError, NoSignaturesError, GasOverflowError, };

package/bin/provider/errors/errors.js

@@ -0,0 +1,173 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasOverflowError = exports.NoSignaturesError = exports.TooManySignaturesError = exports.InsufficientFeeError = exports.MemoTooLargeError = exports.OutOfGasError = exports.InvalidGasWantedError = exports.InvalidCoinsError = exports.InsufficientCoinsError = exports.InvalidPubKeyError = exports.UnknownAddressError = exports.InvalidAddressError = exports.UnknownRequestError = exports.InsufficientFundsError = exports.UnauthorizedError = exports.InvalidSequenceError = exports.TxDecodeError = exports.InternalError = exports.TM2Error = void 0;
+var messages_1 = require("./messages");
+var TM2Error = /** @class */ (function (_super) {
+    __extends(TM2Error, _super);
+    function TM2Error(message, log) {
+        var _this = _super.call(this, message) || this;
+        _this.log = log;
+        return _this;
+    }
+    return TM2Error;
+}(Error));
+exports.TM2Error = TM2Error;
+var InternalError = /** @class */ (function (_super) {
+    __extends(InternalError, _super);
+    function InternalError(log) {
+        return _super.call(this, messages_1.InternalErrorMessage, log) || this;
+    }
+    return InternalError;
+}(TM2Error));
+exports.InternalError = InternalError;
+var TxDecodeError = /** @class */ (function (_super) {
+    __extends(TxDecodeError, _super);
+    function TxDecodeError(log) {
+        return _super.call(this, messages_1.TxDecodeErrorMessage, log) || this;
+    }
+    return TxDecodeError;
+}(TM2Error));
+exports.TxDecodeError = TxDecodeError;
+var InvalidSequenceError = /** @class */ (function (_super) {
+    __extends(InvalidSequenceError, _super);
+    function InvalidSequenceError(log) {
+        return _super.call(this, messages_1.InvalidSequenceErrorMessage, log) || this;
+    }
+    return InvalidSequenceError;
+}(TM2Error));
+exports.InvalidSequenceError = InvalidSequenceError;
+var UnauthorizedError = /** @class */ (function (_super) {
+    __extends(UnauthorizedError, _super);
+    function UnauthorizedError(log) {
+        return _super.call(this, messages_1.UnauthorizedErrorMessage, log) || this;
+    }
+    return UnauthorizedError;
+}(TM2Error));
+exports.UnauthorizedError = UnauthorizedError;
+var InsufficientFundsError = /** @class */ (function (_super) {
+    __extends(InsufficientFundsError, _super);
+    function InsufficientFundsError(log) {
+        return _super.call(this, messages_1.InsufficientFundsErrorMessage, log) || this;
+    }
+    return InsufficientFundsError;
+}(TM2Error));
+exports.InsufficientFundsError = InsufficientFundsError;
+var UnknownRequestError = /** @class */ (function (_super) {
+    __extends(UnknownRequestError, _super);
+    function UnknownRequestError(log) {
+        return _super.call(this, messages_1.UnknownRequestErrorMessage, log) || this;
+    }
+    return UnknownRequestError;
+}(TM2Error));
+exports.UnknownRequestError = UnknownRequestError;
+var InvalidAddressError = /** @class */ (function (_super) {
+    __extends(InvalidAddressError, _super);
+    function InvalidAddressError(log) {
+        return _super.call(this, messages_1.InvalidAddressErrorMessage, log) || this;
+    }
+    return InvalidAddressError;
+}(TM2Error));
+exports.InvalidAddressError = InvalidAddressError;
+var UnknownAddressError = /** @class */ (function (_super) {
+    __extends(UnknownAddressError, _super);
+    function UnknownAddressError(log) {
+        return _super.call(this, messages_1.UnknownAddressErrorMessage, log) || this;
+    }
+    return UnknownAddressError;
+}(TM2Error));
+exports.UnknownAddressError = UnknownAddressError;
+var InvalidPubKeyError = /** @class */ (function (_super) {
+    __extends(InvalidPubKeyError, _super);
+    function InvalidPubKeyError(log) {
+        return _super.call(this, messages_1.InvalidPubKeyErrorMessage, log) || this;
+    }
+    return InvalidPubKeyError;
+}(TM2Error));
+exports.InvalidPubKeyError = InvalidPubKeyError;
+var InsufficientCoinsError = /** @class */ (function (_super) {
+    __extends(InsufficientCoinsError, _super);
+    function InsufficientCoinsError(log) {
+        return _super.call(this, messages_1.InsufficientCoinsErrorMessage, log) || this;
+    }
+    return InsufficientCoinsError;
+}(TM2Error));
+exports.InsufficientCoinsError = InsufficientCoinsError;
+var InvalidCoinsError = /** @class */ (function (_super) {
+    __extends(InvalidCoinsError, _super);
+    function InvalidCoinsError(log) {
+        return _super.call(this, messages_1.InvalidCoinsErrorMessage, log) || this;
+    }
+    return InvalidCoinsError;
+}(TM2Error));
+exports.InvalidCoinsError = InvalidCoinsError;
+var InvalidGasWantedError = /** @class */ (function (_super) {
+    __extends(InvalidGasWantedError, _super);
+    function InvalidGasWantedError(log) {
+        return _super.call(this, messages_1.InvalidGasWantedErrorMessage, log) || this;
+    }
+    return InvalidGasWantedError;
+}(TM2Error));
+exports.InvalidGasWantedError = InvalidGasWantedError;
+var OutOfGasError = /** @class */ (function (_super) {
+    __extends(OutOfGasError, _super);
+    function OutOfGasError(log) {
+        return _super.call(this, messages_1.OutOfGasErrorMessage, log) || this;
+    }
+    return OutOfGasError;
+}(TM2Error));
+exports.OutOfGasError = OutOfGasError;
+var MemoTooLargeError = /** @class */ (function (_super) {
+    __extends(MemoTooLargeError, _super);
+    function MemoTooLargeError(log) {
+        return _super.call(this, messages_1.MemoTooLargeErrorMessage, log) || this;
+    }
+    return MemoTooLargeError;
+}(TM2Error));
+exports.MemoTooLargeError = MemoTooLargeError;
+var InsufficientFeeError = /** @class */ (function (_super) {
+    __extends(InsufficientFeeError, _super);
+    function InsufficientFeeError(log) {
+        return _super.call(this, messages_1.InsufficientFeeErrorMessage, log) || this;
+    }
+    return InsufficientFeeError;
+}(TM2Error));
+exports.InsufficientFeeError = InsufficientFeeError;
+var TooManySignaturesError = /** @class */ (function (_super) {
+    __extends(TooManySignaturesError, _super);
+    function TooManySignaturesError(log) {
+        return _super.call(this, messages_1.TooManySignaturesErrorMessage, log) || this;
+    }
+    return TooManySignaturesError;
+}(TM2Error));
+exports.TooManySignaturesError = TooManySignaturesError;
+var NoSignaturesError = /** @class */ (function (_super) {
+    __extends(NoSignaturesError, _super);
+    function NoSignaturesError(log) {
+        return _super.call(this, messages_1.NoSignaturesErrorMessage, log) || this;
+    }
+    return NoSignaturesError;
+}(TM2Error));
+exports.NoSignaturesError = NoSignaturesError;
+var GasOverflowError = /** @class */ (function (_super) {
+    __extends(GasOverflowError, _super);
+    function GasOverflowError(log) {
+        return _super.call(this, messages_1.GasOverflowErrorMessage, log) || this;
+    }
+    return GasOverflowError;
+}(TM2Error));
+exports.GasOverflowError = GasOverflowError;

package/bin/provider/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './errors';

package/bin/provider/errors/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);

package/bin/provider/errors/messages.d.ts

@@ -0,0 +1,19 @@
+declare const InternalErrorMessage = "internal error encountered";
+declare const TxDecodeErrorMessage = "unable to decode tx";
+declare const InvalidSequenceErrorMessage = "invalid sequence";
+declare const UnauthorizedErrorMessage = "signature is unauthorized";
+declare const InsufficientFundsErrorMessage = "insufficient funds";
+declare const UnknownRequestErrorMessage = "unknown request";
+declare const InvalidAddressErrorMessage = "invalid address";
+declare const UnknownAddressErrorMessage = "unknown address";
+declare const InvalidPubKeyErrorMessage = "invalid pubkey";
+declare const InsufficientCoinsErrorMessage = "insufficient coins";
+declare const InvalidCoinsErrorMessage = "invalid coins";
+declare const InvalidGasWantedErrorMessage = "invalid gas wanted";
+declare const OutOfGasErrorMessage = "out of gas";
+declare const MemoTooLargeErrorMessage = "memo too large";
+declare const InsufficientFeeErrorMessage = "insufficient fee";
+declare const TooManySignaturesErrorMessage = "too many signatures";
+declare const NoSignaturesErrorMessage = "no signatures";
+declare const GasOverflowErrorMessage = "gas overflow";
+export { InternalErrorMessage, TxDecodeErrorMessage, InvalidSequenceErrorMessage, UnauthorizedErrorMessage, InsufficientFundsErrorMessage, UnknownRequestErrorMessage, InvalidAddressErrorMessage, UnknownAddressErrorMessage, InvalidPubKeyErrorMessage, InsufficientCoinsErrorMessage, InvalidCoinsErrorMessage, InvalidGasWantedErrorMessage, OutOfGasErrorMessage, MemoTooLargeErrorMessage, InsufficientFeeErrorMessage, TooManySignaturesErrorMessage, NoSignaturesErrorMessage, GasOverflowErrorMessage, };

package/bin/provider/errors/messages.js

@@ -0,0 +1,41 @@
+"use strict";
+// Errors constructed from:
+// https://github.com/gnolang/gno/blob/master/tm2/pkg/std/errors.go
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasOverflowErrorMessage = exports.NoSignaturesErrorMessage = exports.TooManySignaturesErrorMessage = exports.InsufficientFeeErrorMessage = exports.MemoTooLargeErrorMessage = exports.OutOfGasErrorMessage = exports.InvalidGasWantedErrorMessage = exports.InvalidCoinsErrorMessage = exports.InsufficientCoinsErrorMessage = exports.InvalidPubKeyErrorMessage = exports.UnknownAddressErrorMessage = exports.InvalidAddressErrorMessage = exports.UnknownRequestErrorMessage = exports.InsufficientFundsErrorMessage = exports.UnauthorizedErrorMessage = exports.InvalidSequenceErrorMessage = exports.TxDecodeErrorMessage = exports.InternalErrorMessage = void 0;
+var InternalErrorMessage = 'internal error encountered';
+exports.InternalErrorMessage = InternalErrorMessage;
+var TxDecodeErrorMessage = 'unable to decode tx';
+exports.TxDecodeErrorMessage = TxDecodeErrorMessage;
+var InvalidSequenceErrorMessage = 'invalid sequence';
+exports.InvalidSequenceErrorMessage = InvalidSequenceErrorMessage;
+var UnauthorizedErrorMessage = 'signature is unauthorized';
+exports.UnauthorizedErrorMessage = UnauthorizedErrorMessage;
+var InsufficientFundsErrorMessage = 'insufficient funds';
+exports.InsufficientFundsErrorMessage = InsufficientFundsErrorMessage;
+var UnknownRequestErrorMessage = 'unknown request';
+exports.UnknownRequestErrorMessage = UnknownRequestErrorMessage;
+var InvalidAddressErrorMessage = 'invalid address';
+exports.InvalidAddressErrorMessage = InvalidAddressErrorMessage;
+var UnknownAddressErrorMessage = 'unknown address';
+exports.UnknownAddressErrorMessage = UnknownAddressErrorMessage;
+var InvalidPubKeyErrorMessage = 'invalid pubkey';
+exports.InvalidPubKeyErrorMessage = InvalidPubKeyErrorMessage;
+var InsufficientCoinsErrorMessage = 'insufficient coins';
+exports.InsufficientCoinsErrorMessage = InsufficientCoinsErrorMessage;
+var InvalidCoinsErrorMessage = 'invalid coins';
+exports.InvalidCoinsErrorMessage = InvalidCoinsErrorMessage;
+var InvalidGasWantedErrorMessage = 'invalid gas wanted';
+exports.InvalidGasWantedErrorMessage = InvalidGasWantedErrorMessage;
+var OutOfGasErrorMessage = 'out of gas';
+exports.OutOfGasErrorMessage = OutOfGasErrorMessage;
+var MemoTooLargeErrorMessage = 'memo too large';
+exports.MemoTooLargeErrorMessage = MemoTooLargeErrorMessage;
+var InsufficientFeeErrorMessage = 'insufficient fee';
+exports.InsufficientFeeErrorMessage = InsufficientFeeErrorMessage;
+var TooManySignaturesErrorMessage = 'too many signatures';
+exports.TooManySignaturesErrorMessage = TooManySignaturesErrorMessage;
+var NoSignaturesErrorMessage = 'no signatures';
+exports.NoSignaturesErrorMessage = NoSignaturesErrorMessage;
+var GasOverflowErrorMessage = 'gas overflow';
+exports.GasOverflowErrorMessage = GasOverflowErrorMessage;

package/bin/provider/index.d.ts

@@ -4,3 +4,4 @@ export * from './utility';
 export * from './websocket';
 export * from './endpoints';
 export * from './provider';
+export * from './errors';

package/bin/provider/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./utility"), exports);
 __exportStar(require("./websocket"), exports);
 __exportStar(require("./endpoints"), exports);
 __exportStar(require("./provider"), exports);
+__exportStar(require("./errors"), exports);

package/bin/provider/jsonrpc/jsonrpc.d.ts

@@ -1,5 +1,6 @@
 import { Provider } from '../provider';
 import { BlockInfo, BlockResult, ConsensusParams, NetworkInfo, Status } from '../types';
+import { TransactionEndpoint } from '../endpoints';
 import { Tx } from '../../proto';
 /**
  * Provider based on JSON-RPC HTTP requests
@@ -22,6 +23,8 @@ export declare class JSONRPCProvider implements Provider {
     getAccountSequence(address: string, height?: number): Promise<number>;
     getAccountNumber(address: string, height?: number): Promise<number>;
     getStatus(): Promise<Status>;
-    sendTransaction(tx: string): Promise<string>;
+    sendTransaction(tx: string, endpoint?: TransactionEndpoint.BROADCAST_TX_SYNC | TransactionEndpoint.BROADCAST_TX_COMMIT): Promise<string>;
+    private broadcastTxSync;
+    private broadcastTxCommit;
     waitForTransaction(hash: string, fromHeight?: number, timeout?: number): Promise<Tx>;
 }

package/bin/provider/jsonrpc/jsonrpc.js

@@ -40,6 +40,7 @@ exports.JSONRPCProvider = void 0;
 var services_1 = require("../../services");
 var utility_1 = require("../utility");
 var endpoints_1 = require("../endpoints");
+var errors_utility_1 = require("../utility/errors.utility");
 /**
  * Provider based on JSON-RPC HTTP requests
  */
@@ -192,16 +193,68 @@ var JSONRPCProvider = /** @class */ (function () {
             });
         });
     };
-    JSONRPCProvider.prototype.sendTransaction = function (tx) {
+    JSONRPCProvider.prototype.sendTransaction = function (tx, endpoint) {
         return __awaiter(this, void 0, void 0, function () {
-            var response;
+            var queryEndpoint, request;
+            return __generator(this, function (_a) {
+                queryEndpoint = endpoint
+                    ? endpoint
+                    : endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC;
+                request = (0, utility_1.newRequest)(queryEndpoint, [tx]);
+                if (queryEndpoint == endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC) {
+                    return [2 /*return*/, this.broadcastTxSync(request)];
+                }
+                // The endpoint is a commit broadcast
+                // (it waits for the transaction to be committed) to the chain before returning
+                return [2 /*return*/, this.broadcastTxCommit(request)];
+            });
+        });
+    };
+    JSONRPCProvider.prototype.broadcastTxSync = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, errType, log;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, services_1.RestService.post(this.baseURL, {
+                            request: request,
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        // Check if there is an immediate tx-broadcast error
+                        // (originating from basic transaction checks like CheckTx)
+                        if (response.error) {
+                            errType = response.error.ABCIErrorKey;
+                            log = response.Log;
+                            throw (0, errors_utility_1.constructRequestError)(errType, log);
+                        }
+                        return [2 /*return*/, response.hash];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.broadcastTxCommit = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, check_tx, deliver_tx, errType, log, errType, log;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, services_1.RestService.post(this.baseURL, {
-                            request: (0, utility_1.newRequest)(endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC, [tx]),
+                            request: request,
                         })];
                     case 1:
                         response = _a.sent();
+                        check_tx = response.check_tx, deliver_tx = response.deliver_tx;
+                        // Check if there is an immediate tx-broadcast error (in CheckTx)
+                        if (check_tx.ResponseBase.Error) {
+                            errType = check_tx.ResponseBase.Error.ABCIErrorKey;
+                            log = check_tx.ResponseBase.Log;
+                            throw (0, errors_utility_1.constructRequestError)(errType, log);
+                        }
+                        // Check if there is a parsing error with the transaction (in DeliverTx)
+                        if (deliver_tx.ResponseBase.Error) {
+                            errType = deliver_tx.ResponseBase.Error.ABCIErrorKey;
+                            log = deliver_tx.ResponseBase.Log;
+                            throw (0, errors_utility_1.constructRequestError)(errType, log);
+                        }
                         return [2 /*return*/, response.hash];
                 }
             });

package/bin/provider/jsonrpc/jsonrpc.test.js

@@ -46,6 +46,7 @@ var jest_mock_extended_1 = require("jest-mock-extended");
 var proto_1 = require("../../proto");
 var crypto_1 = require("@cosmjs/crypto");
 var endpoints_1 = require("../endpoints");
+var messages_1 = require("../errors/messages");
 jest.mock('axios');
 var mockedAxios = axios_1.default;
 var mockURL = '127.0.0.1:26657';
@@ -108,26 +109,57 @@ describe('JSON-RPC Provider', function () {
             }
         });
     }); });
-    test('sendTransaction', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResult, provider, hash;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    mockResult = (0, jest_mock_extended_1.mock)();
-                    mockResult.hash = 'hash123';
-                    mockedAxios.post.mockResolvedValue({
-                        data: (0, utility_1.newResponse)(mockResult),
-                    });
-                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
-                    return [4 /*yield*/, provider.sendTransaction('encoded tx')];
-                case 1:
-                    hash = _a.sent();
-                    expect(axios_1.default.post).toHaveBeenCalled();
-                    expect(hash).toEqual(mockResult.hash);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    describe('sendTransaction', function () {
+        var validResult = {
+            error: null,
+            data: null,
+            Log: '',
+            hash: 'hash123',
+        };
+        var mockError = '/std.UnauthorizedError';
+        var mockLog = 'random error message';
+        var invalidResult = {
+            error: {
+                ABCIErrorKey: mockError,
+            },
+            data: null,
+            Log: mockLog,
+            hash: '',
+        };
+        test.each([
+            [validResult, validResult.hash, '', ''],
+            [invalidResult, invalidResult.hash, messages_1.UnauthorizedErrorMessage, mockLog], // error out
+        ])('case %#', function (response, expectedHash, expectedErr, expectedLog) { return __awaiter(void 0, void 0, void 0, function () {
+            var provider, hash, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockedAxios.post.mockResolvedValue({
+                            data: (0, utility_1.newResponse)(response),
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                        return [4 /*yield*/, provider.sendTransaction('encoded tx')];
+                    case 2:
+                        hash = _a.sent();
+                        expect(axios_1.default.post).toHaveBeenCalled();
+                        expect(hash).toEqual(expectedHash);
+                        if (expectedErr != '') {
+                            fail('expected error');
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        expect(e_1.message).toBe(expectedErr);
+                        expect(e_1.log).toBe(expectedLog);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    });
     test('waitForTransaction', function () { return __awaiter(void 0, void 0, void 0, function () {
         var emptyBlock, tx, encodedTx, txHash, filledBlock, latestBlock, startBlock, mockStatus, responseMap, provider, receivedTx;
         return __generator(this, function (_a) {
@@ -337,7 +369,7 @@ describe('JSON-RPC Provider', function () {
             ],
             ['null', 0], // account doesn't exist
         ])('case %#', function (response, expected) { return __awaiter(void 0, void 0, void 0, function () {
-            var mockABCIResponse, provider, accountNumber, e_1;
+            var mockABCIResponse, provider, accountNumber, e_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -363,8 +395,8 @@ describe('JSON-RPC Provider', function () {
                         expect(accountNumber).toBe(expected);
                         return [3 /*break*/, 4];
                     case 3:
-                        e_1 = _a.sent();
-                        expect(e_1.message).toContain('account is not initialized');
+                        e_2 = _a.sent();
+                        expect(e_2.message).toContain('account is not initialized');
                         return [3 /*break*/, 4];
                     case 4: return [2 /*return*/];
                 }

package/bin/provider/provider.d.ts

@@ -1,5 +1,6 @@
 import { BlockInfo, BlockResult, ConsensusParams, NetworkInfo, Status } from './types';
 import { Tx } from '../proto';
+import { TransactionEndpoint } from './endpoints';
 /**
  * Read-only abstraction for accessing blockchain data
  */
@@ -68,8 +69,10 @@ export interface Provider {
      * The transaction needs to be signed beforehand.
      * Returns the transaction hash
      * @param {string} tx the base64-encoded signed transaction
+     * @param {TransactionEndpoint} endpoint the transaction broadcast type (sync / commit).
+     * Defaults to broadcast_sync
      */
-    sendTransaction(tx: string): Promise<string>;
+    sendTransaction(tx: string, endpoint?: TransactionEndpoint.BROADCAST_TX_SYNC | TransactionEndpoint.BROADCAST_TX_COMMIT): Promise<string>;
     /**
      * Waits for the transaction to be committed on the chain.
      * NOTE: This method will not take in the fromHeight parameter once

package/bin/provider/types/common.d.ts

@@ -143,7 +143,7 @@ export interface EndBlock {
 export interface BeginBlock {
     ResponseBase: ABCIResponseBase;
 }
-export interface BroadcastTxResult {
+export interface BroadcastTxSyncResult {
     error: {
         [key: string]: string;
     } | null;
@@ -151,4 +151,10 @@ export interface BroadcastTxResult {
     Log: string;
     hash: string;
 }
+export interface BroadcastTxCommitResult {
+    check_tx: DeliverTx;
+    deliver_tx: DeliverTx;
+    hash: string;
+    height: string;
+}
 export {};

package/bin/provider/utility/errors.utility.d.ts

@@ -0,0 +1,11 @@
+import { TM2Error } from '../errors';
+/**
+ * Constructs the appropriate Tendermint2
+ * error based on the error ID.
+ * Error IDs retrieved from:
+ * https://github.com/gnolang/gno/blob/64f0fd0fa44021a076e1453b1767fbc914ed3b66/tm2/pkg/std/package.go#L20C1-L38
+ * @param {string} errorID the proto ID of the error
+ * @param {string} [log] the log associated with the error, if any
+ * @returns {TM2Error}
+ */
+export declare const constructRequestError: (errorID: string, log?: string) => TM2Error;

package/bin/provider/utility/errors.utility.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructRequestError = void 0;
+var errors_1 = require("../errors");
+/**
+ * Constructs the appropriate Tendermint2
+ * error based on the error ID.
+ * Error IDs retrieved from:
+ * https://github.com/gnolang/gno/blob/64f0fd0fa44021a076e1453b1767fbc914ed3b66/tm2/pkg/std/package.go#L20C1-L38
+ * @param {string} errorID the proto ID of the error
+ * @param {string} [log] the log associated with the error, if any
+ * @returns {TM2Error}
+ */
+var constructRequestError = function (errorID, log) {
+    switch (errorID) {
+        case '/std.InternalError':
+            return new errors_1.InternalError(log);
+        case '/std.TxDecodeError':
+            return new errors_1.TxDecodeError(log);
+        case '/std.InvalidSequenceError':
+            return new errors_1.InvalidSequenceError(log);
+        case '/std.UnauthorizedError':
+            return new errors_1.UnauthorizedError(log);
+        case '/std.InsufficientFundsError':
+            return new errors_1.InsufficientFundsError(log);
+        case '/std.UnknownRequestError':
+            return new errors_1.UnknownRequestError(log);
+        case '/std.InvalidAddressError':
+            return new errors_1.InvalidAddressError(log);
+        case '/std.UnknownAddressError':
+            return new errors_1.UnknownAddressError(log);
+        case '/std.InvalidPubKeyError':
+            return new errors_1.InvalidPubKeyError(log);
+        case '/std.InsufficientCoinsError':
+            return new errors_1.InsufficientCoinsError(log);
+        case '/std.InvalidCoinsError':
+            return new errors_1.InvalidCoinsError(log);
+        case '/std.InvalidGasWantedError':
+            return new errors_1.InvalidGasWantedError(log);
+        case '/std.OutOfGasError':
+            return new errors_1.OutOfGasError(log);
+        case '/std.MemoTooLargeError':
+            return new errors_1.MemoTooLargeError(log);
+        case '/std.InsufficientFeeError':
+            return new errors_1.InsufficientFeeError(log);
+        case '/std.TooManySignaturesError':
+            return new errors_1.TooManySignaturesError(log);
+        case '/std.NoSignaturesError':
+            return new errors_1.NoSignaturesError(log);
+        case '/std.GasOverflowError':
+            return new errors_1.GasOverflowError(log);
+        default:
+            return new errors_1.TM2Error("unknown error: ".concat(errorID), log);
+    }
+};
+exports.constructRequestError = constructRequestError;

package/bin/provider/websocket/ws.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Provider } from '../provider';
 import { BlockInfo, BlockResult, ConsensusParams, NetworkInfo, RPCRequest, RPCResponse, Status } from '../types';
+import { TransactionEndpoint } from '../endpoints';
 import { Tx } from '../../proto';
 /**
  * Provider based on WS JSON-RPC HTTP requests
@@ -50,6 +51,8 @@ export declare class WSProvider implements Provider {
     getAccountSequence(address: string, height?: number): Promise<number>;
     getAccountNumber(address: string, height?: number): Promise<number>;
     getStatus(): Promise<Status>;
-    sendTransaction(tx: string): Promise<string>;
+    sendTransaction(tx: string, endpoint?: TransactionEndpoint.BROADCAST_TX_SYNC | TransactionEndpoint.BROADCAST_TX_COMMIT): Promise<string>;
+    private broadcastTxSync;
+    private broadcastTxCommit;
     waitForTransaction(hash: string, fromHeight?: number, timeout?: number): Promise<Tx>;
 }

package/bin/provider/websocket/ws.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WSProvider = void 0;
 var utility_1 = require("../utility");
 var endpoints_1 = require("../endpoints");
+var errors_utility_1 = require("../utility/errors.utility");
 /**
  * Provider based on WS JSON-RPC HTTP requests
  */
@@ -282,15 +283,67 @@ var WSProvider = /** @class */ (function () {
             });
         });
     };
-    WSProvider.prototype.sendTransaction = function (tx) {
+    WSProvider.prototype.sendTransaction = function (tx, endpoint) {
         return __awaiter(this, void 0, void 0, function () {
-            var response;
+            var queryEndpoint, request;
+            return __generator(this, function (_a) {
+                queryEndpoint = endpoint
+                    ? endpoint
+                    : endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC;
+                request = (0, utility_1.newRequest)(queryEndpoint, [tx]);
+                if (queryEndpoint == endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC) {
+                    return [2 /*return*/, this.broadcastTxSync(request)];
+                }
+                // The endpoint is a commit broadcast
+                // (it waits for the transaction to be committed) to the chain before returning
+                return [2 /*return*/, this.broadcastTxCommit(request)];
+            });
+        });
+    };
+    WSProvider.prototype.broadcastTxSync = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, broadcastResponse, errType, log;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest(request)];
+                    case 1:
+                        response = _a.sent();
+                        broadcastResponse = this.parseResponse(response);
+                        // Check if there is an immediate tx-broadcast error
+                        // (originating from basic transaction checks like CheckTx)
+                        if (broadcastResponse.error) {
+                            errType = broadcastResponse.error.ABCIErrorKey;
+                            log = broadcastResponse.Log;
+                            throw (0, errors_utility_1.constructRequestError)(errType, log);
+                        }
+                        return [2 /*return*/, broadcastResponse.hash];
+                }
+            });
+        });
+    };
+    WSProvider.prototype.broadcastTxCommit = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, broadcastResponse, check_tx, deliver_tx, errType, log, errType, log;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sendRequest((0, utility_1.newRequest)(endpoints_1.TransactionEndpoint.BROADCAST_TX_SYNC, [tx]))];
+                    case 0: return [4 /*yield*/, this.sendRequest(request)];
                     case 1:
                         response = _a.sent();
-                        return [2 /*return*/, this.parseResponse(response).hash];
+                        broadcastResponse = this.parseResponse(response);
+                        check_tx = broadcastResponse.check_tx, deliver_tx = broadcastResponse.deliver_tx;
+                        // Check if there is an immediate tx-broadcast error (in CheckTx)
+                        if (check_tx.ResponseBase.Error) {
+                            errType = check_tx.ResponseBase.Error.ABCIErrorKey;
+                            log = check_tx.ResponseBase.Log;
+                            throw (0, errors_utility_1.constructRequestError)(errType, log);
+                        }
+                        // Check if there is a parsing error with the transaction (in DeliverTx)
+                        if (deliver_tx.ResponseBase.Error) {
+                            errType = deliver_tx.ResponseBase.Error.ABCIErrorKey;
+                            log = deliver_tx.ResponseBase.Log;
+                            throw (0, errors_utility_1.constructRequestError)(errType, log);
+                        }
+                        return [2 /*return*/, broadcastResponse.hash];
                 }
             });
         });

package/bin/provider/websocket/ws.test.js

@@ -45,6 +45,7 @@ var jest_websocket_mock_1 = __importDefault(require("jest-websocket-mock"));
 var proto_1 = require("../../proto");
 var crypto_1 = require("@cosmjs/crypto");
 var endpoints_1 = require("../endpoints");
+var messages_1 = require("../errors/messages");
 describe('WS Provider', function () {
     var wsPort = 8545;
     var wsHost = 'localhost';
@@ -336,30 +337,54 @@ describe('WS Provider', function () {
             }
         });
     }); });
-    test('sendTransaction', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResult, hash;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    mockResult = {
-                        error: null,
-                        data: null,
-                        Log: '',
-                        hash: 'hash123',
-                    };
-                    // Set the response
-                    return [4 /*yield*/, setHandler(mockResult)];
-                case 1:
-                    // Set the response
-                    _a.sent();
-                    return [4 /*yield*/, wsProvider.sendTransaction('encoded tx')];
-                case 2:
-                    hash = _a.sent();
-                    expect(hash).toBe(mockResult.hash);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    describe('sendTransaction', function () {
+        var validResult = {
+            error: null,
+            data: null,
+            Log: '',
+            hash: 'hash123',
+        };
+        var mockError = '/std.UnauthorizedError';
+        var mockLog = 'random error message';
+        var invalidResult = {
+            error: {
+                ABCIErrorKey: mockError,
+            },
+            data: null,
+            Log: mockLog,
+            hash: '',
+        };
+        test.each([
+            [validResult, validResult.hash, '', ''],
+            [invalidResult, invalidResult.hash, messages_1.UnauthorizedErrorMessage, mockLog], // error out
+        ])('case %#', function (response, expectedHash, expectedErr, expectedLog) { return __awaiter(void 0, void 0, void 0, function () {
+            var hash, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, setHandler(response)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, wsProvider.sendTransaction('encoded tx')];
+                    case 3:
+                        hash = _a.sent();
+                        expect(hash).toEqual(expectedHash);
+                        if (expectedErr != '') {
+                            fail('expected error');
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_2 = _a.sent();
+                        expect(e_2.message).toBe(expectedErr);
+                        expect(e_2.log).toBe(expectedLog);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); });
+    });
     var getEmptyBlockInfo = function () {
         var emptyHeader = {
             version: '',

package/bin/wallet/key/key.js

@@ -60,8 +60,8 @@ var KeySigner = /** @class */ (function () {
      * @param {string} addressPrefix the address prefix
      */
     function KeySigner(privateKey, publicKey, addressPrefix) {
-        if (addressPrefix === void 0) { addressPrefix = utility_1.defaultAddressPrefix; }
         var _this = this;
+        if (addressPrefix === void 0) { addressPrefix = utility_1.defaultAddressPrefix; }
         this.getAddress = function () { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, (0, amino_1.pubkeyToAddress)((0, amino_1.encodeSecp256k1Pubkey)(crypto_1.Secp256k1.compressPubkey(this.publicKey)), this.addressPrefix)];

package/bin/wallet/ledger/ledger.js

@@ -51,8 +51,8 @@ var LedgerSigner = /** @class */ (function () {
      * @param {string} addressPrefix the address prefix
      */
     function LedgerSigner(connector, accountIndex, addressPrefix) {
-        if (addressPrefix === void 0) { addressPrefix = utility_1.defaultAddressPrefix; }
         var _this = this;
+        if (addressPrefix === void 0) { addressPrefix = utility_1.defaultAddressPrefix; }
         this.getAddress = function () { return __awaiter(_this, void 0, void 0, function () {
             var compressedPubKey;
             return __generator(this, function (_a) {

package/bin/wallet/wallet.js

@@ -70,7 +70,7 @@ var signdoc_1 = require("@cosmjs/amino/build/signdoc");
  * Wallet is a single account abstraction
  * that can interact with the blockchain
  */
-var Wallet = exports.Wallet = /** @class */ (function () {
+var Wallet = /** @class */ (function () {
     function Wallet() {
         var _this = this;
         /**
@@ -275,14 +275,13 @@ var Wallet = exports.Wallet = /** @class */ (function () {
      * @param {AccountWalletOption} options the account options
      */
     Wallet.createRandom = function (options) { return __awaiter(void 0, void 0, void 0, function () {
-        var publicKey, privateKey, wallet;
-        var _b;
+        var _b, publicKey, privateKey, wallet;
         return __generator(_a, function (_c) {
             switch (_c.label) {
                 case 0: return [4 /*yield*/, (0, utility_1.generateKeyPair)((0, bip39_1.entropyToMnemonic)((0, utility_1.generateEntropy)()), 0)];
                 case 1:
-                    publicKey = (_b = _c.sent(), _b.publicKey), privateKey = _b.privateKey;
-                    wallet = new Wallet();
+                    _b = _c.sent(), publicKey = _b.publicKey, privateKey = _b.privateKey;
+                    wallet = new _a();
                     wallet.signer = new key_1.KeySigner(privateKey, crypto_1.Secp256k1.compressPubkey(publicKey), options === null || options === void 0 ? void 0 : options.addressPrefix);
                     return [2 /*return*/, wallet];
             }
@@ -294,14 +293,13 @@ var Wallet = exports.Wallet = /** @class */ (function () {
      * @param {CreateWalletOptions} options the wallet generation options
      */
     Wallet.fromMnemonic = function (mnemonic, options) { return __awaiter(void 0, void 0, void 0, function () {
-        var publicKey, privateKey, wallet;
-        var _b;
+        var _b, publicKey, privateKey, wallet;
         return __generator(_a, function (_c) {
             switch (_c.label) {
                 case 0: return [4 /*yield*/, (0, utility_1.generateKeyPair)(mnemonic, options === null || options === void 0 ? void 0 : options.accountIndex)];
                 case 1:
-                    publicKey = (_b = _c.sent(), _b.publicKey), privateKey = _b.privateKey;
-                    wallet = new Wallet();
+                    _b = _c.sent(), publicKey = _b.publicKey, privateKey = _b.privateKey;
+                    wallet = new _a();
                     wallet.signer = new key_1.KeySigner(privateKey, crypto_1.Secp256k1.compressPubkey(publicKey), options === null || options === void 0 ? void 0 : options.addressPrefix);
                     return [2 /*return*/, wallet];
             }
@@ -319,7 +317,7 @@ var Wallet = exports.Wallet = /** @class */ (function () {
                 case 0: return [4 /*yield*/, crypto_1.Secp256k1.makeKeypair(privateKey)];
                 case 1:
                     publicKey = (_b.sent()).pubkey;
-                    wallet = new Wallet();
+                    wallet = new _a();
                     wallet.signer = new key_1.KeySigner(privateKey, crypto_1.Secp256k1.compressPubkey(publicKey), options === null || options === void 0 ? void 0 : options.addressPrefix);
                     return [2 /*return*/, wallet];
             }
@@ -332,9 +330,10 @@ var Wallet = exports.Wallet = /** @class */ (function () {
      */
     Wallet.fromLedger = function (connector, options) {
         var _b;
-        var wallet = new Wallet();
+        var wallet = new _a();
         wallet.signer = new ledger_1.LedgerSigner(connector, (_b = options === null || options === void 0 ? void 0 : options.accountIndex) !== null && _b !== void 0 ? _b : 0, options === null || options === void 0 ? void 0 : options.addressPrefix);
         return wallet;
     };
     return Wallet;
 }());
+exports.Wallet = Wallet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnolang/tm2-js-client",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Tendermint2 JS / TS Client",
   "main": "./bin/index.js",
   "repository": {
@@ -33,20 +33,20 @@
     "@typescript-eslint/eslint-plugin": "^5.59.5",
     "@typescript-eslint/parser": "^5.59.5",
     "eslint": "^8.40.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "5.0.0",
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.4",
     "jest-websocket-mock": "^2.4.0",
-    "prettier": "^2.8.8",
+    "prettier": "^3.0.0",
     "ts-jest": "^29.1.0",
     "ts-proto": "^1.147.2",
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "@cosmjs/amino": "^0.30.1",
-    "@cosmjs/crypto": "^0.30.1",
-    "@cosmjs/ledger-amino": "^0.30.1",
+    "@cosmjs/amino": "^0.31.0",
+    "@cosmjs/crypto": "^0.31.0",
+    "@cosmjs/ledger-amino": "^0.31.0",
     "axios": "^1.4.0",
     "long": "^5.2.3",
     "protobufjs": "^7.2.3",