@xelis/sdk 0.8.4 → 0.9.1

package/dist/cjs/wallet/websocket.js

@@ -16,8 +16,8 @@ var __extends = (this && this.__extends) || (function () {
 })();
 exports.__esModule = true;
 exports.WS = exports.WalletMethods = void 0;
-var websocket_js_1 = require("../lib/websocket.js");
-var types_js_1 = require("./types.js");
+var websocket_1 = require("../lib/websocket");
+var types_1 = require("./types");
 var WalletMethods = /** @class */ (function () {
     function WalletMethods(ws, prefix) {
         if (prefix === void 0) { prefix = ""; }
@@ -27,54 +27,81 @@ var WalletMethods = /** @class */ (function () {
     WalletMethods.prototype.dataCall = function (method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     };
+    WalletMethods.prototype.onNewTopoheight = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.NewTopoheight, onData);
+    };
+    WalletMethods.prototype.onNewAsset = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.NewAsset, onData);
+    };
+    WalletMethods.prototype.onNewTransaction = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.NewTransaction, onData);
+    };
+    WalletMethods.prototype.onBalanceChanged = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.BalanceChanged, onData);
+    };
+    WalletMethods.prototype.onRescan = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.Rescan, onData);
+    };
+    WalletMethods.prototype.onOnline = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.Online, onData);
+    };
+    WalletMethods.prototype.onOffline = function (onData) {
+        return this.ws.listenEvent(types_1.RPCEvent.Offline, onData);
+    };
     WalletMethods.prototype.getVersion = function () {
-        return this.dataCall(types_js_1.RPCMethod.GetVersion);
+        return this.dataCall(types_1.RPCMethod.GetVersion);
     };
     WalletMethods.prototype.getNetwork = function () {
-        return this.dataCall(types_js_1.RPCMethod.GetNetwork);
+        return this.dataCall(types_1.RPCMethod.GetNetwork);
     };
     WalletMethods.prototype.getNonce = function () {
-        return this.dataCall(types_js_1.RPCMethod.GetNonce);
+        return this.dataCall(types_1.RPCMethod.GetNonce);
     };
     WalletMethods.prototype.getTopoheight = function () {
-        return this.dataCall(types_js_1.RPCMethod.GetTopoheight);
+        return this.dataCall(types_1.RPCMethod.GetTopoheight);
     };
     WalletMethods.prototype.getAddress = function (params) {
         if (params === void 0) { params = {}; }
-        return this.dataCall(types_js_1.RPCMethod.GetAddress, params);
+        return this.dataCall(types_1.RPCMethod.GetAddress, params);
     };
     WalletMethods.prototype.splitAddress = function (params) {
-        return this.dataCall(types_js_1.RPCMethod.SplitAddress, params);
+        return this.dataCall(types_1.RPCMethod.SplitAddress, params);
     };
-    WalletMethods.prototype.rescan = function () {
-        return this.dataCall(types_js_1.RPCMethod.Rescan);
+    WalletMethods.prototype.rescan = function (params) {
+        return this.dataCall(types_1.RPCMethod.Rescan, params);
     };
     WalletMethods.prototype.getBalance = function (asset) {
-        return this.dataCall(types_js_1.RPCMethod.GetBalance, { asset: asset });
+        return this.dataCall(types_1.RPCMethod.GetBalance, { asset: asset });
     };
     WalletMethods.prototype.getTrackedAssets = function () {
-        return this.dataCall(types_js_1.RPCMethod.GetTrackedAssets);
+        return this.dataCall(types_1.RPCMethod.GetTrackedAssets);
     };
     WalletMethods.prototype.getAssetPrecision = function (params) {
-        return this.dataCall(types_js_1.RPCMethod.GetAssetPrecision, params);
+        return this.dataCall(types_1.RPCMethod.GetAssetPrecision, params);
     };
     WalletMethods.prototype.getTransaction = function (hash) {
-        return this.dataCall(types_js_1.RPCMethod.GetTransaction, { hash: hash });
+        return this.dataCall(types_1.RPCMethod.GetTransaction, { hash: hash });
     };
     WalletMethods.prototype.buildTransaction = function (params) {
-        return this.dataCall(types_js_1.RPCMethod.BuildTransaction, params);
+        return this.dataCall(types_1.RPCMethod.BuildTransaction, params);
     };
     WalletMethods.prototype.listTransactions = function (params) {
-        return this.dataCall(types_js_1.RPCMethod.GetTransaction, params);
+        return this.dataCall(types_1.RPCMethod.GetTransaction, params);
     };
     WalletMethods.prototype.isOnline = function () {
-        return this.dataCall(types_js_1.RPCMethod.IsOnline);
+        return this.dataCall(types_1.RPCMethod.IsOnline);
     };
     WalletMethods.prototype.signData = function (data) {
-        return this.dataCall(types_js_1.RPCMethod.SignData, data);
+        return this.dataCall(types_1.RPCMethod.SignData, data);
+    };
+    WalletMethods.prototype.estimateFees = function (params) {
+        return this.dataCall(types_1.RPCMethod.EstimateFees, params);
+    };
+    WalletMethods.prototype.setOnlineMode = function (params) {
+        return this.dataCall(types_1.RPCMethod.SetOfflineMode, params);
     };
-    WalletMethods.prototype.estimateFees = function (txData) {
-        return this.dataCall(types_js_1.RPCMethod.EstimateFees, { tx_type: txData });
+    WalletMethods.prototype.setOfflineMode = function () {
+        return this.dataCall(types_1.RPCMethod.SetOfflineMode);
     };
     return WalletMethods;
 }());
