@gnolang/tm2-js-client 1.0.0

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

@@ -0,0 +1,535 @@
+"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 utility_1 = require("../utility");
+var ws_1 = require("./ws");
+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");
+describe('WS Provider', function () {
+    var wsPort = 8545;
+    var wsHost = 'localhost';
+    var wsURL = "ws://".concat(wsHost, ":").concat(wsPort);
+    var server;
+    var wsProvider;
+    var mockABCIResponse = function (response) {
+        return {
+            response: {
+                ResponseBase: {
+                    Log: '',
+                    Info: '',
+                    Data: (0, utility_1.stringToBase64)(response),
+                    Error: null,
+                    Events: null,
+                },
+                Key: null,
+                Value: null,
+                Proof: null,
+                Height: '',
+            },
+        };
+    };
+    /**
+     * Sets up the test response handler (single-response)
+     * @param {WebSocketServer} wss the websocket server returning data
+     * @param {Type} testData the test data being returned to the client
+     */
+    var setHandler = function (testData) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    server.on('connection', function (socket) {
+                        socket.on('message', function (data) {
+                            var request = JSON.parse(data.toString());
+                            var response = (0, utility_1.newResponse)(testData);
+                            response.id = request.id;
+                            socket.send(JSON.stringify(response));
+                        });
+                    });
+                    return [4 /*yield*/, server.connected];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    beforeEach(function () {
+        server = new jest_websocket_mock_1.default(wsURL);
+        wsProvider = new ws_1.WSProvider(wsURL);
+    });
+    afterEach(function () {
+        wsProvider.closeConnection();
+        jest_websocket_mock_1.default.clean();
+    });
+    test('getNetwork', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockInfo, info;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockInfo = {
+                        listening: false,
+                        listeners: [],
+                        n_peers: '0',
+                        peers: [],
+                    };
+                    // Set the response
+                    return [4 /*yield*/, setHandler(mockInfo)];
+                case 1:
+                    // Set the response
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.getNetwork()];
+                case 2:
+                    info = _a.sent();
+                    expect(info).toEqual(mockInfo);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    var getEmptyStatus = function () {
+        return {
+            node_info: {
+                version_set: [],
+                net_address: '',
+                network: '',
+                software: '',
+                version: '',
+                channels: '',
+                monkier: '',
+                other: {
+                    tx_index: '',
+                    rpc_address: '',
+                },
+            },
+            sync_info: {
+                latest_block_hash: '',
+                latest_app_hash: '',
+                latest_block_height: '',
+                latest_block_time: '',
+                catching_up: false,
+            },
+            validator_info: {
+                address: '',
+                pub_key: {
+                    type: '',
+                    value: '',
+                },
+                voting_power: '',
+            },
+        };
+    };
+    test('getStatus', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockStatus, status;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockStatus = getEmptyStatus();
+                    mockStatus.validator_info.address = 'address';
+                    // Set the response
+                    return [4 /*yield*/, setHandler(mockStatus)];
+                case 1:
+                    // Set the response
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.getStatus()];
+                case 2:
+                    status = _a.sent();
+                    expect(status).toEqual(status);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('getConsensusParams', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockParams, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockParams = {
+                        block_height: '',
+                        consensus_params: {
+                            Block: {
+                                MaxTxBytes: '',
+                                MaxDataBytes: '',
+                                MaxBlockBytes: '',
+                                MaxGas: '',
+                                TimeIotaMS: '',
+                            },
+                            Validator: {
+                                PubKeyTypeURLs: [],
+                            },
+                        },
+                    };
+                    // Set the response
+                    return [4 /*yield*/, setHandler(mockParams)];
+                case 1:
+                    // Set the response
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.getConsensusParams(1)];
+                case 2:
+                    params = _a.sent();
+                    expect(params).toEqual(mockParams);
+                    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 mockResponse, sequence;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockResponse = mockABCIResponse(response);
+                        // Set the response
+                        return [4 /*yield*/, setHandler(mockResponse)];
+                    case 1:
+                        // Set the response
+                        _a.sent();
+                        return [4 /*yield*/, wsProvider.getAccountSequence('address')];
+                    case 2:
+                        sequence = _a.sent();
+                        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 mockResponse, accountNumber, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockResponse = mockABCIResponse(response);
+                        // Set the response
+                        return [4 /*yield*/, setHandler(mockResponse)];
+                    case 1:
+                        // Set the response
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, wsProvider.getAccountNumber('address')];
+                    case 3:
+                        accountNumber = _a.sent();
+                        expect(accountNumber).toBe(expected);
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_1 = _a.sent();
+                        expect(e_1.message).toContain('account is not initialized');
+                        return [3 /*break*/, 5];
+                    case 5: 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 mockResponse, balance;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mockResponse = mockABCIResponse(existing);
+                        // Set the response
+                        return [4 /*yield*/, setHandler(mockResponse)];
+                    case 1:
+                        // Set the response
+                        _a.sent();
+                        return [4 /*yield*/, wsProvider.getBalance('address', denomination)];
+                    case 2:
+                        balance = _a.sent();
+                        expect(balance).toBe(expected);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    test('getBlockNumber', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var expectedBlockNumber, mockStatus, blockNumber;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    expectedBlockNumber = 10;
+                    mockStatus = getEmptyStatus();
+                    mockStatus.sync_info.latest_block_height = "".concat(expectedBlockNumber);
+                    // Set the response
+                    return [4 /*yield*/, setHandler(mockStatus)];
+                case 1:
+                    // Set the response
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.getBlockNumber()];
+                case 2:
+                    blockNumber = _a.sent();
+                    expect(blockNumber).toBe(expectedBlockNumber);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    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*/];
+            }
+        });
+    }); });
+    var getEmptyBlockInfo = function () {
+        var emptyHeader = {
+            version: '',
+            chain_id: '',
+            height: '',
+            time: '',
+            num_txs: '',
+            total_txs: '',
+            app_version: '',
+            last_block_id: {
+                hash: null,
+                parts: {
+                    total: '',
+                    hash: null,
+                },
+            },
+            last_commit_hash: '',
+            data_hash: '',
+            validators_hash: '',
+            consensus_hash: '',
+            app_hash: '',
+            last_results_hash: '',
+            proposer_address: '',
+        };
+        var emptyBlockID = {
+            hash: null,
+            parts: {
+                total: '',
+                hash: null,
+            },
+        };
+        return {
+            block_meta: {
+                block_id: emptyBlockID,
+                header: emptyHeader,
+            },
+            block: {
+                header: emptyHeader,
+                data: {
+                    txs: null,
+                },
+                last_commit: {
+                    block_id: emptyBlockID,
+                    precommits: null,
+                },
+            },
+        };
+    };
+    test('getBlock', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockInfo, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockInfo = getEmptyBlockInfo();
+                    // Set the response
+                    return [4 /*yield*/, setHandler(mockInfo)];
+                case 1:
+                    // Set the response
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.getBlock(0)];
+                case 2:
+                    result = _a.sent();
+                    expect(result).toEqual(mockInfo);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    var getEmptyBlockResult = function () {
+        var emptyResponseBase = {
+            Error: null,
+            Data: null,
+            Events: null,
+            Log: '',
+            Info: '',
+        };
+        var emptyEndBlock = {
+            ResponseBase: emptyResponseBase,
+            ValidatorUpdates: null,
+            ConsensusParams: null,
+            Events: null,
+        };
+        var emptyStartBlock = {
+            ResponseBase: emptyResponseBase,
+        };
+        return {
+            height: '',
+            results: {
+                deliver_tx: null,
+                end_block: emptyEndBlock,
+                begin_block: emptyStartBlock,
+            },
+        };
+    };
+    test('getBlockResult', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mockResult, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mockResult = getEmptyBlockResult();
+                    // Set the response
+                    return [4 /*yield*/, setHandler(mockResult)];
+                case 1:
+                    // Set the response
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.getBlockResult(0)];
+                case 2:
+                    result = _a.sent();
+                    expect(result).toEqual(mockResult);
+                    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, receivedTx;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    emptyBlock = getEmptyBlockInfo();
+                    emptyBlock.block.data = {
+                        txs: [],
+                    };
+                    tx = {
+                        messages: [],
+                        signatures: [],
+                        memo: 'tx memo',
+                    };
+                    encodedTx = proto_1.Tx.encode(tx).finish();
+                    txHash = (0, crypto_1.sha256)(encodedTx);
+                    filledBlock = getEmptyBlockInfo();
+                    filledBlock.block.data = {
+                        txs: [(0, utility_1.uint8ArrayToBase64)(encodedTx)],
+                    };
+                    latestBlock = 5;
+                    startBlock = latestBlock - 2;
+                    mockStatus = getEmptyStatus();
+                    mockStatus.sync_info.latest_block_height = "".concat(latestBlock);
+                    responseMap = new Map([
+                        [latestBlock, filledBlock],
+                        [latestBlock - 1, emptyBlock],
+                        [startBlock, emptyBlock],
+                    ]);
+                    // Set the response
+                    server.on('connection', function (socket) {
+                        socket.on('message', function (data) {
+                            var request = JSON.parse(data.toString());
+                            if (request.method == endpoints_1.CommonEndpoint.STATUS) {
+                                var response_1 = (0, utility_1.newResponse)(mockStatus);
+                                response_1.id = request.id;
+                                socket.send(JSON.stringify(response_1));
+                                return;
+                            }
+                            if (!request.params) {
+                                return;
+                            }
+                            var blockNum = +request.params[0];
+                            var info = responseMap.get(blockNum);
+                            var response = (0, utility_1.newResponse)(info);
+                            response.id = request.id;
+                            socket.send(JSON.stringify(response));
+                        });
+                    });
+                    return [4 /*yield*/, server.connected];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, wsProvider.waitForTransaction((0, utility_1.uint8ArrayToBase64)(txHash), startBlock)];
+                case 2:
+                    receivedTx = _a.sent();
+                    expect(receivedTx).toEqual(tx);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/bin/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rest/restService';
+export * from './rest/restService.types';

