@xelis/sdk 0.10.12 → 0.11.1

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

@@ -1,30 +1,34 @@
-import { MessageEvent } from 'ws';
+import { RPCEvent, RPCEventResult } from './types';
 import * as types from './types';
 import { WSRPC } from '../rpc/websocket';
+export interface DaemonEventsData {
+    [RPCEvent.NewBlock]: types.Block & RPCEventResult;
+    [RPCEvent.BlockOrdered]: types.BlockOrdered & RPCEventResult;
+    [RPCEvent.BlockOrphaned]: types.BlockOrphaned & RPCEventResult;
+    [RPCEvent.StableHeightChanged]: types.StableHeightChanged & RPCEventResult;
+    [RPCEvent.StableTopoHeightChanged]: types.StableTopoHeightChanged & RPCEventResult;
+    [RPCEvent.TransactionOrphaned]: types.TransactionResponse & RPCEventResult;
+    [RPCEvent.TransactionAddedInMempool]: types.MempoolTransactionSummary & RPCEventResult;
+    [RPCEvent.TransactionExecuted]: types.TransactionExecuted & RPCEventResult;
+    [RPCEvent.InvokeContract]: types.InvokeContract & RPCEventResult;
+    [RPCEvent.ContractTransfer]: types.ContractTransfer & RPCEventResult;
+    [RPCEvent.ContractEvent]: types.ContractEvent & RPCEventResult;
+    [RPCEvent.DeployContract]: types.NewContract & RPCEventResult;
+    [RPCEvent.NewAsset]: types.AssetWithData & RPCEventResult;
+    [RPCEvent.PeerConnected]: types.Peer & RPCEventResult;
+    [RPCEvent.PeerDisconnected]: number & RPCEventResult;
+    [RPCEvent.PeerStateUpdated]: types.Peer & RPCEventResult;
+    [RPCEvent.PeerPeerListUpdated]: types.PeerPeerListUpdated & RPCEventResult;
+    [RPCEvent.PeerPeerDisconnected]: types.PeerPeerDisconnected & RPCEventResult;
+    [RPCEvent.NewBlockTemplate]: types.GetBlockTemplateResult & RPCEventResult;
+}
 export declare class DaemonMethods {
     ws: WSRPC;
     prefix: string;
     constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
-    onNewBlock(onData: (msgEvent: MessageEvent, data?: types.Block & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onBlockOrdered(onData: (msgEvent: MessageEvent, data?: types.BlockOrdered & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onBlockOrphaned(onData: (msgEvent: MessageEvent, data?: types.BlockOrphaned & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onStableHeightChanged(onData: (msgEvent: MessageEvent, data?: types.StableHeightChanged & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onStableTopoHeightChanged(onData: (msgEvent: MessageEvent, data?: types.StableTopoHeightChanged & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onTransactionOrphaned(onData: (msgEvent: MessageEvent, data?: types.TransactionResponse & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onTransactionAddedInMempool(onData: (msgEvent: MessageEvent, data?: types.MempoolTransactionSummary & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onTransactionExecuted(onData: (msgEvent: MessageEvent, data?: types.TransactionExecuted & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onInvokeContract(contract: string, onData: (msgEvent: MessageEvent, data?: types.InvokeContract & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onContractTransfer(address: string, onData: (msgEvent: MessageEvent, data?: types.ContractTransfer & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onContractEvent(contract: string, id: number, onData: (msgEvent: MessageEvent, data?: types.ContractEvent & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onDeployContract(onData: (msgEvent: MessageEvent, data?: types.NewContract & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewAsset(onData: (msgEvent: MessageEvent, data?: types.AssetWithData & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerConnected(onData: (msgEvent: MessageEvent, data?: types.Peer & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerDisconnected(onData: (msgEvent: MessageEvent, data?: number & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerStateUpdated(onData: (msgEvent: MessageEvent, data?: types.Peer & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerPeerListUpdated(onData: (msgEvent: MessageEvent, data?: types.PeerPeerListUpdated & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onPeerPeerDisconnected(onData: (msgEvent: MessageEvent, data?: types.PeerPeerDisconnected & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewBlockTemplate(onData: (msgEvent: MessageEvent, data?: types.GetBlockTemplateResult & types.RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    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;
     getVersion(): Promise<string>;
     getHeight(): Promise<number>;
     getTopoheight(): Promise<number>;
@@ -96,6 +100,6 @@ export declare class DaemonMethods {
 }
 export declare class WS extends WSRPC {
     methods: DaemonMethods;
-    constructor();
+    constructor(endpoint: string);
 }
 export default WS;

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

@@ -4,7 +4,7 @@ import DaemonWS from '../daemon/websocket';
 import { RPCEvent } from '../daemon/types';
 export declare const INITIATING = -1;
 interface NodeSocket {
-    daemon: DaemonWS;
+    daemon?: DaemonWS;
     err?: Error;
     readyState: number;
 }
@@ -16,7 +16,7 @@ export declare const NodeSocketProvider: (props: PropsWithChildren<NodeSocketPro
 interface NodeSocketSubscribeProps<T> {
     event: RPCEvent;
     onLoad: () => void;
-    onData: (msgEvent: MessageEvent, data?: T, err?: Error | undefined) => void;
+    onData: (event?: MessageEvent, data?: T, err?: Error | undefined) => void;
 }
 export declare const useNodeSocketSubscribe: ({ event, onLoad, onData }: NodeSocketSubscribeProps<any>, dependencies: React.DependencyList) => void;
 export declare const useNodeSocket: () => NodeSocket;

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

@@ -1,34 +1,26 @@
 /// <reference types="node" />
+import { RPCRequest } from "./types";
 import { ClientOptions, MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
 import { ClientRequestArgs } from 'http';
-import { RPCRequest } from './types';
-export type EventWithParams = {
-    [event: string]: {};
-};
-export type EventKey = string | EventWithParams;
 export type IdRefObj = {
     id?: number;
 };
+export type EventDataListener = (data?: any, err?: Error) => void;
+type EventData = {
+    onMessage: (event: MessageEvent) => void;
+    listeners: EventDataListener[];
+};
 export declare class WSRPC {
-    endpoint: string;
-    socket?: WebSocket;
-    timeout: number;
-    unsubscribeSuspense: number;
-    reconnectOnConnectionLoss: boolean;
-    maxConnectionTries: number;
-    options?: ClientOptions | ClientRequestArgs;
-    connectionTries: number;
+    socket: WebSocket;
     methodIdIncrement: number;
-    private events;
-    constructor(options?: ClientOptions | ClientRequestArgs);
-    connect(endpoint: string): Promise<unknown>;
-    tryReconnect(): void;
-    close(): void;
-    private clearEvent;
-    closeAllListens(event: EventKey): Promise<void>;
-    listenEvent<T>(event: EventKey, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
-    batchCall(requests: RPCRequest[]): Promise<any[]>;
+    callTimeout: number;
+    events: Map<string, EventData>;
+    constructor(endpoint: string, options?: ClientOptions | ClientRequestArgs);
+    closeListener(event: string, listener: EventDataListener): Promise<void>;
+    listen(event: string, 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<any[]>;
 }
+export {};

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

@@ -1,22 +1,26 @@
 import { WSRPC } from '../rpc/websocket';
-import { MessageEvent } from 'ws';
 import { RPCEventResult } from '../daemon/types';
 import * as daemonTypes from '../daemon/types';
+import { RPCEvent } from './types';
 import * as types from './types';
 import { Element } from '../data/element';
+export interface WalletEventsData {
+    [RPCEvent.NewTopoheight]: types.NewTopoheightResult & RPCEventResult;
+    [RPCEvent.NewAsset]: daemonTypes.AssetWithData & RPCEventResult;
+    [RPCEvent.NewTransaction]: types.TransactionEntry & RPCEventResult;
+    [RPCEvent.BalanceChanged]: types.BalanceChangedResult & RPCEventResult;
+    [RPCEvent.Rescan]: types.RescanResult & RPCEventResult;
+    [RPCEvent.HistorySynced]: types.HistorySyncedResult & RPCEventResult;
+    [RPCEvent.Online]: RPCEventResult;
+    [RPCEvent.Offline]: RPCEventResult;
+}
 export declare class WalletMethods {
     ws: WSRPC;
     prefix: string;
     constructor(ws: WSRPC, prefix?: string);
     dataCall<T>(method: string, params?: any): Promise<T>;
-    onNewTopoheight(onData: (msgEvent: MessageEvent, data?: types.NewTopoheightResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewAsset(onData: (msgEvent: MessageEvent, data?: daemonTypes.AssetWithData & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onNewTransaction(onData: (msgEvent: MessageEvent, data?: types.TransactionEntry & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onBalanceChanged(onData: (msgEvent: MessageEvent, data?: types.BalanceChangedResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onRescan(onData: (msgEvent: MessageEvent, data?: types.RescanResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onHistorySynced(onData: (msgEvent: MessageEvent, data?: types.HistorySyncedResult & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onOnline(onData: (msgEvent: MessageEvent, data?: RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    onOffline(onData: (msgEvent: MessageEvent, data?: RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    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;
     getVersion(): Promise<string>;
     getNetwork(): Promise<string>;
     getNonce(): Promise<number>;
@@ -62,6 +66,6 @@ export declare class WalletMethods {
 }
 export declare class WS extends WSRPC {
     methods: WalletMethods;
-    constructor(username: string, password: string);
+    constructor(endpoint: string, username: string, password: string);
 }
 export default WS;

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

@@ -5,7 +5,7 @@ import { ApplicationData } from './types';
 export declare class WS extends WSRPC {
     daemon: DaemonMethods;
     wallet: WalletMethods;
-    constructor();
+    constructor(endpoint: string);
     authorize(app: ApplicationData): Promise<unknown>;
 }
 export default WS;

package/package.json

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