@gnolang/tm2-js-client 1.0.0

package/bin/wallet/wallet.test.js

@@ -0,0 +1,345 @@
+"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 jest_mock_extended_1 = require("jest-mock-extended");
+var wallet_1 = require("./wallet");
+var crypto_1 = require("@cosmjs/crypto");
+var utility_1 = require("./utility");
+var bip39_1 = require("@cosmjs/crypto/build/bip39");
+var key_1 = require("./key");
+var long_1 = __importDefault(require("long"));
+var types_1 = require("./types");
+describe('Wallet', function () {
+    test('createRandom', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var wallet, address;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    expect(wallet).not.toBeNull();
+                    return [4 /*yield*/, wallet.getAddress()];
+                case 2:
+                    address = _a.sent();
+                    expect(address).toHaveLength(40);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('connect', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockProvider, wallet;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    // Connect the provider
+                    wallet.connect(mockProvider);
+                    expect(wallet.getProvider()).toBe(mockProvider);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('fromMnemonic', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mnemonic, wallet, address;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mnemonic = new crypto_1.EnglishMnemonic('lens balcony basic cherry half purchase balance soccer solar scissors process eager orchard fatigue rural retire approve crouch repair prepare develop clarify milk suffer');
+                    return [4 /*yield*/, wallet_1.Wallet.fromMnemonic(mnemonic.toString())];
+                case 1:
+                    wallet = _a.sent();
+                    expect(wallet).not.toBeNull();
+                    return [4 /*yield*/, wallet.getAddress()];
+                case 2:
+                    address = _a.sent();
+                    expect(address).toBe("".concat(utility_1.defaultAddressPrefix, "1vcjvkjdvckprkcpm7l44plrtg83asfu9geaz90"));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('fromPrivateKey', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, publicKey, privateKey, signer, wallet, walletSigner, _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0: return [4 /*yield*/, (0, utility_1.generateKeyPair)((0, bip39_1.entropyToMnemonic)((0, utility_1.generateEntropy)()), 0)];
+                case 1:
+                    _a = _h.sent(), publicKey = _a.publicKey, privateKey = _a.privateKey;
+                    signer = new key_1.KeySigner(privateKey, crypto_1.Secp256k1.compressPubkey(publicKey));
+                    return [4 /*yield*/, wallet_1.Wallet.fromPrivateKey(privateKey)];
+                case 2:
+                    wallet = _h.sent();
+                    walletSigner = wallet.getSigner();
+                    expect(wallet).not.toBeNull();
+                    _c = expect;
+                    return [4 /*yield*/, wallet.getAddress()];
+                case 3:
+                    _d = (_b = _c.apply(void 0, [_h.sent()])).toBe;
+                    return [4 /*yield*/, signer.getAddress()];
+                case 4:
+                    _d.apply(_b, [_h.sent()]);
+                    _f = expect;
+                    return [4 /*yield*/, walletSigner.getPublicKey()];
+                case 5:
+                    _g = (_e = _f.apply(void 0, [_h.sent()])).toEqual;
+                    return [4 /*yield*/, signer.getPublicKey()];
+                case 6:
+                    _g.apply(_e, [_h.sent()]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getAccountSequence', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockSequence, mockProvider, wallet, address, sequence;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockSequence = 5;
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.getAccountSequence.mockResolvedValue(mockSequence);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    wallet.connect(mockProvider);
+                    return [4 /*yield*/, wallet.getAddress()];
+                case 2:
+                    address = _a.sent();
+                    return [4 /*yield*/, wallet.getAccountSequence()];
+                case 3:
+                    sequence = _a.sent();
+                    expect(mockProvider.getAccountSequence).toHaveBeenCalledWith(address, undefined);
+                    expect(sequence).toBe(mockSequence);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getAccountNumber', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockAccountNumber, mockProvider, wallet, address, accountNumber;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockAccountNumber = 10;
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.getAccountNumber.mockResolvedValue(mockAccountNumber);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    wallet.connect(mockProvider);
+                    return [4 /*yield*/, wallet.getAddress()];
+                case 2:
+                    address = _a.sent();
+                    return [4 /*yield*/, wallet.getAccountNumber()];
+                case 3:
+                    accountNumber = _a.sent();
+                    expect(mockProvider.getAccountNumber).toHaveBeenCalledWith(address, undefined);
+                    expect(accountNumber).toBe(mockAccountNumber);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getBalance', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockBalance, mockProvider, wallet, address, balance;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockBalance = 100;
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.getBalance.mockResolvedValue(mockBalance);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    wallet.connect(mockProvider);
+                    return [4 /*yield*/, wallet.getAddress()];
+                case 2:
+                    address = _a.sent();
+                    return [4 /*yield*/, wallet.getBalance()];
+                case 3:
+                    balance = _a.sent();
+                    expect(mockProvider.getBalance).toHaveBeenCalledWith(address, 'ugnot');
+                    expect(balance).toBe(mockBalance);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getGasPrice', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockGasPrice, mockProvider, wallet, gasPrice;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockGasPrice = 1000;
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.getGasPrice.mockResolvedValue(mockGasPrice);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    wallet.connect(mockProvider);
+                    return [4 /*yield*/, wallet.getGasPrice()];
+                case 2:
+                    gasPrice = _a.sent();
+                    expect(mockProvider.getGasPrice).toHaveBeenCalled();
+                    expect(gasPrice).toBe(mockGasPrice);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('estimateGas', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockTxEstimation, mockTx, mockProvider, wallet, estimation;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockTxEstimation = 1000;
+                    mockTx = (0, jest_mock_extended_1.mock)();
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.estimateGas.mockResolvedValue(mockTxEstimation);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    wallet.connect(mockProvider);
+                    return [4 /*yield*/, wallet.estimateGas(mockTx)];
+                case 2:
+                    estimation = _a.sent();
+                    expect(mockProvider.estimateGas).toHaveBeenCalledWith(mockTx);
+                    expect(estimation).toBe(mockTxEstimation);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('signTransaction', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockTx, mockStatus, mockProvider, wallet, emptyDecodeCallback, signedTx, sig;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    mockTx = (0, jest_mock_extended_1.mock)();
+                    mockTx.signatures = [];
+                    mockTx.fee = {
+                        gasFee: '10',
+                        gasWanted: new long_1.default(10),
+                    };
+                    mockTx.messages = [];
+                    mockStatus = (0, jest_mock_extended_1.mock)();
+                    mockStatus.node_info = {
+                        version_set: [],
+                        version: '',
+                        net_address: '',
+                        software: '',
+                        channels: '',
+                        monkier: '',
+                        other: {
+                            tx_index: '',
+                            rpc_address: '',
+                        },
+                        network: 'testchain',
+                    };
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.getStatus.mockResolvedValue(mockStatus);
+                    mockProvider.getAccountNumber.mockResolvedValue(10);
+                    mockProvider.getAccountSequence.mockResolvedValue(10);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _c.sent();
+                    wallet.connect(mockProvider);
+                    emptyDecodeCallback = function (_) {
+                        return [];
+                    };
+                    return [4 /*yield*/, wallet.signTransaction(mockTx, emptyDecodeCallback)];
+                case 2:
+                    signedTx = _c.sent();
+                    expect(mockProvider.getStatus).toHaveBeenCalled();
+                    expect(mockProvider.getAccountNumber).toHaveBeenCalled();
+                    expect(mockProvider.getAccountSequence).toHaveBeenCalled();
+                    expect(signedTx.signatures).toHaveLength(1);
+                    sig = signedTx.signatures[0];
+                    expect((_a = sig.pubKey) === null || _a === void 0 ? void 0 : _a.typeUrl).toBe(types_1.Secp256k1PubKeyType);
+                    expect((_b = sig.pubKey) === null || _b === void 0 ? void 0 : _b.value).not.toBeNull();
+                    expect(sig.signature).not.toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('sendTransaction', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockTx, mockTxHash, mockStatus, mockProvider, wallet, txHash;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockTx = (0, jest_mock_extended_1.mock)();
+                    mockTx.signatures = [];
+                    mockTx.fee = {
+                        gasFee: '10',
+                        gasWanted: new long_1.default(10),
+                    };
+                    mockTx.messages = [];
+                    mockTx.memo = '';
+                    mockTxHash = 'tx hash';
+                    mockStatus = (0, jest_mock_extended_1.mock)();
+                    mockStatus.node_info = {
+                        version_set: [],
+                        version: '',
+                        net_address: '',
+                        software: '',
+                        channels: '',
+                        monkier: '',
+                        other: {
+                            tx_index: '',
+                            rpc_address: '',
+                        },
+                        network: 'testchain',
+                    };
+                    mockProvider = (0, jest_mock_extended_1.mock)();
+                    mockProvider.getStatus.mockResolvedValue(mockStatus);
+                    mockProvider.getAccountNumber.mockResolvedValue(10);
+                    mockProvider.getAccountSequence.mockResolvedValue(10);
+                    mockProvider.sendTransaction.mockResolvedValue(mockTxHash);
+                    return [4 /*yield*/, wallet_1.Wallet.createRandom()];
+                case 1:
+                    wallet = _a.sent();
+                    wallet.connect(mockProvider);
+                    return [4 /*yield*/, wallet.sendTransaction(mockTx)];
+                case 2:
+                    txHash = _a.sent();
+                    expect(txHash).toBe(mockTxHash);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@gnolang/tm2-js-client",
+  "version": "1.0.0",
+  "description": "Tendermint2 JS / TS Client",
+  "main": "./bin/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gnolang/tm2-js-client.git"
+  },
+  "keywords": [
+    "tm2",
+    "tendermint2",
+    "sdk",
+    "client",
+    "js"
+  ],
+  "author": "Milos Zivkovic <milos.zivkovic@tendermint.com>",
+  "license": "Apache-2.0",
+  "homepage": "https://gno.land/",
+  "files": [
+    "bin/**/*"
+  ],
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.1",
+    "@types/long": "^5.0.0",
+    "@types/node": "^20.1.4",
+    "@types/ws": "^8.5.4",
+    "@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",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.4",
+    "jest-websocket-mock": "^2.4.0",
+    "prettier": "^2.8.8",
+    "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",
+    "axios": "^1.4.0",
+    "long": "^5.2.3",
+    "protobufjs": "^7.2.3",
+    "ws": "^8.13.0"
+  },
+  "scripts": {
+    "tsc": "tsc",
+    "lint": "eslint '**/*.ts' --fix",
+    "prettier": "prettier --write .",
+    "build": "yarn tsc",
+    "test": "jest",
+    "prepare": "yarn build",
+    "prepublishOnly": "yarn lint && yarn prettier"
+  }
+}