package/bin/services/index.js

@@ -0,0 +1,18 @@
+"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("./rest/restService"), exports);
+__exportStar(require("./rest/restService.types"), exports);

package/bin/services/rest/restService.d.ts

@@ -0,0 +1,4 @@
+import { RequestParams } from './restService.types';
+export declare class RestService {
+    static post<TResult>(baseURL: string, params: RequestParams): Promise<TResult>;
+}

package/bin/services/rest/restService.js

@@ -0,0 +1,72 @@
+"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 });
+exports.RestService = void 0;
+var axios_1 = __importDefault(require("axios"));
+var RestService = /** @class */ (function () {
+    function RestService() {
+    }
+    RestService.post = function (baseURL, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var axiosResponse, _a, result, error;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, axios_1.default.post(baseURL, params.request, params.config)];
+                    case 1:
+                        axiosResponse = _b.sent();
+                        _a = axiosResponse.data, result = _a.result, error = _a.error;
+                        // Check for errors
+                        if (error) {
+                            // Error encountered during the POST request
+                            throw new Error("".concat(error.message, ": ").concat(error.data));
+                        }
+                        // Check for the correct result format
+                        if (!result) {
+                            throw new Error('invalid result returned');
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    return RestService;
+}());
+exports.RestService = RestService;

package/bin/services/rest/restService.types.d.ts

@@ -0,0 +1,6 @@
+import { AxiosRequestConfig } from 'axios';
+import { RPCRequest } from '../../provider';
+export interface RequestParams {
+    request: RPCRequest;
+    config?: AxiosRequestConfig;
+}

package/bin/services/rest/restService.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/wallet/index.d.ts

@@ -0,0 +1,5 @@
+export * from './key';
+export * from './ledger';
+export * from './types';
+export * from './utility';
+export * from './wallet';

package/bin/wallet/index.js

@@ -0,0 +1,21 @@
+"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("./key"), exports);
+__exportStar(require("./ledger"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utility"), exports);
+__exportStar(require("./wallet"), exports);

package/bin/wallet/key/index.d.ts

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