@@ -87,6 +114,6 @@ var WS = /** @class */ (function (_super) {
         return _this;
     }
     return WS;
-}(websocket_js_1.WS));
+}(websocket_1.WS));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/cjs/xswd/websocket.js

@@ -16,16 +16,16 @@ var __extends = (this && this.__extends) || (function () {
 })();
 exports.__esModule = true;
 exports.WS = void 0;
-var websocket_js_1 = require("../lib/websocket.js");
-var websocket_js_2 = require("../daemon/websocket.js");
-var websocket_js_3 = require("../wallet/websocket.js");
+var websocket_1 = require("../lib/websocket");
+var websocket_2 = require("../daemon/websocket");
+var websocket_3 = require("../wallet/websocket");
 var WS = /** @class */ (function (_super) {
     __extends(WS, _super);
     function WS() {
         var _this = _super.call(this) || this;
         _this.timeout = 0;
-        _this.daemon = new websocket_js_2.DaemonMethods(_this, "node.");
-        _this.wallet = new websocket_js_3.WalletMethods(_this, "wallet.");
+        _this.daemon = new websocket_2.DaemonMethods(_this, "node.");
+        _this.wallet = new websocket_3.WalletMethods(_this, "wallet.");
         return _this;
     }
     WS.prototype.authorize = function (app) {
@@ -33,6 +33,6 @@ var WS = /** @class */ (function (_super) {
         return this.call("", {}, data);
     };
     return WS;
-}(websocket_js_1.WS));
+}(websocket_1.WS));
 exports.WS = WS;
 exports["default"] = WS;

package/dist/esm/daemon/rpc.js

