@xelis/sdk 0.11.25 → 0.11.27

package/dist/cjs/daemon/types.js

@@ -103,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);

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/types.js

@@ -100,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);

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/types.d.ts

@@ -299,12 +299,15 @@ export interface AccountHistory {
     };
     burn?: {
         amount: number;
+        asset: string;
     };
     outgoing?: {
         to: string;
+        asset: string;
     };
     incoming?: {
         from: string;
+        asset: string;
     };
     multi_sig?: {
         participants: string[];
@@ -313,8 +316,11 @@ export interface AccountHistory {
     invoke_contract?: {
         contract: string;
         entry_id: number;
+        deposits: string[];
+    };
+    deploy_contract?: {
+        deposits?: string[];
     };
-    deploy_contract?: {};
 }
 export interface PeerPeerListUpdated {
     peer_id: string;
@@ -358,6 +364,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 +624,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 {
@@ -820,7 +837,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>;

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.25",
+  "version": "0.11.27",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "exports": {