@xelis/sdk 0.9.11 → 0.10.1

package/dist/esm/{lib → rpc}/websocket.js

@@ -36,26 +36,26 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import WebSocket from 'isomorphic-ws';
 import { to } from 'await-to-js';
-import { parseData } from './parse_data.js';
-var WS = /** @class */ (function () {
-    function WS(options) {
+import { parseJSON } from './parse_json/parse_json.js';
+var WSRPC = /** @class */ (function () {
+    function WSRPC(options) {
         this.connectionTries = 0;
         this.methodIdIncrement = 0;
         this.endpoint = "";
         this.timeout = 15000; // default to 15s
-        this.events = {};
+        this.events = new Map();
         this.unsubscribeSuspense = 1000;
         this.maxConnectionTries = 3;
         this.reconnectOnConnectionLoss = true;
         this.options = options;
     }
-    WS.prototype.connect = function (endpoint) {
+    WSRPC.prototype.connect = function (endpoint) {
         var _this = this;
         // force disconnect if already connected
         if (this.socket && this.socket.readyState === WebSocket.OPEN) {
             this.socket.close();
         }
-        this.events = {};
+        this.events = new Map();
         this.connectionTries = 0;
         return new Promise(function (resolve, reject) {
             _this.socket = new WebSocket(endpoint, _this.options);
@@ -77,7 +77,7 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.tryReconnect = function () {
+    WSRPC.prototype.tryReconnect = function () {
         var _this = this;
         this.connectionTries++;
         if (this.connectionTries > this.maxConnectionTries) {
@@ -91,26 +91,29 @@ var WS = /** @class */ (function () {
             _this.tryReconnect();
         });
     };
-    WS.prototype.close = function () {
+    WSRPC.prototype.close = function () {
         if (!this.socket)
             return;
         this.socket.close();
     };
-    WS.prototype.clearEvent = function (event) {
+    WSRPC.prototype.clearEvent = function (event) {
         var _this = this;
-        this.events[event].listeners.forEach(function (listener) {
-            _this.socket && _this.socket.removeEventListener("message", listener);
-        });
-        Reflect.deleteProperty(this.events, event);
+        var eventData = this.events.get(event);
+        if (eventData) {
+            eventData.listeners.forEach(function (listener) {
+                _this.socket && _this.socket.removeEventListener("message", listener);
+            });
+            this.events["delete"](event);
+        }
     };
-    WS.prototype.closeAllListens = function (event) {
+    WSRPC.prototype.closeAllListens = function (event) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, err, _;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if (!this.events[event]) return [3 /*break*/, 2];
-                        return [4 /*yield*/, to(this.call("unsubscribe", { notify: event }))];
+                        if (!this.events.has(event)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, to(this.dataCall("unsubscribe", { notify: event }))];
                     case 1:
                         _a = _b.sent(), err = _a[0], _ = _a[1];
                         if (err)
@@ -122,59 +125,56 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.listenEvent = function (event, onData) {
+    WSRPC.prototype.listenEvent = function (event, onData) {
         return __awaiter(this, void 0, void 0, function () {
-            var onMessage, unsubscribeTimeoutId, _a, err, res, closeListen;
+            var onMessage, eventData, idRefObject, _a, err, _, closeListen;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         onMessage = function (msgEvent) {
-                            if (_this.events[event]) {
-                                var id = _this.events[event].id;
-                                if (typeof msgEvent.data === "string") {
-                                    try {
-                                        var data = parseData(msgEvent.data);
-                                        if (data.id === id) {
-                                            if (data.error) {
-                                                onData(msgEvent, undefined, new Error(data.error.message));
-                                            }
-                                            else {
-                                                onData(msgEvent, data.result, undefined);
-                                            }
+                            var eventData = _this.events.get(event);
+                            if (eventData && typeof msgEvent.data === "string") {
+                                try {
+                                    var data = parseJSON(msgEvent.data);
+                                    if (data.id === eventData.id) {
+                                        if (data.error) {
+                                            onData(msgEvent, undefined, new Error(data.error.message));
+                                        }
+                                        else {
+                                            onData(msgEvent, data.result, undefined);
                                         }
                                     }
-                                    catch (_a) {
-                                        // can't parse json -- do nothing
-                                    }
+                                }
+                                catch (_a) {
+                                    // can't parse json -- do nothing
                                 }
                             }
                         };
-                        if (!this.events[event]) return [3 /*break*/, 1];
-                        unsubscribeTimeoutId = this.events[event].unsubscribeTimeoutId;
-                        if (unsubscribeTimeoutId) {
+                        eventData = this.events.get(event);
+                        if (!eventData) return [3 /*break*/, 1];
+                        if (eventData.unsubscribeTimeoutId) {
                             // clear timeout to unsubscribe 
                             // because we got a new registered event and want to cancel the pending unsubscribe grace period
-                            clearTimeout(unsubscribeTimeoutId);
+                            clearTimeout(eventData.unsubscribeTimeoutId);
                         }
-                        this.events[event].listeners.push(onMessage);
+                        eventData.listeners.push(onMessage);
                         return [3 /*break*/, 3];
                     case 1:
-                        // important if multiple listenEvent are called without await at least we store listener before getting id
-                        this.events[event] = { listeners: [onMessage] };
-                        return [4 /*yield*/, to(this.call("subscribe", { notify: event }))];
+                        idRefObject = {};
+                        return [4 /*yield*/, to(this.dataCall("subscribe", { notify: event }, idRefObject))];
                     case 2:
-                        _a = _b.sent(), err = _a[0], res = _a[1];
+                        _a = _b.sent(), err = _a[0], _ = _a[1];
                         if (err) {
                             this.clearEvent(event);
                             return [2 /*return*/, Promise.reject(err)];
                         }
-                        this.events[event].id = res.id;
+                        this.events.set(event, { listeners: [onMessage], id: idRefObject.id });
                         _b.label = 3;
                     case 3:
                         this.socket && this.socket.addEventListener("message", onMessage);
                         closeListen = function () {
-                            var eventData = _this.events[event];
+                            var eventData = _this.events.get(event);
                             if (eventData) {
                                 var listeners = eventData.listeners;
                                 for (var i = 0; i < listeners.length; i++) {
@@ -187,17 +187,17 @@ var WS = /** @class */ (function () {
                                 if (listeners.length === 0) {
                                     if (_this.socket && _this.socket.readyState === WebSocket.OPEN) {
                                         // we use a grace period to unsubscribe (mostly because of react useEffect and avoid unecessary subscribe)
-                                        _this.events[event].unsubscribeTimeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                                        eventData.unsubscribeTimeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
                                             return __generator(this, function (_a) {
-                                                this.call("unsubscribe", { notify: event });
-                                                Reflect.deleteProperty(this.events, event);
+                                                this.dataCall("unsubscribe", { notify: event });
+                                                this.events["delete"](event);
                                                 return [2 /*return*/];
                                             });
                                         }); }, _this.unsubscribeSuspense);
                                     }
                                     else {
                                         // socket is closed so we don't send unsubscribe and no grace period delete right away
-                                        Reflect.deleteProperty(_this.events, event);
+                                        _this.events["delete"](event);
                                     }
                                 }
                             }
@@ -209,70 +209,110 @@ var WS = /** @class */ (function () {
             });
         });
     };
-    WS.prototype.call = function (method, params, overwriteData) {
+    WSRPC.prototype.batchCall = function (requests) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var id, data, _a, err, res, items;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        id = this.methodIdIncrement++;
+                        requests.forEach(function (request) {
+                            request.id = id;
+                            request.jsonrpc = "2.0";
+                        });
+                        data = JSON.stringify(requests);
+                        return [4 /*yield*/, to(this.rawCall(id, data))];
+                    case 1:
+                        _a = _b.sent(), err = _a[0], res = _a[1];
+                        if (err)
+                            return [2 /*return*/, reject(err)];
+                        items = [];
+                        res.forEach(function (v) {
+                            if (v.error) {
+                                items.push(new Error(v.error.message));
+                            }
+                            else {
+                                items.push(v.result);
+                            }
+                        });
+                        return [2 /*return*/, resolve(items)];
+                }
+            });
+        }); });
+    };
+    WSRPC.prototype.rawCall = function (id, body) {
         var _this = this;
         return new Promise(function (resolve, reject) {
             if (!_this.socket)
                 return reject(new Error("Socket is not initialized."));
             if (_this.socket.readyState !== WebSocket.OPEN)
                 return reject(new Error("Can't send msg. Socket is not opened."));
-            var requestMethod = _this.createRequestMethod(method, params);
-            // for XSWD we want to send the application data without request method wrapping
-            if (overwriteData) {
-                requestMethod.id = null;
-                requestMethod.data = overwriteData;
-            }
             var timeoutId = null;
             var onMessage = function (msgEvent) {
                 if (typeof msgEvent.data === "string") {
-                    var data = parseData(msgEvent.data);
-                    if (data.id === requestMethod.id) {
+                    var data = parseJSON(msgEvent.data);
+                    console.log(data);
+                    var valid = false;
+                    if (Array.isArray(data) && data.length > 0 && data[0].id === id) {
+                        //@ts-ignore
+                        resolve(data);
+                        valid = true;
+                    }
+                    else if (data.id === id) {
+                        resolve(data);
+                        valid = true;
+                    }
+                    else if (data.id === null && id === 0) {
+                        // special case with xswd sending first call will return null id
+                        resolve(data);
+                        valid = true;
+                    }
+                    if (valid) {
                         clearTimeout(timeoutId);
                         _this.socket && _this.socket.removeEventListener("message", onMessage);
-                        if (data.error)
-                            return reject(new Error(data.error.message));
-                        else
-                            resolve(data);
                     }
                 }
             };
-            // make sure you listen before sending data
-            _this.socket && _this.socket.addEventListener("message", onMessage); // we don't use { once: true } option because of timeout feature
+            _this.socket.addEventListener("message", onMessage);
             if (_this.timeout > 0) {
                 timeoutId = setTimeout(function () {
                     _this.socket && _this.socket.removeEventListener("message", onMessage);
                     reject(new Error("timeout"));
                 }, _this.timeout);
             }
-            if (_this.socket && _this.socket.readyState === WebSocket.OPEN) {
-                _this.socket.send(requestMethod.data);
+            if (_this.socket.readyState === WebSocket.OPEN) {
+                _this.socket.send(body);
             }
         });
     };
-    WS.prototype.dataCall = function (method, params) {
+    WSRPC.prototype.dataCall = function (method, params, idRefObj) {
         var _this = this;
         return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-            var _a, err, res;
+            var id, request, data, _a, err, res;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, to(this.call(method, params))];
+                    case 0:
+                        id = this.methodIdIncrement++;
+                        if (idRefObj)
+                            idRefObj.id = id;
+                        request = { id: id, jsonrpc: "2.0", method: method };
+                        if (params)
+                            request.params = params;
+                        data = JSON.stringify(request);
+                        return [4 /*yield*/, to(this.rawCall(id, data))];
                     case 1:
                         _a = _b.sent(), err = _a[0], res = _a[1];
                         if (err)
                             return [2 /*return*/, reject(err)];
+                        if (res.error) {
+                            return [2 /*return*/, reject(res.error.message)];
+                        }
                         return [2 /*return*/, resolve(res.result)];
                 }
             });
         }); });
     };
-    WS.prototype.createRequestMethod = function (method, params) {
-        var id = this.methodIdIncrement++;
-        var request = { id: id, jsonrpc: "2.0", method: method };
-        if (params)
-            request.params = params;
-        var data = JSON.stringify(request);
-        return { data: data, id: id };
-    };
-    return WS;
+    return WSRPC;
 }());
-export { WS };
+export { WSRPC };

package/dist/esm/wallet/rpc.js

@@ -13,122 +13,133 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-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 };
-    }
-};
 import { Base64 } from 'js-base64';
 import { RPCMethod } from './types.js';
-import { RPC as BaseRPC } from '../lib/rpc.js';
+import { HttpRPC } from '../rpc/http.js';
 var RPC = /** @class */ (function (_super) {
     __extends(RPC, _super);
     function RPC(endpoint, username, password) {
         var _this = _super.call(this, endpoint) || this;
         var authValue = Base64.encode("".concat(username, ":").concat(password));
-        _this.auth = "Basic ".concat(authValue);
+        _this.headers.set("Authorization", "Basic ".concat(authValue));
         return _this;
     }
-    RPC.prototype.post = function (method, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var headers;
-            return __generator(this, function (_a) {
-                headers = new Headers();
-                headers.set("Authorization", this.auth);
-                return [2 /*return*/, _super.prototype.post.call(this, method, params, headers)];
-            });
-        });
-    };
     RPC.prototype.getVersion = function () {
-        return this.post(RPCMethod.GetVersion);
+        return this.request(RPCMethod.GetVersion);
     };
     RPC.prototype.getNetwork = function () {
-        return this.post(RPCMethod.GetNetwork);
+        return this.request(RPCMethod.GetNetwork);
     };
     RPC.prototype.getNonce = function () {
-        return this.post(RPCMethod.GetNonce);
+        return this.request(RPCMethod.GetNonce);
     };
     RPC.prototype.getTopoheight = function () {
-        return this.post(RPCMethod.GetTopoheight);
+        return this.request(RPCMethod.GetTopoheight);
     };
     RPC.prototype.getAddress = function (params) {
         if (params === void 0) { params = {}; }
-        return this.post(RPCMethod.GetAddress, params);
+        return this.request(RPCMethod.GetAddress, params);
     };
     RPC.prototype.splitAddress = function (params) {
-        return this.post(RPCMethod.SplitAddress, params);
+        return this.request(RPCMethod.SplitAddress, params);
     };
     RPC.prototype.rescan = function (params) {
-        return this.post(RPCMethod.Rescan, params);
+        return this.request(RPCMethod.Rescan, params);
     };
     RPC.prototype.getBalance = function (asset) {
-        return this.post(RPCMethod.GetBalance, { asset: asset });
+        return this.request(RPCMethod.GetBalance, { asset: asset });
     };
     RPC.prototype.hasBalance = function (asset) {
-        return this.post(RPCMethod.HasBalance, { asset: asset });
+        return this.request(RPCMethod.HasBalance, { asset: asset });
     };
     RPC.prototype.getTrackedAssets = function () {
-        return this.post(RPCMethod.GetTrackedAssets);
+        return this.request(RPCMethod.GetTrackedAssets);
     };
     RPC.prototype.getAssetPrecision = function (params) {
-        return this.post(RPCMethod.GetAssetPrecision, params);
+        return this.request(RPCMethod.GetAssetPrecision, params);
+    };
+    RPC.prototype.getAssets = function () {
+        return this.request(RPCMethod.GetAssets);
+    };
+    RPC.prototype.getAsset = function (params) {
+        return this.request(RPCMethod.GetAsset, params);
     };
     RPC.prototype.getTransaction = function (hash) {
-        return this.post(RPCMethod.GetTransaction, { hash: hash });
+        return this.request(RPCMethod.GetTransaction, { hash: hash });
     };
     RPC.prototype.buildTransaction = function (params) {
-        return this.post(RPCMethod.BuildTransaction, params);
+        return this.request(RPCMethod.BuildTransaction, params);
+    };
+    RPC.prototype.buildTransactionOffline = function (params) {
+        return this.request(RPCMethod.BuildTransactionOffline, params);
+    };
+    RPC.prototype.buildUnsignedTransaction = function (params) {
+        return this.request(RPCMethod.BuildUnsignedTransaction, params);
+    };
+    RPC.prototype.signUnsignedTransaction = function (params) {
+        return this.request(RPCMethod.SignUnsignedTransaction, params);
+    };
+    RPC.prototype.finalizeUnsignedTransaction = function (params) {
+        return this.request(RPCMethod.FinalizeUnsignedTransaction, params);
+    };
+    RPC.prototype.clearTxCache = function () {
+        return this.request(RPCMethod.ClearTxCache);
     };
     RPC.prototype.listTransactions = function (params) {
-        return this.post(RPCMethod.ListTransactions, params);
+        return this.request(RPCMethod.ListTransactions, params);
     };
     RPC.prototype.isOnline = function () {
-        return this.post(RPCMethod.IsOnline);
+        return this.request(RPCMethod.IsOnline);
+    };
+    RPC.prototype.setOnlineMode = function (params) {
+        return this.request(RPCMethod.SetOnlineMode, params);
+    };
+    RPC.prototype.setOfflineMode = function () {
+        return this.request(RPCMethod.SetOfflineMode);
     };
     RPC.prototype.signData = function (data) {
-        return this.post(RPCMethod.SignData, data);
+        return this.request(RPCMethod.SignData, data.toObject());
     };
     RPC.prototype.estimateFees = function (params) {
-        return this.post(RPCMethod.EstimateFees, params);
+        return this.request(RPCMethod.EstimateFees, params);
     };
-    RPC.prototype.setOnlineMode = function (params) {
-        return this.post(RPCMethod.SetOnlineMode, params);
+    RPC.prototype.estimateExtraDataSize = function (params) {
+        return this.request(RPCMethod.EstimateExtraDataSize, params);
     };
-    RPC.prototype.setOfflineMode = function () {
-        return this.post(RPCMethod.SetOfflineMode);
+    RPC.prototype.networkInfo = function () {
+        return this.request(RPCMethod.NetworkInfo);
+    };
+    RPC.prototype.decryptExtraData = function (params) {
+        return this.request(RPCMethod.DecryptExtraData, params);
+    };
+    RPC.prototype.decryptCiphertext = function (params) {
+        return this.request(RPCMethod.DecryptCiphertext, params);
+    };
+    RPC.prototype.getMatchingKeys = function (params) {
+        return this.request(RPCMethod.GetMatchingKeys, params);
+    };
+    RPC.prototype.countMatchingEntries = function (params) {
+        return this.request(RPCMethod.CountMatchingEntries, params);
+    };
+    RPC.prototype.getValueFromKey = function (params) {
+        return this.request(RPCMethod.GetValueFromKey, params);
+    };
+    RPC.prototype.store = function (params) {
+        return this.request(RPCMethod.Store, params);
+    };
+    RPC.prototype["delete"] = function (params) {
+        return this.request(RPCMethod.Delete, params);
+    };
+    RPC.prototype.deleteTreeEntries = function (tree) {
+        return this.request(RPCMethod.DeleteTreeEntries, { tree: tree });
+    };
+    RPC.prototype.hasKey = function (params) {
+        return this.request(RPCMethod.HasKey, params);
+    };
+    RPC.prototype.queryDB = function (params) {
+        return this.request(RPCMethod.QueryDB, params);
     };
     return RPC;
-}(BaseRPC));
+}(HttpRPC));
 export { RPC };
 export default RPC;

package/dist/esm/wallet/types.js

@@ -1,3 +1,26 @@
+export var TxRole;
+(function (TxRole) {
+    TxRole["Sender"] = "sender";
+    TxRole["Receiver"] = "receiver";
+})(TxRole || (TxRole = {}));
+export var ValueType;
+(function (ValueType) {
+    ValueType[ValueType["Bool"] = 0] = "Bool";
+    ValueType[ValueType["String"] = 1] = "String";
+    ValueType[ValueType["U8"] = 2] = "U8";
+    ValueType[ValueType["U16"] = 3] = "U16";
+    ValueType[ValueType["U32"] = 4] = "U32";
+    ValueType[ValueType["U64"] = 5] = "U64";
+    ValueType[ValueType["U128"] = 6] = "U128";
+    ValueType[ValueType["Hash"] = 7] = "Hash";
+    ValueType[ValueType["Blob"] = 8] = "Blob";
+})(ValueType || (ValueType = {}));
+export var ElementType;
+(function (ElementType) {
+    ElementType[ElementType["Value"] = 0] = "Value";
+    ElementType[ElementType["Array"] = 1] = "Array";
+    ElementType[ElementType["Fields"] = 2] = "Fields";
+})(ElementType || (ElementType = {}));
 export var RPCMethod;
 (function (RPCMethod) {
     RPCMethod["GetVersion"] = "get_version";
@@ -11,14 +34,33 @@ export var RPCMethod;
     RPCMethod["HasBalance"] = "has_balance";
     RPCMethod["GetTrackedAssets"] = "get_tracked_assets";
     RPCMethod["GetAssetPrecision"] = "get_asset_precision";
+    RPCMethod["GetAssets"] = "get_assets";
+    RPCMethod["GetAsset"] = "get_asset";
     RPCMethod["GetTransaction"] = "get_transaction";
     RPCMethod["BuildTransaction"] = "build_transaction";
+    RPCMethod["BuildTransactionOffline"] = "build_transaction_offline";
+    RPCMethod["BuildUnsignedTransaction"] = "build_unsigned_transaction";
+    RPCMethod["SignUnsignedTransaction"] = "sign_unsigned_transaction";
+    RPCMethod["FinalizeUnsignedTransaction"] = "finalize_unsigned_transaction";
+    RPCMethod["ClearTxCache"] = "clear_tx_cache";
     RPCMethod["ListTransactions"] = "list_transactions";
     RPCMethod["IsOnline"] = "is_online";
     RPCMethod["SetOnlineMode"] = "set_online_mode";
     RPCMethod["SetOfflineMode"] = "set_offline_mode";
     RPCMethod["SignData"] = "sign_data";
     RPCMethod["EstimateFees"] = "estimate_fees";
+    RPCMethod["EstimateExtraDataSize"] = "estimate_extra_data_size";
+    RPCMethod["NetworkInfo"] = "network_info";
+    RPCMethod["DecryptExtraData"] = "decrypt_extra_data";
+    RPCMethod["DecryptCiphertext"] = "decrypt_ciphertext";
+    RPCMethod["GetMatchingKeys"] = "get_matching_keys";
+    RPCMethod["CountMatchingEntries"] = "count_matching_entries";
+    RPCMethod["GetValueFromKey"] = "get_value_from_key";
+    RPCMethod["Store"] = "store";
+    RPCMethod["Delete"] = "delete";
+    RPCMethod["DeleteTreeEntries"] = "delete_tree_entries";
+    RPCMethod["HasKey"] = "has_key";
+    RPCMethod["QueryDB"] = "query_db";
 })(RPCMethod || (RPCMethod = {}));
 export var RPCEvent;
 (function (RPCEvent) {
@@ -27,6 +69,7 @@ export var RPCEvent;
     RPCEvent["NewTransaction"] = "new_transaction";
     RPCEvent["BalanceChanged"] = "balance_changed";
     RPCEvent["Rescan"] = "rescan";
+    RPCEvent["HistorySynced"] = "history_synced";
     RPCEvent["Online"] = "online";
     RPCEvent["Offline"] = "offline";
 })(RPCEvent || (RPCEvent = {}));