@@ -47,8 +47,8 @@ var RPC = /** @class */ (function (_super) {
     RPC.prototype.getTopBlock = function (params) {
         return this.post(RPCMethod.GetTopBlock, params);
     };
-    RPC.prototype.submitBlock = function (blockTemplate) {
-        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
+    RPC.prototype.submitBlock = function (params) {
+        return this.post(RPCMethod.SubmitBlock, params);
     };
     RPC.prototype.getBalance = function (params) {
         return this.post(RPCMethod.GetBalance, params);
@@ -137,6 +137,24 @@ var RPC = /** @class */ (function (_super) {
     RPC.prototype.getAccountRegistrationTopoheight = function (address) {
         return this.post(RPCMethod.GetAccountRegistrationTopoheight, { address: address });
     };
+    RPC.prototype.isAccountRegistered = function (params) {
+        return this.post(RPCMethod.IsAccountRegistered, params);
+    };
+    RPC.prototype.getMempoolCache = function (address) {
+        return this.post(RPCMethod.GetMempoolCache, { address: address });
+    };
+    RPC.prototype.getDifficulty = function () {
+        return this.post(RPCMethod.GetDifficulty);
+    };
+    RPC.prototype.validateAddress = function (params) {
+        return this.post(RPCMethod.ValidateAddress, params);
+    };
+    RPC.prototype.extractKeyFromAddress = function (params) {
+        return this.post(RPCMethod.ExtractKeyFromAddress, params);
+    };
+    RPC.prototype.createMinerWork = function (params) {
+        return this.post(RPCMethod.CreateMinerWork, params);
+    };
     return RPC;
 }(BaseRPC));
 export { RPC };

package/dist/esm/daemon/types.js

@@ -52,6 +52,12 @@ export var RPCMethod;
     RPCMethod["GetSizeOnDisk"] = "get_size_on_disk";
     RPCMethod["IsTxExecutedInBlock"] = "is_tx_executed_in_block";
     RPCMethod["GetAccountRegistrationTopoheight"] = "get_account_registration_topoheight";
+    RPCMethod["IsAccountRegistered"] = "is_account_registered";
+    RPCMethod["GetMempoolCache"] = "get_mempool_cache";
+    RPCMethod["GetDifficulty"] = "get_difficulty";
+    RPCMethod["ValidateAddress"] = "validate_address";
+    RPCMethod["ExtractKeyFromAddress"] = "extract_key_from_address";
+    RPCMethod["CreateMinerWork"] = "create_miner_work";
 })(RPCMethod || (RPCMethod = {}));
 export var RPCEvent;
 (function (RPCEvent) {

package/dist/esm/daemon/websocket.js

@@ -133,8 +133,8 @@ var DaemonMethods = /** @class */ (function () {
     DaemonMethods.prototype.getTopBlock = function (params) {
         return this.dataCall(RPCMethod.GetTopBlock, params);
     };
-    DaemonMethods.prototype.submitBlock = function (blockTemplate) {
-        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
+    DaemonMethods.prototype.submitBlock = function (params) {
+        return this.dataCall(RPCMethod.SubmitBlock, params);
     };
     DaemonMethods.prototype.getBalance = function (params) {
         return this.dataCall(RPCMethod.GetBalance, params);
@@ -220,6 +220,24 @@ var DaemonMethods = /** @class */ (function () {
     DaemonMethods.prototype.getAccountRegistrationTopoheight = function (address) {
         return this.dataCall(RPCMethod.GetAccountRegistrationTopoheight, { address: address });
     };
+    DaemonMethods.prototype.isAccountRegistered = function (params) {
+        return this.dataCall(RPCMethod.IsAccountRegistered, params);
+    };
+    DaemonMethods.prototype.getMempoolCacheResult = function (address) {
+        return this.dataCall(RPCMethod.GetMempoolCache, { address: address });
+    };
+    DaemonMethods.prototype.getDifficulty = function () {
+        return this.dataCall(RPCMethod.GetDifficulty);
+    };
+    DaemonMethods.prototype.validateAddress = function (params) {
+        return this.dataCall(RPCMethod.ValidateAddress, params);
+    };
+    DaemonMethods.prototype.extractKeyFromAddress = function (params) {
+        return this.dataCall(RPCMethod.ExtractKeyFromAddress, params);
+    };
+    DaemonMethods.prototype.createMinerWork = function (params) {
+        return this.dataCall(RPCMethod.CreateMinerWork, params);
+    };
     return DaemonMethods;
 }());
 export { DaemonMethods };

package/dist/esm/wallet/rpc.js

@@ -89,8 +89,8 @@ var RPC = /** @class */ (function (_super) {
     RPC.prototype.splitAddress = function (params) {
         return this.post(RPCMethod.SplitAddress, params);
     };
-    RPC.prototype.rescan = function () {
-        return this.post(RPCMethod.Rescan);
+    RPC.prototype.rescan = function (params) {
+        return this.post(RPCMethod.Rescan, params);
     };
     RPC.prototype.getBalance = function (asset) {
         return this.post(RPCMethod.GetBalance, { asset: asset });
@@ -119,8 +119,14 @@ var RPC = /** @class */ (function (_super) {
     RPC.prototype.signData = function (data) {
         return this.post(RPCMethod.SignData, data);
     };
-    RPC.prototype.estimateFees = function (txData) {
-        return this.post(RPCMethod.EstimateFees, { tx_type: txData });
+    RPC.prototype.estimateFees = function (params) {
+        return this.post(RPCMethod.EstimateFees, params);
+    };
+    RPC.prototype.setOnlineMode = function (params) {
+        return this.post(RPCMethod.SetOnlineMode, params);
+    };
+    RPC.prototype.setOfflineMode = function () {
+        return this.post(RPCMethod.SetOfflineMode);
     };
     return RPC;
 }(BaseRPC));

package/dist/esm/wallet/types.js

@@ -15,9 +15,21 @@ export var RPCMethod;
     RPCMethod["BuildTransaction"] = "build_transaction";
     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 || (RPCMethod = {}));
+export var RPCEvent;
+(function (RPCEvent) {
+    RPCEvent["NewTopoheight"] = "new_topoheight";
+    RPCEvent["NewAsset"] = "new_asset";
+    RPCEvent["NewTransaction"] = "";
+    RPCEvent["BalanceChanged"] = "balance_changed";
+    RPCEvent["Rescan"] = "rescan";
+    RPCEvent["Online"] = "online";
+    RPCEvent["Offline"] = "offline";
+})(RPCEvent || (RPCEvent = {}));
 export var Permission;
 (function (Permission) {
     Permission[Permission["Ask"] = 0] = "Ask";

package/dist/esm/wallet/websocket.js

@@ -14,7 +14,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 import { WS as BaseWS } from '../lib/websocket.js';
-import { RPCMethod } from './types.js';
+import { RPCMethod, RPCEvent } from './types.js';
 var WalletMethods = /** @class */ (function () {
     function WalletMethods(ws, prefix) {
         if (prefix === void 0) { prefix = ""; }
@@ -24,6 +24,27 @@ var WalletMethods = /** @class */ (function () {
     WalletMethods.prototype.dataCall = function (method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     };
+    WalletMethods.prototype.onNewTopoheight = function (onData) {
+        return this.ws.listenEvent(RPCEvent.NewTopoheight, onData);
+    };
+    WalletMethods.prototype.onNewAsset = function (onData) {
+        return this.ws.listenEvent(RPCEvent.NewAsset, onData);
+    };
+    WalletMethods.prototype.onNewTransaction = function (onData) {
+        return this.ws.listenEvent(RPCEvent.NewTransaction, onData);
+    };
+    WalletMethods.prototype.onBalanceChanged = function (onData) {
+        return this.ws.listenEvent(RPCEvent.BalanceChanged, onData);
+    };
+    WalletMethods.prototype.onRescan = function (onData) {
+        return this.ws.listenEvent(RPCEvent.Rescan, onData);
+    };
+    WalletMethods.prototype.onOnline = function (onData) {
+        return this.ws.listenEvent(RPCEvent.Online, onData);
+    };
+    WalletMethods.prototype.onOffline = function (onData) {
+        return this.ws.listenEvent(RPCEvent.Offline, onData);
+    };
     WalletMethods.prototype.getVersion = function () {
         return this.dataCall(RPCMethod.GetVersion);
     };
@@ -43,8 +64,8 @@ var WalletMethods = /** @class */ (function () {
     WalletMethods.prototype.splitAddress = function (params) {
         return this.dataCall(RPCMethod.SplitAddress, params);
     };
-    WalletMethods.prototype.rescan = function () {
-        return this.dataCall(RPCMethod.Rescan);
+    WalletMethods.prototype.rescan = function (params) {
+        return this.dataCall(RPCMethod.Rescan, params);
     };
     WalletMethods.prototype.getBalance = function (asset) {
         return this.dataCall(RPCMethod.GetBalance, { asset: asset });
@@ -70,8 +91,14 @@ var WalletMethods = /** @class */ (function () {
     WalletMethods.prototype.signData = function (data) {
         return this.dataCall(RPCMethod.SignData, data);
     };
-    WalletMethods.prototype.estimateFees = function (txData) {
-        return this.dataCall(RPCMethod.EstimateFees, { tx_type: txData });
+    WalletMethods.prototype.estimateFees = function (params) {
+        return this.dataCall(RPCMethod.EstimateFees, params);
+    };
+    WalletMethods.prototype.setOnlineMode = function (params) {
+        return this.dataCall(RPCMethod.SetOfflineMode, params);
+    };
+    WalletMethods.prototype.setOfflineMode = function () {
+        return this.dataCall(RPCMethod.SetOfflineMode);
     };
     return WalletMethods;
 }());

package/dist/types/daemon/rpc.d.ts

@@ -1,44 +1,50 @@
-import { Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetBalanceResult, P2PStatusResult, GetBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceResult, GetNonceParams, GetAccountHistoryParams, AccounHistory, DevFee, DiskSize, HasBalanceParams, HasBalanceResult, AssetData, IsTxExecutedInBlockParams, GetAssetParams, GetPeersResult, GetBlockTemplateResult, VersionedBalance, VersionedNonce, GetNonceAtTopoheightParams, HasNonceParams, HasNonceResult, TransactionResponse } from './types.js';
-import { RPC as BaseRPC } from '../lib/rpc.js';
+import { Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetBalanceResult, P2PStatusResult, GetBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceResult, GetNonceParams, GetAccountHistoryParams, AccounHistory, DevFee, DiskSize, HasBalanceParams, HasBalanceResult, AssetData, IsTxExecutedInBlockParams, GetAssetParams, GetPeersResult, GetBlockTemplateResult, VersionedBalance, VersionedNonce, GetNonceAtTopoheightParams, HasNonceParams, HasNonceResult, TransactionResponse, IsAccountRegisteredParams, GetMempoolCacheResult, GetDifficultyResult, ValidateAddressParams, ExtractKeyFromAddressParams, SubmitBlockParams, CreateMinerWorkParams, CreateMinerWorkResult } from './types';
+import { RPC as BaseRPC } from '../lib/rpc';
 export declare class RPC extends BaseRPC {
-    getVersion(): Promise<import("../lib/types.js").RPCResponse<string>>;
-    getHeight(): Promise<import("../lib/types.js").RPCResponse<number>>;
-    getTopoHeight(): Promise<import("../lib/types.js").RPCResponse<number>>;
-    getStableHeight(): Promise<import("../lib/types.js").RPCResponse<number>>;
-    getBlockTemplate(address: string): Promise<import("../lib/types.js").RPCResponse<GetBlockTemplateResult>>;
-    getBlockAtTopoHeight(params: GetBlockAtTopoHeightParams): Promise<import("../lib/types.js").RPCResponse<Block>>;
-    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<import("../lib/types.js").RPCResponse<Block[]>>;
-    getBlockByHash(params: GetBlockByHashParams): Promise<import("../lib/types.js").RPCResponse<Block>>;
-    getTopBlock(params: GetTopBlockParams): Promise<import("../lib/types.js").RPCResponse<Block>>;
-    submitBlock(blockTemplate: string): Promise<import("../lib/types.js").RPCResponse<boolean>>;
-    getBalance(params: GetBalanceParams): Promise<import("../lib/types.js").RPCResponse<GetBalanceResult>>;
-    hasBalance(params: HasBalanceParams): Promise<import("../lib/types.js").RPCResponse<HasBalanceResult>>;
-    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<import("../lib/types.js").RPCResponse<VersionedBalance>>;
-    getInfo(): Promise<import("../lib/types.js").RPCResponse<GetInfoResult>>;
-    getNonce(params: GetNonceParams): Promise<import("../lib/types.js").RPCResponse<GetNonceResult>>;
-    hasNonce(params: HasNonceParams): Promise<import("../lib/types.js").RPCResponse<HasNonceResult>>;
-    getNonceAtTopoheight(params: GetNonceAtTopoheightParams): Promise<import("../lib/types.js").RPCResponse<VersionedNonce>>;
-    getAsset(params: GetAssetParams): Promise<import("../lib/types.js").RPCResponse<AssetData>>;
-    getAssets(): Promise<import("../lib/types.js").RPCResponse<string[]>>;
-    countAssets(): Promise<import("../lib/types.js").RPCResponse<number>>;
-    countAccounts(): Promise<import("../lib/types.js").RPCResponse<number>>;
-    countTransactions(): Promise<import("../lib/types.js").RPCResponse<number>>;
-    submitTransaction(hexData: string): Promise<import("../lib/types.js").RPCResponse<boolean>>;
-    getTransaction(hash: string): Promise<import("../lib/types.js").RPCResponse<TransactionResponse>>;
-    p2pStatus(): Promise<import("../lib/types.js").RPCResponse<P2PStatusResult>>;
-    getPeers(): Promise<import("../lib/types.js").RPCResponse<GetPeersResult>>;
-    getMemPool(): Promise<import("../lib/types.js").RPCResponse<TransactionResponse[]>>;
-    getTips(): Promise<import("../lib/types.js").RPCResponse<string[]>>;
-    getDAGOrder(params: TopoHeightRangeParams): Promise<import("../lib/types.js").RPCResponse<string[]>>;
-    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<import("../lib/types.js").RPCResponse<Block[]>>;
-    getBlocksRangeByHeight(params: HeightRangeParams): Promise<import("../lib/types.js").RPCResponse<Block[]>>;
-    getTransactions(txHashes: string[]): Promise<import("../lib/types.js").RPCResponse<TransactionResponse[]>>;
-    getAccountHistory(params: GetAccountHistoryParams): Promise<import("../lib/types.js").RPCResponse<AccounHistory[]>>;
-    getAccountAssets(address: string): Promise<import("../lib/types.js").RPCResponse<string[]>>;
-    getAccounts(params: GetAccountsParams): Promise<import("../lib/types.js").RPCResponse<string[]>>;
-    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<import("../lib/types.js").RPCResponse<boolean>>;
-    getDevFeeThresholds(): Promise<import("../lib/types.js").RPCResponse<DevFee[]>>;
-    getSizeOnDisk(): Promise<import("../lib/types.js").RPCResponse<DiskSize>>;
-    getAccountRegistrationTopoheight(address: String): Promise<import("../lib/types.js").RPCResponse<Number>>;
+    getVersion(): Promise<import("../lib/types").RPCResponse<string>>;
+    getHeight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getTopoHeight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getStableHeight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getBlockTemplate(address: string): Promise<import("../lib/types").RPCResponse<GetBlockTemplateResult>>;
+    getBlockAtTopoHeight(params: GetBlockAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<Block>>;
+    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getBlockByHash(params: GetBlockByHashParams): Promise<import("../lib/types").RPCResponse<Block>>;
+    getTopBlock(params: GetTopBlockParams): Promise<import("../lib/types").RPCResponse<Block>>;
+    submitBlock(params: SubmitBlockParams): Promise<import("../lib/types").RPCResponse<boolean>>;
+    getBalance(params: GetBalanceParams): Promise<import("../lib/types").RPCResponse<GetBalanceResult>>;
+    hasBalance(params: HasBalanceParams): Promise<import("../lib/types").RPCResponse<HasBalanceResult>>;
+    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<VersionedBalance>>;
+    getInfo(): Promise<import("../lib/types").RPCResponse<GetInfoResult>>;
+    getNonce(params: GetNonceParams): Promise<import("../lib/types").RPCResponse<GetNonceResult>>;
+    hasNonce(params: HasNonceParams): Promise<import("../lib/types").RPCResponse<HasNonceResult>>;
+    getNonceAtTopoheight(params: GetNonceAtTopoheightParams): Promise<import("../lib/types").RPCResponse<VersionedNonce>>;
+    getAsset(params: GetAssetParams): Promise<import("../lib/types").RPCResponse<AssetData>>;
+    getAssets(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    countAssets(): Promise<import("../lib/types").RPCResponse<number>>;
+    countAccounts(): Promise<import("../lib/types").RPCResponse<number>>;
+    countTransactions(): Promise<import("../lib/types").RPCResponse<number>>;
+    submitTransaction(hexData: string): Promise<import("../lib/types").RPCResponse<boolean>>;
+    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<TransactionResponse>>;
+    p2pStatus(): Promise<import("../lib/types").RPCResponse<P2PStatusResult>>;
+    getPeers(): Promise<import("../lib/types").RPCResponse<GetPeersResult>>;
+    getMemPool(): Promise<import("../lib/types").RPCResponse<TransactionResponse[]>>;
+    getTips(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getDAGOrder(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getBlocksRangeByHeight(params: HeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getTransactions(txHashes: string[]): Promise<import("../lib/types").RPCResponse<TransactionResponse[]>>;
+    getAccountHistory(params: GetAccountHistoryParams): Promise<import("../lib/types").RPCResponse<AccounHistory[]>>;
+    getAccountAssets(address: string): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getAccounts(params: GetAccountsParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<import("../lib/types").RPCResponse<boolean>>;
+    getDevFeeThresholds(): Promise<import("../lib/types").RPCResponse<DevFee[]>>;
+    getSizeOnDisk(): Promise<import("../lib/types").RPCResponse<DiskSize>>;
+    getAccountRegistrationTopoheight(address: String): Promise<import("../lib/types").RPCResponse<Number>>;
+    isAccountRegistered(params: IsAccountRegisteredParams): Promise<import("../lib/types").RPCResponse<boolean>>;
+    getMempoolCache(address: String): Promise<import("../lib/types").RPCResponse<GetMempoolCacheResult>>;
+    getDifficulty(): Promise<import("../lib/types").RPCResponse<GetDifficultyResult>>;
+    validateAddress(params: ValidateAddressParams): Promise<import("../lib/types").RPCResponse<boolean>>;
+    extractKeyFromAddress(params: ExtractKeyFromAddressParams): Promise<import("../lib/types").RPCResponse<string | number[]>>;
+    createMinerWork(params: CreateMinerWorkParams): Promise<import("../lib/types").RPCResponse<CreateMinerWorkResult>>;
 }
 export default RPC;

package/dist/types/daemon/types.d.ts

@@ -21,6 +21,8 @@ export interface Block {
     difficulty: string;
     supply?: number;
     reward?: number;
+    dev_reward?: number;
+    miner_reward?: number;
     cumulative_difficulty: string;
     total_fees?: number;
     total_size_in_bytes: number;
@@ -84,6 +86,7 @@ export interface P2PStatusResult {
     peer_id: number;
     our_topoheight: number;
     best_topoheight: number;
+    median_topoheight: number;
     max_peers: number;
 }
 export interface TopoHeightRangeParams {
@@ -286,12 +289,47 @@ export declare enum BlockType {
 export interface GetBlockTemplateResult {
     template: string;
     height: number;
-    difficulty: number;
+    topoheight: number;
+    difficulty: string;
 }
 export interface HasNonceParams {
     address: string;
     topoheight?: number;
 }
+export interface IsAccountRegisteredParams {
+    address: string;
+    in_stable_height: boolean;
+}
+export interface GetMempoolCacheResult {
+    min: number;
+    max: number;
+    txs: string[];
+    balances: Map<string, string>;
+}
+export interface GetDifficultyResult {
+    difficulty: string;
+    hashrate: string;
+    hashrate_formatted: string;
+}
+export interface ValidateAddressParams {
+    address: string;
+    allow_integrated: boolean;
+}
+export interface ExtractKeyFromAddressParams {
+    address: string;
+    tx_as_hex: boolean;
+}
+export interface SubmitBlockParams {
+    block_template: string;
+    miner_work?: string;
+}
+export interface CreateMinerWorkParams {
+    template: string;
+    address?: string;
+}
+export interface CreateMinerWorkResult {
+    miner_work: string;
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetInfo = "get_info",
@@ -331,7 +369,13 @@ export declare enum RPCMethod {
     GetDevFeeThresholds = "get_dev_fee_thresholds",
     GetSizeOnDisk = "get_size_on_disk",
     IsTxExecutedInBlock = "is_tx_executed_in_block",
-    GetAccountRegistrationTopoheight = "get_account_registration_topoheight"
+    GetAccountRegistrationTopoheight = "get_account_registration_topoheight",
+    IsAccountRegistered = "is_account_registered",
+    GetMempoolCache = "get_mempool_cache",
+    GetDifficulty = "get_difficulty",
+    ValidateAddress = "validate_address",
+    ExtractKeyFromAddress = "extract_key_from_address",
+    CreateMinerWork = "create_miner_work"
 }
 export declare enum RPCEvent {
     NewBlock = "new_block",

package/dist/types/daemon/websocket.d.ts

@@ -1,6 +1,6 @@
 import { MessageEvent } from 'ws';
-import { Block, GetInfoResult, GetPeersResult, RPCEventResult, TopoHeightRangeParams, P2PStatusResult, GetBalanceAtTopoHeightParams, GetBalanceResult, HeightRangeParams, BlockOrdered, GetBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceParams, GetNonceResult, GetAccountHistoryParams, AccounHistory, Peer, PeerPeerListUpdated, PeerPeerDisconnected, DevFee, DiskSize, AssetWithData, AssetData, GetAssetParams, HasBalanceParams, HasBalanceResult, IsTxExecutedInBlockParams, BlockOrphaned, VersionedBalance, StableHeightChanged, HasNonceResult, HasNonceParams, TransactionResponse } from './types.js';
-import { WS as BaseWS } from '../lib/websocket.js';
+import { Block, GetInfoResult, GetPeersResult, RPCEventResult, TopoHeightRangeParams, P2PStatusResult, GetBalanceAtTopoHeightParams, GetBalanceResult, HeightRangeParams, BlockOrdered, GetBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceParams, GetNonceResult, GetAccountHistoryParams, AccounHistory, Peer, PeerPeerListUpdated, PeerPeerDisconnected, DevFee, DiskSize, AssetWithData, AssetData, GetAssetParams, HasBalanceParams, HasBalanceResult, IsTxExecutedInBlockParams, BlockOrphaned, VersionedBalance, StableHeightChanged, HasNonceResult, HasNonceParams, TransactionResponse, IsAccountRegisteredParams, GetMempoolCacheResult, GetDifficultyResult, ValidateAddressParams, ExtractKeyFromAddressParams, SubmitBlockParams, CreateMinerWorkParams, CreateMinerWorkResult } from './types';
+import { WS as BaseWS } from '../lib/websocket';
 export declare class DaemonMethods {
     ws: BaseWS;
     prefix: string;
@@ -29,7 +29,7 @@ export declare class DaemonMethods {
     getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<Block[]>;
     getBlockByHash(params: GetBlockByHashParams): Promise<Block>;
     getTopBlock(params: GetTopBlockParams): Promise<Block>;
-    submitBlock(blockTemplate: string): Promise<boolean>;
+    submitBlock(params: SubmitBlockParams): Promise<boolean>;
     getBalance(params: GetBalanceParams): Promise<GetBalanceResult>;
     hasBalance(params: HasBalanceParams): Promise<HasBalanceResult>;
     getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<VersionedBalance>;
@@ -58,6 +58,12 @@ export declare class DaemonMethods {
     getDevFeeThresholds(): Promise<DevFee[]>;
     getSizeOnDisk(): Promise<DiskSize>;
     getAccountRegistrationTopoheight(address: String): Promise<Number>;
+    isAccountRegistered(params: IsAccountRegisteredParams): Promise<boolean>;
+    getMempoolCacheResult(address: string): Promise<GetMempoolCacheResult>;
+    getDifficulty(): Promise<GetDifficultyResult>;
+    validateAddress(params: ValidateAddressParams): Promise<boolean>;
+    extractKeyFromAddress(params: ExtractKeyFromAddressParams): Promise<string | number[]>;
+    createMinerWork(params: CreateMinerWorkParams): Promise<CreateMinerWorkResult>;
 }
 export declare class WS extends BaseWS {
     methods: DaemonMethods;

package/dist/types/lib/rpc.d.ts

@@ -1,4 +1,4 @@
-import { RPCResponse } from './types.js';
+import { RPCResponse } from './types';
 export declare class RPC {
     endpoint: string;
     timeout: number;

package/dist/types/lib/websocket.d.ts

@@ -2,7 +2,7 @@
 import { ClientOptions, MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
 import { ClientRequestArgs } from 'http';
-import { RPCResponse } from './types.js';
+import { RPCResponse } from './types';
 export declare class WS {
     endpoint: string;
     socket?: WebSocket;

package/dist/types/react/daemon.d.ts

@@ -1,7 +1,7 @@
 import React, { PropsWithChildren } from 'react';
 import { MessageEvent } from 'ws';
-import DaemonWS from '../daemon/websocket.js';
-import { RPCEvent } from '../daemon/types.js';
+import DaemonWS from '../daemon/websocket';
+import { RPCEvent } from '../daemon/types';
 export declare const INITIATING = -1;
 interface NodeSocket {
     daemon: DaemonWS;

package/dist/types/wallet/rpc.d.ts

@@ -1,7 +1,7 @@
-import { GetAssetParams, HasBalanceResult, TransactionData } from '../daemon/types.js';
-import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams, Signature, TransactionEntry } from './types.js';
-import { RPC as BaseRPC } from '../lib/rpc.js';
-import { RPCResponse } from '../lib/types.js';
+import { GetAssetParams, HasBalanceResult } from '../daemon/types';
+import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams, Signature, TransactionEntry, RescanParams, SetOnlineModeParams, EstimateFeesParams } from './types';
+import { RPC as BaseRPC } from '../lib/rpc';
+import { RPCResponse } from '../lib/types';
 export declare class RPC extends BaseRPC {
     auth: string;
     constructor(endpoint: string, username: string, password: string);
@@ -12,7 +12,7 @@ export declare class RPC extends BaseRPC {
     getTopoheight(): Promise<RPCResponse<number>>;
     getAddress(params?: GetAddressParams): Promise<RPCResponse<string>>;
     splitAddress(params: SplitAddressParams): Promise<RPCResponse<SplitAddressResult>>;
-    rescan(): Promise<RPCResponse<void>>;
+    rescan(params: RescanParams): Promise<RPCResponse<boolean>>;
     getBalance(asset?: string): Promise<RPCResponse<number>>;
     hasBalance(asset?: string): Promise<RPCResponse<HasBalanceResult>>;
     getTrackedAssets(): Promise<RPCResponse<string[]>>;
@@ -22,6 +22,8 @@ export declare class RPC extends BaseRPC {
     listTransactions(params?: ListTransactionParams): Promise<RPCResponse<TransactionEntry[]>>;
     isOnline(): Promise<RPCResponse<boolean>>;
     signData(data: any): Promise<RPCResponse<Signature>>;
-    estimateFees(txData: TransactionData): Promise<RPCResponse<number>>;
+    estimateFees(params: EstimateFeesParams): Promise<RPCResponse<number>>;
+    setOnlineMode(params: SetOnlineModeParams): Promise<RPCResponse<boolean>>;
+    setOfflineMode(): Promise<RPCResponse<boolean>>;
 }
 export default RPC;