@xelis/sdk 0.11.24 → 0.11.26

package/dist/cjs/daemon/rpc.js

@@ -127,6 +127,9 @@ class RPC extends http_1.HttpRPC {
     getEstimatedFeeRates() {
         return this.request(types_1.RPCMethod.GetEstimatedFeeRates);
     }
+    getEstimatedFeePerKB() {
+        return this.request(types_1.RPCMethod.GetEstimatedFeePerKB);
+    }
     getDAGOrder(params) {
         return this.request(types_1.RPCMethod.GetDAGOrder, params);
     }
@@ -208,6 +211,12 @@ class RPC extends http_1.HttpRPC {
     getContractAssets(params) {
         return this.request(types_1.RPCMethod.GetContractAssets, params);
     }
+    getContracts(params) {
+        return this.request(types_1.RPCMethod.GetContracts, params);
+    }
+    getContractDataEntries(params) {
+        return this.request(types_1.RPCMethod.GetContractDataEntries, params);
+    }
     getP2PBlockPropagation(params) {
         return this.request(types_1.RPCMethod.GetP2PBlockPropagation, params);
     }

package/dist/cjs/daemon/types.js

@@ -57,6 +57,7 @@ var RPCMethod;
     RPCMethod["GetMempoolSummary"] = "get_mempool_summary";
     RPCMethod["GetMempoolCache"] = "get_mempool_cache";
     RPCMethod["GetEstimatedFeeRates"] = "get_estimated_fee_rates";
+    RPCMethod["GetEstimatedFeePerKB"] = "get_estimated_fee_per_kb";
     RPCMethod["GetDAGOrder"] = "get_dag_order";
     RPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
     RPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
@@ -84,6 +85,8 @@ var RPCMethod;
     RPCMethod["GetContractBalance"] = "get_contract_balance";
     RPCMethod["GetContractBalanceAtTopoheight"] = "get_contract_balance_at_topoheight";
     RPCMethod["GetContractAssets"] = "get_contract_assets";
+    RPCMethod["GetContracts"] = "get_contracts";
+    RPCMethod["GetContractDataEntries"] = "get_contract_data_entries";
     RPCMethod["GetP2PBlockPropagation"] = "get_p2p_block_propagation";
     RPCMethod["GetBlockTemplate"] = "get_block_template";
     RPCMethod["GetMinerWork"] = "get_miner_work";
@@ -100,7 +103,8 @@ var RPCEvent;
     RPCEvent["TransactionAddedInMempool"] = "transaction_added_in_mempool";
     RPCEvent["TransactionExecuted"] = "transaction_executed";
     RPCEvent["InvokeContract"] = "invoke_contract";
-    RPCEvent["ContractTransfer"] = "contract_transfer";
+    RPCEvent["ContractTransfers"] = "contract_transfers";
+    RPCEvent["InvokeContractError"] = "invoke_contract_error";
     RPCEvent["ContractEvent"] = "contract_event";
     RPCEvent["DeployContract"] = "deploy_contract";
     RPCEvent["NewAsset"] = "new_asset";

package/dist/cjs/daemon/websocket.js

@@ -11,11 +11,17 @@ class DaemonMethods {
     dataCall(method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     }
-    closeListener(event, listener) {
-        this.ws.closeListener(event, listener);
-    }
-    listen(event, listener) {
-        this.ws.listen(this.prefix + event, listener);
+    removeListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.removeListener(eventObj, listener);
+    }
+    addListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.addListener(eventObj, listener);
     }
     getVersion() {
         return this.dataCall(types_1.RPCMethod.GetVersion);
@@ -140,6 +146,9 @@ class DaemonMethods {
     getEstimatedFeeRates() {
         return this.dataCall(types_1.RPCMethod.GetEstimatedFeeRates);
     }
+    getEstimatedFeePerKB() {
+        return this.dataCall(types_1.RPCMethod.GetEstimatedFeePerKB);
+    }
     getDAGOrder(params) {
         return this.dataCall(types_1.RPCMethod.GetDAGOrder, params);
     }
@@ -221,6 +230,12 @@ class DaemonMethods {
     getContractAssets(params) {
         return this.dataCall(types_1.RPCMethod.GetContractAssets, params);
     }
+    getContracts(params) {
+        return this.dataCall(types_1.RPCMethod.GetContracts, params);
+    }
+    getContractDataEntries(params) {
+        return this.dataCall(types_1.RPCMethod.GetContractDataEntries, params);
+    }
     getP2PBlockPropagation(params) {
         return this.dataCall(types_1.RPCMethod.GetP2PBlockPropagation, params);
     }

package/dist/cjs/react/daemon.js

@@ -94,11 +94,11 @@ const useNodeSocketSubscribe = ({ event, onLoad, onData }, dependencies) => {
             return;
         if (typeof onLoad === `function`)
             onLoad();
-        nodeSocket.daemon.listen(event, onData);
+        nodeSocket.daemon.addListener(event, onData);
         return () => {
             if (!nodeSocket.daemon)
                 return;
-            nodeSocket.daemon.closeListener(event, onData);
+            nodeSocket.daemon.removeListener(event, onData);
         };
     }, [nodeSocket, ...dependencies]);
 };

package/dist/cjs/rpc/websocket.js

@@ -17,7 +17,7 @@ class WSRPC {
             this.events = new Map();
         });
     }
-    async closeListener(event, listener) {
+    async removeListener(event, listener) {
         const eventData = this.events.get(event);
         if (eventData) {
             if (eventData.listeners.length > 1) {
@@ -31,8 +31,8 @@ class WSRPC {
             }
         }
     }
-    async listen(event, listener) {
-        const listenEvent = () => {
+    async addListener(event, listener) {
+        const listenEvent = async () => {
             const eventData = this.events.get(event);
             if (eventData) {
                 eventData.listeners.push(listener);
@@ -40,7 +40,8 @@ class WSRPC {
             }
             else {
                 let idRefObject = {};
-                this.dataCall(`subscribe`, { notify: event }, idRefObject);
+                await this.dataCall(`subscribe`, { notify: event }, idRefObject)
+                    .catch(err => listener(null, err));
                 const onMessage = (msgEvent) => {
                     const eventData = this.events.get(event);
                     if (eventData && typeof msgEvent.data === `string`) {

package/dist/cjs/wallet/types.js

@@ -77,4 +77,7 @@ var RPCEvent;
     RPCEvent["HistorySynced"] = "history_synced";
     RPCEvent["Online"] = "online";
     RPCEvent["Offline"] = "offline";
+    RPCEvent["SyncError"] = "sync_error";
+    RPCEvent["TrackAsset"] = "track_asset";
+    RPCEvent["UntrackAsset"] = "untrack_asset";
 })(RPCEvent = exports.RPCEvent || (exports.RPCEvent = {}));

package/dist/cjs/wallet/websocket.js

@@ -11,11 +11,17 @@ class WalletMethods {
     dataCall(method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     }
-    closeListener(event, listener) {
-        this.ws.closeListener(event, listener);
-    }
-    listen(event, listener) {
-        this.ws.listen(this.prefix + event, listener);
+    removeListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.removeListener(event, listener);
+    }
+    addListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.addListener(eventObj, listener);
     }
     getVersion() {
         return this.dataCall(types_1.RPCMethod.GetVersion);

package/dist/esm/daemon/rpc.js

@@ -124,6 +124,9 @@ export class RPC extends HttpRPC {
     getEstimatedFeeRates() {
         return this.request(RPCMethod.GetEstimatedFeeRates);
     }
+    getEstimatedFeePerKB() {
+        return this.request(RPCMethod.GetEstimatedFeePerKB);
+    }
     getDAGOrder(params) {
         return this.request(RPCMethod.GetDAGOrder, params);
     }
@@ -205,6 +208,12 @@ export class RPC extends HttpRPC {
     getContractAssets(params) {
         return this.request(RPCMethod.GetContractAssets, params);
     }
+    getContracts(params) {
+        return this.request(RPCMethod.GetContracts, params);
+    }
+    getContractDataEntries(params) {
+        return this.request(RPCMethod.GetContractDataEntries, params);
+    }
     getP2PBlockPropagation(params) {
         return this.request(RPCMethod.GetP2PBlockPropagation, params);
     }

package/dist/esm/daemon/types.js

@@ -54,6 +54,7 @@ export var RPCMethod;
     RPCMethod["GetMempoolSummary"] = "get_mempool_summary";
     RPCMethod["GetMempoolCache"] = "get_mempool_cache";
     RPCMethod["GetEstimatedFeeRates"] = "get_estimated_fee_rates";
+    RPCMethod["GetEstimatedFeePerKB"] = "get_estimated_fee_per_kb";
     RPCMethod["GetDAGOrder"] = "get_dag_order";
     RPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
     RPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
@@ -81,6 +82,8 @@ export var RPCMethod;
     RPCMethod["GetContractBalance"] = "get_contract_balance";
     RPCMethod["GetContractBalanceAtTopoheight"] = "get_contract_balance_at_topoheight";
     RPCMethod["GetContractAssets"] = "get_contract_assets";
+    RPCMethod["GetContracts"] = "get_contracts";
+    RPCMethod["GetContractDataEntries"] = "get_contract_data_entries";
     RPCMethod["GetP2PBlockPropagation"] = "get_p2p_block_propagation";
     RPCMethod["GetBlockTemplate"] = "get_block_template";
     RPCMethod["GetMinerWork"] = "get_miner_work";
@@ -97,7 +100,8 @@ export var RPCEvent;
     RPCEvent["TransactionAddedInMempool"] = "transaction_added_in_mempool";
     RPCEvent["TransactionExecuted"] = "transaction_executed";
     RPCEvent["InvokeContract"] = "invoke_contract";
-    RPCEvent["ContractTransfer"] = "contract_transfer";
+    RPCEvent["ContractTransfers"] = "contract_transfers";
+    RPCEvent["InvokeContractError"] = "invoke_contract_error";
     RPCEvent["ContractEvent"] = "contract_event";
     RPCEvent["DeployContract"] = "deploy_contract";
     RPCEvent["NewAsset"] = "new_asset";

package/dist/esm/daemon/websocket.js

@@ -8,11 +8,17 @@ export class DaemonMethods {
     dataCall(method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     }
-    closeListener(event, listener) {
-        this.ws.closeListener(event, listener);
-    }
-    listen(event, listener) {
-        this.ws.listen(this.prefix + event, listener);
+    removeListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.removeListener(eventObj, listener);
+    }
+    addListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.addListener(eventObj, listener);
     }
     getVersion() {
         return this.dataCall(RPCMethod.GetVersion);
@@ -137,6 +143,9 @@ export class DaemonMethods {
     getEstimatedFeeRates() {
         return this.dataCall(RPCMethod.GetEstimatedFeeRates);
     }
+    getEstimatedFeePerKB() {
+        return this.dataCall(RPCMethod.GetEstimatedFeePerKB);
+    }
     getDAGOrder(params) {
         return this.dataCall(RPCMethod.GetDAGOrder, params);
     }
@@ -218,6 +227,12 @@ export class DaemonMethods {
     getContractAssets(params) {
         return this.dataCall(RPCMethod.GetContractAssets, params);
     }
+    getContracts(params) {
+        return this.dataCall(RPCMethod.GetContracts, params);
+    }
+    getContractDataEntries(params) {
+        return this.dataCall(RPCMethod.GetContractDataEntries, params);
+    }
     getP2PBlockPropagation(params) {
         return this.dataCall(RPCMethod.GetP2PBlockPropagation, params);
     }

package/dist/esm/react/daemon.js

@@ -64,11 +64,11 @@ export const useNodeSocketSubscribe = ({ event, onLoad, onData }, dependencies)
             return;
         if (typeof onLoad === `function`)
             onLoad();
-        nodeSocket.daemon.listen(event, onData);
+        nodeSocket.daemon.addListener(event, onData);
         return () => {
             if (!nodeSocket.daemon)
                 return;
-            nodeSocket.daemon.closeListener(event, onData);
+            nodeSocket.daemon.removeListener(event, onData);
         };
     }, [nodeSocket, ...dependencies]);
 };

package/dist/esm/rpc/websocket.js

@@ -11,7 +11,7 @@ export class WSRPC {
             this.events = new Map();
         });
     }
-    async closeListener(event, listener) {
+    async removeListener(event, listener) {
         const eventData = this.events.get(event);
         if (eventData) {
             if (eventData.listeners.length > 1) {
@@ -25,8 +25,8 @@ export class WSRPC {
             }
         }
     }
-    async listen(event, listener) {
-        const listenEvent = () => {
+    async addListener(event, listener) {
+        const listenEvent = async () => {
             const eventData = this.events.get(event);
             if (eventData) {
                 eventData.listeners.push(listener);
@@ -34,7 +34,8 @@ export class WSRPC {
             }
             else {
                 let idRefObject = {};
-                this.dataCall(`subscribe`, { notify: event }, idRefObject);
+                await this.dataCall(`subscribe`, { notify: event }, idRefObject)
+                    .catch(err => listener(null, err));
                 const onMessage = (msgEvent) => {
                     const eventData = this.events.get(event);
                     if (eventData && typeof msgEvent.data === `string`) {

package/dist/esm/wallet/types.js

@@ -74,4 +74,7 @@ export var RPCEvent;
     RPCEvent["HistorySynced"] = "history_synced";
     RPCEvent["Online"] = "online";
     RPCEvent["Offline"] = "offline";
+    RPCEvent["SyncError"] = "sync_error";
+    RPCEvent["TrackAsset"] = "track_asset";
+    RPCEvent["UntrackAsset"] = "untrack_asset";
 })(RPCEvent || (RPCEvent = {}));

package/dist/esm/wallet/websocket.js

@@ -8,11 +8,17 @@ export class WalletMethods {
     dataCall(method, params) {
         return this.ws.dataCall(this.prefix + method, params);
     }
-    closeListener(event, listener) {
-        this.ws.closeListener(event, listener);
-    }
-    listen(event, listener) {
-        this.ws.listen(this.prefix + event, listener);
+    removeListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.removeListener(event, listener);
+    }
+    addListener(event, params, listener) {
+        let eventObj = this.prefix + event;
+        if (params)
+            eventObj = { [eventObj]: params };
+        this.ws.addListener(eventObj, listener);
     }
     getVersion() {
         return this.dataCall(RPCMethod.GetVersion);

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

@@ -42,6 +42,7 @@ export declare class RPC extends HttpRPC {
     getMempoolSummary(params?: types.GetMempoolParams): Promise<types.GetMempoolSummaryResult>;
     getMempoolCache(address: String): Promise<types.GetMempoolCacheResult>;
     getEstimatedFeeRates(): Promise<types.FeeRatesEstimated>;
+    getEstimatedFeePerKB(): Promise<types.PredicatedBaseFeeResult>;
     getDAGOrder(params?: types.TopoheightRangeParams): Promise<string[]>;
     getBlocksRangeByTopoheight(params: types.TopoheightRangeParams): Promise<types.Block[]>;
     getBlocksRangeByHeight(params: types.HeightRangeParams): Promise<types.Block[]>;
@@ -69,6 +70,8 @@ export declare class RPC extends HttpRPC {
     getContractBalance(params: types.GetContractBalanceParams): Promise<types.GetContractBalanceResult>;
     getContractBalanceAtTopoheight(params: types.GetContractBalanceAtTopoheightParams): Promise<types.GetContractBalanceAtTopoheightResult>;
     getContractAssets(params: types.GetContractBalancesParams): Promise<string[]>;
+    getContracts(params: types.GetAccountsParams): Promise<string[]>;
+    getContractDataEntries(params: types.GetContractDataEntriesParams): Promise<unknown>;
     getP2PBlockPropagation(params: types.GetP2pBlockPropagationParams): Promise<types.P2pBlockPropagationResult>;
     getBlockTemplate(address: string): Promise<types.GetBlockTemplateResult>;
     getMinerWork(params: types.GetMinerWorkParams): Promise<types.GetMinerWorkResult>;

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

@@ -358,6 +358,11 @@ export interface AssetData {
 export interface AssetWithData extends AssetData {
     asset: string;
 }
+export interface NewAsset {
+    asset: string;
+    block_hash: string;
+    topoheight: number;
+}
 export interface HasBalanceParams {
     address: string;
     asset: string;
@@ -613,10 +618,16 @@ export interface P2pBlockPropagationResult {
     first_seen?: number;
     processing_at?: number;
 }
-export interface ContractTransfer {
-    asset: string;
-    amount: number;
+export interface ContractTransfersEntry {
+    contract: string;
+    caller: string;
+}
+export interface ContractTransfers {
     block_hash: string;
+    block_timestamp: number;
+    executions: {
+        [key: string]: ContractTransfersEntry;
+    };
     topoheight: number;
 }
 export interface ContractEventSource {
@@ -722,6 +733,17 @@ export interface ContractOutputs {
     caller: string;
     outputs: ContractLog[];
 }
+export interface PredicatedBaseFeeResult {
+    fee_per_kb: number;
+    predicated_fee_per_kb: number;
+}
+export interface GetContractDataEntriesParams {
+    contract: string;
+    minimum_topoheight?: number;
+    maximum_topoheight?: number;
+    skip?: number;
+    maximum?: number;
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetHeight = "get_height",
@@ -764,6 +786,7 @@ export declare enum RPCMethod {
     GetMempoolSummary = "get_mempool_summary",
     GetMempoolCache = "get_mempool_cache",
     GetEstimatedFeeRates = "get_estimated_fee_rates",
+    GetEstimatedFeePerKB = "get_estimated_fee_per_kb",
     GetDAGOrder = "get_dag_order",
     GetBlocksRangeByTopoheight = "get_blocks_range_by_topoheight",
     GetBlocksRangeByHeight = "get_blocks_range_by_height",
@@ -791,6 +814,8 @@ export declare enum RPCMethod {
     GetContractBalance = "get_contract_balance",
     GetContractBalanceAtTopoheight = "get_contract_balance_at_topoheight",
     GetContractAssets = "get_contract_assets",
+    GetContracts = "get_contracts",
+    GetContractDataEntries = "get_contract_data_entries",
     GetP2PBlockPropagation = "get_p2p_block_propagation",
     GetBlockTemplate = "get_block_template",
     GetMinerWork = "get_miner_work",
@@ -806,7 +831,8 @@ export declare enum RPCEvent {
     TransactionAddedInMempool = "transaction_added_in_mempool",
     TransactionExecuted = "transaction_executed",
     InvokeContract = "invoke_contract",
-    ContractTransfer = "contract_transfer",
+    ContractTransfers = "contract_transfers",
+    InvokeContractError = "invoke_contract_error",
     ContractEvent = "contract_event",
     DeployContract = "deploy_contract",
     NewAsset = "new_asset",

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

@@ -2,33 +2,103 @@ import { RPCEvent } from './types';
 import * as types from './types';
 import { WSRPC } from '../rpc/websocket';
 export interface DaemonEventsData {
-    [RPCEvent.NewBlock]: types.Block;
-    [RPCEvent.BlockOrdered]: types.BlockOrdered;
-    [RPCEvent.BlockOrphaned]: types.BlockOrphaned;
-    [RPCEvent.StableHeightChanged]: types.StableHeightChanged;
-    [RPCEvent.StableTopoHeightChanged]: types.StableTopoHeightChanged;
-    [RPCEvent.TransactionOrphaned]: types.TransactionResponse;
-    [RPCEvent.TransactionAddedInMempool]: types.MempoolTransactionSummary;
-    [RPCEvent.TransactionExecuted]: types.TransactionExecuted;
-    [RPCEvent.InvokeContract]: types.InvokeContract;
-    [RPCEvent.ContractTransfer]: types.ContractTransfer;
-    [RPCEvent.ContractEvent]: types.ContractEvent;
-    [RPCEvent.DeployContract]: types.NewContract;
-    [RPCEvent.NewAsset]: types.AssetWithData;
-    [RPCEvent.PeerConnected]: types.Peer;
-    [RPCEvent.PeerDisconnected]: types.Peer;
-    [RPCEvent.PeerStateUpdated]: types.Peer;
-    [RPCEvent.PeerPeerListUpdated]: types.PeerPeerListUpdated;
-    [RPCEvent.PeerPeerDisconnected]: types.PeerPeerDisconnected;
-    [RPCEvent.NewBlockTemplate]: types.GetBlockTemplateResult;
+    [RPCEvent.NewBlock]: {
+        params: null;
+        returnType: types.Block;
+    };
+    [RPCEvent.BlockOrdered]: {
+        params: null;
+        returnType: types.BlockOrdered;
+    };
+    [RPCEvent.BlockOrphaned]: {
+        params: null;
+        returnType: types.BlockOrphaned;
+    };
+    [RPCEvent.StableHeightChanged]: {
+        params: null;
+        returnType: types.StableHeightChanged;
+    };
+    [RPCEvent.StableTopoHeightChanged]: {
+        params: null;
+        returnType: types.StableTopoHeightChanged;
+    };
+    [RPCEvent.TransactionOrphaned]: {
+        params: null;
+        returnType: types.TransactionResponse;
+    };
+    [RPCEvent.TransactionAddedInMempool]: {
+        params: null;
+        returnType: types.MempoolTransactionSummary;
+    };
+    [RPCEvent.TransactionExecuted]: {
+        params: null;
+        returnType: types.TransactionExecuted;
+    };
+    [RPCEvent.InvokeContract]: {
+        params: {
+            contract: string;
+        };
+        returnType: types.InvokeContract;
+    };
+    [RPCEvent.ContractTransfers]: {
+        params: {
+            address: string;
+        };
+        returnType: types.ContractTransfers;
+    };
+    [RPCEvent.InvokeContractError]: {
+        params: {
+            address: string;
+        };
+        returnType: null;
+    };
+    [RPCEvent.ContractEvent]: {
+        params: {
+            contract: string;
+            id: number;
+        };
+        returnType: types.ContractEvent;
+    };
+    [RPCEvent.DeployContract]: {
+        params: null;
+        returnType: types.NewContract;
+    };
+    [RPCEvent.NewAsset]: {
+        params: null;
+        returnType: types.NewAsset;
+    };
+    [RPCEvent.PeerConnected]: {
+        params: null;
+        returnType: types.Peer;
+    };
+    [RPCEvent.PeerDisconnected]: {
+        params: null;
+        returnType: types.Peer;
+    };
+    [RPCEvent.PeerStateUpdated]: {
+        params: null;
+        returnType: types.Peer;
+    };
+    [RPCEvent.PeerPeerListUpdated]: {
+        params: null;
+        returnType: types.PeerPeerListUpdated;
+    };
+    [RPCEvent.PeerPeerDisconnected]: {
+        params: null;
+        returnType: types.PeerPeerDisconnected;
+    };
+    [RPCEvent.NewBlockTemplate]: {
+        params: null;
+        returnType: types.GetBlockTemplateResult;
+    };
 }
 export declare class DaemonMethods {
     ws: WSRPC;
     prefix: string;
     constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
-    closeListener<K extends keyof DaemonEventsData>(event: K, listener: (data?: DaemonEventsData[K], err?: Error) => void): void;
-    listen<K extends keyof DaemonEventsData>(event: K, listener: (data?: DaemonEventsData[K], err?: Error) => void): void;
+    removeListener<K extends keyof DaemonEventsData>(event: K, params: DaemonEventsData[K]["params"], listener: (data?: DaemonEventsData[K]["returnType"], err?: Error) => void): void;
+    addListener<K extends keyof DaemonEventsData>(event: K, params: DaemonEventsData[K]["params"], listener: (data?: DaemonEventsData[K]["returnType"], err?: Error) => void): void;
     getVersion(): Promise<string>;
     getHeight(): Promise<number>;
     getTopoheight(): Promise<number>;
@@ -70,6 +140,7 @@ export declare class DaemonMethods {
     getMempoolSummary(params?: types.GetMempoolParams): Promise<types.GetMempoolSummaryResult>;
     getMempoolCache(address: string): Promise<types.GetMempoolCacheResult>;
     getEstimatedFeeRates(): Promise<types.FeeRatesEstimated>;
+    getEstimatedFeePerKB(): Promise<types.PredicatedBaseFeeResult>;
     getDAGOrder(params: types.TopoheightRangeParams): Promise<string[]>;
     getBlocksRangeByTopoheight(params: types.TopoheightRangeParams): Promise<types.Block[]>;
     getBlocksRangeByHeight(params: types.HeightRangeParams): Promise<types.Block[]>;
@@ -97,6 +168,8 @@ export declare class DaemonMethods {
     getContractBalance(params: types.GetContractBalanceParams): Promise<types.GetContractBalanceResult>;
     getContractBalanceAtTopoheight(params: types.GetContractBalanceAtTopoheightParams): Promise<types.GetContractBalanceAtTopoheightResult>;
     getContractAssets(params: types.GetContractBalancesParams): Promise<string[]>;
+    getContracts(params: types.GetAccountsParams): Promise<string[]>;
+    getContractDataEntries(params: types.GetContractDataEntriesParams): Promise<unknown>;
     getP2PBlockPropagation(params: types.GetP2pBlockPropagationParams): Promise<types.P2pBlockPropagationResult>;
     getBlockTemplate(address: string): Promise<string>;
     getMinerWork(params: types.GetMinerWorkParams): Promise<types.GetMinerWorkResult>;

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

@@ -15,10 +15,10 @@ export declare class WSRPC {
     socket: WebSocket;
     methodIdIncrement: number;
     callTimeout: number;
-    events: Map<string, EventData>;
+    events: Map<any, EventData>;
     constructor(endpoint: string, options?: ClientOptions | ClientRequestArgs);
-    closeListener(event: string, listener: EventDataListener): Promise<void>;
-    listen(event: string, listener: EventDataListener): Promise<void>;
+    removeListener(event: any, listener: EventDataListener): Promise<void>;
+    addListener(event: any, listener: EventDataListener): Promise<void>;
     rawCall<T>(id: number, body: string): Promise<T>;
     dataCall<T>(method: string, params?: any, idRefObj?: IdRefObj): Promise<T>;
     batchCall(requests: RPCRequest[]): Promise<({} | Error)[]>;

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

@@ -301,6 +301,15 @@ export interface SearchTransactionResult {
     index?: number;
     is_raw_search: boolean;
 }
+export interface SyncError {
+    message: string;
+}
+export interface TrackAsset {
+    asset: string;
+}
+export interface UntrackAsset {
+    asset: string;
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetNetwork = "get_network",
@@ -351,5 +360,8 @@ export declare enum RPCEvent {
     Rescan = "rescan",
     HistorySynced = "history_synced",
     Online = "online",
-    Offline = "offline"
+    Offline = "offline",
+    SyncError = "sync_error",
+    TrackAsset = "track_asset",
+    UntrackAsset = "untrack_asset"
 }

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

@@ -4,22 +4,58 @@ import { RPCEvent } from './types';
 import * as types from './types';
 import { Element } from '../data/element';
 export interface WalletEventsData {
-    [RPCEvent.NewTopoheight]: types.NewTopoheightResult;
-    [RPCEvent.NewAsset]: daemonTypes.AssetWithData;
-    [RPCEvent.NewTransaction]: types.TransactionEntry;
-    [RPCEvent.BalanceChanged]: types.BalanceChangedResult;
-    [RPCEvent.Rescan]: types.RescanResult;
-    [RPCEvent.HistorySynced]: types.HistorySyncedResult;
-    [RPCEvent.Online]: void;
-    [RPCEvent.Offline]: void;
+    [RPCEvent.NewTopoheight]: {
+        params: null;
+        returnType: types.NewTopoheightResult;
+    };
+    [RPCEvent.NewAsset]: {
+        params: null;
+        returnType: daemonTypes.AssetWithData;
+    };
+    [RPCEvent.NewTransaction]: {
+        params: null;
+        returnType: types.TransactionEntry;
+    };
+    [RPCEvent.BalanceChanged]: {
+        params: null;
+        returnType: types.BalanceChangedResult;
+    };
+    [RPCEvent.Rescan]: {
+        params: null;
+        returnType: types.RescanResult;
+    };
+    [RPCEvent.HistorySynced]: {
+        params: null;
+        returnType: types.HistorySyncedResult;
+    };
+    [RPCEvent.Online]: {
+        params: null;
+        returnType: void;
+    };
+    [RPCEvent.Offline]: {
+        params: null;
+        returnType: void;
+    };
+    [RPCEvent.SyncError]: {
+        params: null;
+        returnType: types.SyncError;
+    };
+    [RPCEvent.TrackAsset]: {
+        params: null;
+        returnType: types.TrackAsset;
+    };
+    [RPCEvent.UntrackAsset]: {
+        params: null;
+        returnType: types.UntrackAsset;
+    };
 }
 export declare class WalletMethods {
     ws: WSRPC;
     prefix: string;
     constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
-    closeListener<K extends keyof WalletEventsData>(event: K, listener: (data?: WalletEventsData[K], err?: Error) => void): void;
-    listen<K extends keyof WalletEventsData>(event: K, listener: (data?: WalletEventsData[K], err?: Error) => void): void;
+    removeListener<K extends keyof WalletEventsData>(event: K, params: WalletEventsData[K]["params"], listener: (data?: WalletEventsData[K]["returnType"], err?: Error) => void): void;
+    addListener<K extends keyof WalletEventsData>(event: K, params: WalletEventsData[K]["params"], listener: (data?: WalletEventsData[K]["returnType"], err?: Error) => void): void;
     getVersion(): Promise<string>;
     getNetwork(): Promise<string>;
     getNonce(): Promise<number>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.11.24",
+  "version": "0.11.26",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "exports": {