@gnolang/tm2-js-client 1.0.0

package/bin/provider/jsonrpc/jsonrpc.js

@@ -0,0 +1,219 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCProvider = void 0;
+var services_1 = require("../../services");
+var utility_1 = require("../utility");
+var endpoints_1 = require("../endpoints");
+/**
+ * Provider based on JSON-RPC HTTP requests
+ */
+var JSONRPCProvider = /** @class */ (function () {
+    /**
+     * Creates a new instance of the JSON-RPC Provider
+     * @param {string} baseURL the JSON-RPC URL of the node
+     */
+    function JSONRPCProvider(baseURL) {
+        this.baseURL = baseURL;
+    }
+    JSONRPCProvider.prototype.estimateGas = function (tx) {
+        return Promise.reject('not supported');
+    };
+    JSONRPCProvider.prototype.getBalance = function (address, denomination, height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var abciResponse;
+            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.ABCIEndpoint.ABCI_QUERY, [
+                                "bank/balances/".concat(address),
+                                '',
+                                '0',
+                                false,
+                            ]),
+                        })];
+                    case 1:
+                        abciResponse = _a.sent();
+                        return [2 /*return*/, (0, utility_1.extractBalanceFromResponse)(abciResponse.response.ResponseBase.Data, denomination ? denomination : 'ugnot')];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getBlock = function (height) {
+        return __awaiter(this, void 0, void 0, function () {
+            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.BlockEndpoint.BLOCK, [height.toString()]),
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getBlockResult = function (height) {
+        return __awaiter(this, void 0, void 0, function () {
+            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.BlockEndpoint.BLOCK_RESULTS, [height.toString()]),
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getBlockNumber = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var status;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getStatus()];
+                    case 1:
+                        status = _a.sent();
+                        return [2 /*return*/, parseInt(status.sync_info.latest_block_height)];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getConsensusParams = function (height) {
+        return __awaiter(this, void 0, void 0, function () {
+            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.ConsensusEndpoint.CONSENSUS_PARAMS, [
+                                height.toString(),
+                            ]),
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getGasPrice = function () {
+        return Promise.reject('not supported');
+    };
+    JSONRPCProvider.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            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.ConsensusEndpoint.NET_INFO),
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getAccountSequence = function (address, height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var abciResponse;
+            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.ABCIEndpoint.ABCI_QUERY, [
+                                "auth/accounts/".concat(address),
+                                '',
+                                '0',
+                                false,
+                            ]),
+                        })];
+                    case 1:
+                        abciResponse = _a.sent();
+                        return [2 /*return*/, (0, utility_1.extractSequenceFromResponse)(abciResponse.response.ResponseBase.Data)];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getAccountNumber = function (address, height) {
+        return __awaiter(this, void 0, void 0, function () {
+            var abciResponse;
+            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.ABCIEndpoint.ABCI_QUERY, [
+                                "auth/accounts/".concat(address),
+                                '',
+                                '0',
+                                false,
+                            ]),
+                        })];
+                    case 1:
+                        abciResponse = _a.sent();
+                        return [2 /*return*/, (0, utility_1.extractAccountNumberFromResponse)(abciResponse.response.ResponseBase.Data)];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.getStatus = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            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.CommonEndpoint.STATUS),
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.sendTransaction = function (tx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            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]),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.hash];
+                }
+            });
+        });
+    };
+    JSONRPCProvider.prototype.waitForTransaction = function (hash, fromHeight, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, utility_1.waitForTransaction)(this, hash, fromHeight, timeout)];
+            });
+        });
+    };
+    return JSONRPCProvider;
+}());
+exports.JSONRPCProvider = JSONRPCProvider;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,374 @@
+"use strict";
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var axios_1 = __importDefault(require("axios"));
+var jsonrpc_1 = require("./jsonrpc");
+var utility_1 = require("../utility");
+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");
+jest.mock('axios');
+var mockedAxios = axios_1.default;
+var mockURL = '127.0.0.1:26657';
+describe('JSON-RPC Provider', function () {
+    test('getNetwork', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockInfo, provider, info;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockInfo = (0, jest_mock_extended_1.mock)();
+                    mockInfo.listening = false;
+                    mockedAxios.post.mockResolvedValue({
+                        data: (0, utility_1.newResponse)(mockInfo),
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.getNetwork()];
+                case 1:
+                    info = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(info).toEqual(mockInfo);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getBlock', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockInfo, provider, info;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockInfo = (0, jest_mock_extended_1.mock)();
+                    mockedAxios.post.mockResolvedValue({
+                        data: (0, utility_1.newResponse)(mockInfo),
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.getBlock(0)];
+                case 1:
+                    info = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(info).toEqual(mockInfo);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getBlockResult', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockResult, provider, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockResult = (0, jest_mock_extended_1.mock)();
+                    mockedAxios.post.mockResolvedValue({
+                        data: (0, utility_1.newResponse)(mockResult),
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.getBlockResult(0)];
+                case 1:
+                    result = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(result).toEqual(mockResult);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    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*/];
+            }
+        });
+    }); });
+    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) {
+            switch (_a.label) {
+                case 0:
+                    emptyBlock = (0, jest_mock_extended_1.mock)();
+                    emptyBlock.block.data = {
+                        txs: [],
+                    };
+                    tx = {
+                        messages: [],
+                        signatures: [],
+                        memo: 'tx memo',
+                    };
+                    encodedTx = proto_1.Tx.encode(tx).finish();
+                    txHash = (0, crypto_1.sha256)(encodedTx);
+                    filledBlock = (0, jest_mock_extended_1.mock)();
+                    filledBlock.block.data = {
+                        txs: [(0, utility_1.uint8ArrayToBase64)(encodedTx)],
+                    };
+                    latestBlock = 5;
+                    startBlock = latestBlock - 2;
+                    mockStatus = (0, jest_mock_extended_1.mock)();
+                    mockStatus.sync_info.latest_block_height = "".concat(latestBlock);
+                    responseMap = new Map([
+                        [latestBlock, filledBlock],
+                        [latestBlock - 1, emptyBlock],
+                        [startBlock, emptyBlock],
+                    ]);
+                    mockedAxios.post.mockImplementation(function (url, params, config) {
+                        var request = params;
+                        if (request.method == endpoints_1.CommonEndpoint.STATUS) {
+                            return Promise.resolve({
+                                data: (0, utility_1.newResponse)(mockStatus),
+                            });
+                        }
+                        if (!request.params) {
+                            return Promise.reject('invalid params');
+                        }
+                        var blockNum = +request.params[0];
+                        var info = responseMap.get(blockNum);
+                        return Promise.resolve({
+                            data: (0, utility_1.newResponse)(info),
+                        });
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.waitForTransaction((0, utility_1.uint8ArrayToBase64)(txHash), startBlock)];
+                case 1:
+                    receivedTx = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(receivedTx).toEqual(tx);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getConsensusParams', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockParams, provider, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockParams = (0, jest_mock_extended_1.mock)();
+                    mockParams.block_height = '1';
+                    mockedAxios.post.mockResolvedValue({
+                        data: (0, utility_1.newResponse)(mockParams),
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.getConsensusParams(1)];
+                case 1:
+                    params = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(params).toEqual(mockParams);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getStatus', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStatus, provider, status;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStatus = (0, jest_mock_extended_1.mock)();
+                    mockStatus.validator_info.address = 'address';
+                    mockedAxios.post.mockResolvedValue({
+                        data: (0, utility_1.newResponse)(mockStatus),
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.getStatus()];
+                case 1:
+                    status = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(status).toEqual(mockStatus);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getBlockNumber', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var expectedBlockNumber, mockStatus, provider, blockNumber;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    expectedBlockNumber = 10;
+                    mockStatus = (0, jest_mock_extended_1.mock)();
+                    mockStatus.sync_info.latest_block_height = "".concat(expectedBlockNumber);
+                    mockedAxios.post.mockResolvedValue({
+                        data: (0, utility_1.newResponse)(mockStatus),
+                    });
+                    provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                    return [4 /*yield*/, provider.getBlockNumber()];
+                case 1:
+                    blockNumber = _a.sent();
+                    expect(axios_1.default.post).toHaveBeenCalled();
+                    expect(blockNumber).toEqual(expectedBlockNumber);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    describe('getBalance', function () {
+        var denomination = 'atom';
+        test.each([
+            ['"5gnot,100atom"', 100],
+            ['"5universe"', 0],
+            ['""', 0], // account doesn't exist
+        ])('case %#', function (existing, expected) { return __awaiter(void 0, void 0, void 0, function () {
+            var mockABCIResponse, provider, balance;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockABCIResponse = (0, jest_mock_extended_1.mock)();
+                        mockABCIResponse.response.ResponseBase = {
+                            Log: '',
+                            Info: '',
+                            Data: (0, utility_1.stringToBase64)(existing),
+                            Error: null,
+                            Events: null,
+                        };
+                        mockedAxios.post.mockResolvedValue({
+                            data: (0, utility_1.newResponse)(mockABCIResponse),
+                        });
+                        provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                        return [4 /*yield*/, provider.getBalance('address', denomination)];
+                    case 1:
+                        balance = _a.sent();
+                        expect(axios_1.default.post).toHaveBeenCalled();
+                        expect(balance).toBe(expected);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getSequence', function () {
+        var validAccount = {
+            BaseAccount: {
+                address: 'random address',
+                coins: '',
+                public_key: null,
+                account_number: '0',
+                sequence: '10',
+            },
+        };
+        test.each([
+            [
+                JSON.stringify(validAccount),
+                parseInt(validAccount.BaseAccount.sequence, 10),
+            ],
+            ['null', 0], // account doesn't exist
+        ])('case %#', function (response, expected) { return __awaiter(void 0, void 0, void 0, function () {
+            var mockABCIResponse, provider, sequence;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockABCIResponse = (0, jest_mock_extended_1.mock)();
+                        mockABCIResponse.response.ResponseBase = {
+                            Log: '',
+                            Info: '',
+                            Data: (0, utility_1.stringToBase64)(response),
+                            Error: null,
+                            Events: null,
+                        };
+                        mockedAxios.post.mockResolvedValue({
+                            data: (0, utility_1.newResponse)(mockABCIResponse),
+                        });
+                        provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                        return [4 /*yield*/, provider.getAccountSequence('address')];
+                    case 1:
+                        sequence = _a.sent();
+                        expect(axios_1.default.post).toHaveBeenCalled();
+                        expect(sequence).toBe(expected);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getAccountNumber', function () {
+        var validAccount = {
+            BaseAccount: {
+                address: 'random address',
+                coins: '',
+                public_key: null,
+                account_number: '10',
+                sequence: '0',
+            },
+        };
+        test.each([
+            [
+                JSON.stringify(validAccount),
+                parseInt(validAccount.BaseAccount.account_number, 10),
+            ],
+            ['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;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockABCIResponse = (0, jest_mock_extended_1.mock)();
+                        mockABCIResponse.response.ResponseBase = {
+                            Log: '',
+                            Info: '',
+                            Data: (0, utility_1.stringToBase64)(response),
+                            Error: null,
+                            Events: null,
+                        };
+                        mockedAxios.post.mockResolvedValue({
+                            data: (0, utility_1.newResponse)(mockABCIResponse),
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        provider = new jsonrpc_1.JSONRPCProvider(mockURL);
+                        return [4 /*yield*/, provider.getAccountNumber('address')];
+                    case 2:
+                        accountNumber = _a.sent();
+                        expect(axios_1.default.post).toHaveBeenCalled();
+                        expect(accountNumber).toBe(expected);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        expect(e_1.message).toContain('account is not initialized');
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/bin/provider/provider.d.ts

@@ -0,0 +1,86 @@
+import { BlockInfo, BlockResult, ConsensusParams, NetworkInfo, Status } from './types';
+import { Tx } from '../proto';
+/**
+ * Read-only abstraction for accessing blockchain data
+ */
+export interface Provider {
+    /**
+     * Fetches the denomination balance of the account
+     * @param {string} address the bech32 address of the account
+     * @param {string} [denomination=ugnot] the balance denomination
+     * @param {number} [height=0] the height for querying.
+     * If omitted, the latest height is used
+     */
+    getBalance(address: string, denomination?: string, height?: number): Promise<number>;
+    /**
+     * Fetches the account sequence
+     * @param {string} address the bech32 address of the account
+     * @param {number} [height=0] the height for querying.
+     * If omitted, the latest height is used.
+     */
+    getAccountSequence(address: string, height?: number): Promise<number>;
+    /**
+     * Fetches the account number. Errors out if the account
+     * is not initialized
+     * @param {string} address the bech32 address of the account
+     * @param {number} [height=0] the height for querying.
+     * If omitted, the latest height is used
+     */
+    getAccountNumber(address: string, height?: number): Promise<number>;
+    /**
+     * Fetches the block at the specific height, if any
+     * @param {number} height the height for querying
+     */
+    getBlock(height: number): Promise<BlockInfo>;
+    /**
+     * Fetches the block at the specific height, if any
+     * @param {number} height the height for querying
+     */
+    getBlockResult(height: number): Promise<BlockResult>;
+    /**
+     * Fetches the latest block number from the chain
+     */
+    getBlockNumber(): Promise<number>;
+    /**
+     * Fetches the network information
+     */
+    getNetwork(): Promise<NetworkInfo>;
+    /**
+     * Fetches the consensus params for the specific block height
+     * @param {number} height the height for querying
+     */
+    getConsensusParams(height: number): Promise<ConsensusParams>;
+    /**
+     * Fetches the current node status
+     */
+    getStatus(): Promise<Status>;
+    /**
+     * Fetches the current (recommended) average gas price
+     */
+    getGasPrice(): Promise<number>;
+    /**
+     * Estimates the gas limit for the transaction
+     * @param {Tx} tx the transaction that needs estimating
+     */
+    estimateGas(tx: Tx): Promise<number>;
+    /**
+     * Sends the transaction to the node for committing.
+     * The transaction needs to be signed beforehand.
+     * Returns the transaction hash
+     * @param {string} tx the base64-encoded signed transaction
+     */
+    sendTransaction(tx: string): Promise<string>;
+    /**
+     * Waits for the transaction to be committed on the chain.
+     * NOTE: This method will not take in the fromHeight parameter once
+     * proper transaction indexing is added - the implementation should
+     * simply try to fetch the transaction first to see if it's included in a block
+     * before starting to wait for it; Until then, this method should be used
+     * in the sequence:
+     * get latest block -> send transaction -> waitForTransaction(block before send)
+     * @param {string} hash The transaction hash
+     * @param {number} [fromHeight=latest] The block height used to begin the search
+     * @param {number} [timeout=15000] Optional wait timeout in MS
+     */
+    waitForTransaction(hash: string, fromHeight?: number, timeout?: number): Promise<Tx>;
+}