@xelis/sdk 0.3.4 → 0.4.0

package/daemon/rpc.d.ts

@@ -1,34 +1,32 @@
-import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetLastBalanceResult, P2PStatusResult, RPCMethod, RPCResponse, Transaction, GetLastBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from './types';
-declare class RPC {
-    endpoint: string;
-    constructor(endpoint: string);
-    post<T>(method: RPCMethod, params?: any): Promise<RPCResponse<T>>;
-    getVersion(): Promise<RPCResponse<string>>;
-    getInfo(): Promise<RPCResponse<GetInfoResult>>;
-    getHeight(): Promise<RPCResponse<number>>;
-    getTopoHeight(): Promise<RPCResponse<number>>;
-    getStableHeight(): Promise<RPCResponse<number>>;
-    getBlockTemplate(address: string): Promise<RPCResponse<string>>;
-    getBlockAtTopoHeight(params: GetBlockAtTopoHeightParams): Promise<RPCResponse<Block>>;
-    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<RPCResponse<Block[]>>;
-    getBlockByHash(params: GetBlockByHashParams): Promise<RPCResponse<Block>>;
-    getTopBlock(params: GetTopBlockParams): Promise<RPCResponse<Block>>;
-    getNonce(address: string): Promise<RPCResponse<number>>;
-    getLastBalance(params: GetLastBalanceParams): Promise<RPCResponse<GetLastBalanceResult>>;
-    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<RPCResponse<Balance>>;
-    getAssets(): Promise<RPCResponse<string[]>>;
-    countTransactions(): Promise<RPCResponse<number>>;
-    countAssets(): Promise<RPCResponse<number>>;
-    getTips(): Promise<RPCResponse<string[]>>;
-    p2pStatus(): Promise<RPCResponse<P2PStatusResult>>;
-    getDAGOrder(params: TopoHeightRangeParams): Promise<RPCResponse<string[]>>;
-    getMemPool(): Promise<RPCResponse<Transaction[]>>;
-    getTransaction(hash: string): Promise<RPCResponse<Transaction>>;
-    getTransactions(txHashes: string[]): Promise<RPCResponse<Transaction[]>>;
-    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<RPCResponse<Block[]>>;
-    getBlocksRangeByHeight(params: HeightRangeParams): Promise<RPCResponse<Block[]>>;
-    getAccounts(params: GetAccountsParams): Promise<RPCResponse<string[]>>;
-    submitBlock(blockTemplate: string): Promise<RPCResponse<boolean>>;
-    submitTransaction(hexData: string): Promise<RPCResponse<boolean>>;
+import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetLastBalanceResult, P2PStatusResult, Transaction, GetLastBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from '../lib/types';
+import { RPC as BaseRPC } from '../lib/rpc';
+declare class RPC extends BaseRPC {
+    getVersion(): Promise<import("../lib/types").RPCResponse<string>>;
+    getInfo(): Promise<import("../lib/types").RPCResponse<GetInfoResult>>;
+    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<string>>;
+    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>>;
+    getNonce(address: string): Promise<import("../lib/types").RPCResponse<number>>;
+    getLastBalance(params: GetLastBalanceParams): Promise<import("../lib/types").RPCResponse<GetLastBalanceResult>>;
+    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<Balance>>;
+    getAssets(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    countTransactions(): Promise<import("../lib/types").RPCResponse<number>>;
+    countAssets(): Promise<import("../lib/types").RPCResponse<number>>;
+    getTips(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    p2pStatus(): Promise<import("../lib/types").RPCResponse<P2PStatusResult>>;
+    getDAGOrder(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getMemPool(): Promise<import("../lib/types").RPCResponse<Transaction[]>>;
+    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<Transaction>>;
+    getTransactions(txHashes: string[]): Promise<import("../lib/types").RPCResponse<Transaction[]>>;
+    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getBlocksRangeByHeight(params: HeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getAccounts(params: GetAccountsParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    submitBlock(blockTemplate: string): Promise<import("../lib/types").RPCResponse<boolean>>;
+    submitTransaction(hexData: string): Promise<import("../lib/types").RPCResponse<boolean>>;
 }
 export default RPC;

package/daemon/rpc.js

@@ -1,107 +1,86 @@
-import { RPCMethod } from './types';
-class RPC {
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-    }
-    async post(method, params) {
-        try {
-            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
-            const res = await fetch(this.endpoint, { method: `POST`, body });
-            if (res.ok) {
-                const data = await res.json();
-                if (data.error) {
-                    return Promise.reject(new Error(data.error.message));
-                }
-                return Promise.resolve(data);
-            }
-            else {
-                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
-            }
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
-    }
+import { DaemonRPCMethod } from '../lib/types';
+import { RPC as BaseRPC } from '../lib/rpc';
+class RPC extends BaseRPC {
     getVersion() {
-        return this.post(RPCMethod.GetVersion);
+        return this.post(DaemonRPCMethod.GetVersion);
     }
     getInfo() {
-        return this.post(RPCMethod.GetInfo);
+        return this.post(DaemonRPCMethod.GetInfo);
     }
     getHeight() {
-        return this.post(RPCMethod.GetHeight);
+        return this.post(DaemonRPCMethod.GetHeight);
     }
     getTopoHeight() {
-        return this.post(RPCMethod.GetTopoHeight);
+        return this.post(DaemonRPCMethod.GetTopoHeight);
     }
     getStableHeight() {
-        return this.post(RPCMethod.GetStableHeight);
+        return this.post(DaemonRPCMethod.GetStableHeight);
     }
     getBlockTemplate(address) {
-        return this.post(RPCMethod.GetBlockTemplate, { address });
+        return this.post(DaemonRPCMethod.GetBlockTemplate, { address });
     }
     getBlockAtTopoHeight(params) {
-        return this.post(RPCMethod.GetBlockAtTopoHeight, params);
+        return this.post(DaemonRPCMethod.GetBlockAtTopoHeight, params);
     }
     getBlocksAtHeight(params) {
-        return this.post(RPCMethod.GetBlocksAtHeight, params);
+        return this.post(DaemonRPCMethod.GetBlocksAtHeight, params);
     }
     getBlockByHash(params) {
-        return this.post(RPCMethod.GetBlockByHash, params);
+        return this.post(DaemonRPCMethod.GetBlockByHash, params);
     }
     getTopBlock(params) {
-        return this.post(RPCMethod.GetTopBlock, params);
+        return this.post(DaemonRPCMethod.GetTopBlock, params);
     }
     getNonce(address) {
-        return this.post(RPCMethod.GetNonce, { address });
+        return this.post(DaemonRPCMethod.GetNonce, { address });
     }
     getLastBalance(params) {
-        return this.post(RPCMethod.GetLastBalance, params);
+        return this.post(DaemonRPCMethod.GetLastBalance, params);
     }
     getBalanceAtTopoHeight(params) {
-        return this.post(RPCMethod.GetBalanceAtTopoHeight, params);
+        return this.post(DaemonRPCMethod.GetBalanceAtTopoHeight, params);
     }
     getAssets() {
-        return this.post(RPCMethod.GetAssets);
+        return this.post(DaemonRPCMethod.GetAssets);
     }
     countTransactions() {
-        return this.post(RPCMethod.CountTransactions);
+        return this.post(DaemonRPCMethod.CountTransactions);
     }
     countAssets() {
-        return this.post(RPCMethod.CountAssets);
+        return this.post(DaemonRPCMethod.CountAssets);
     }
     getTips() {
-        return this.post(RPCMethod.GetTips);
+        return this.post(DaemonRPCMethod.GetTips);
     }
     p2pStatus() {
-        return this.post(RPCMethod.P2PStatus);
+        return this.post(DaemonRPCMethod.P2PStatus);
     }
     getDAGOrder(params) {
-        return this.post(RPCMethod.GetDAGOrder, params);
+        return this.post(DaemonRPCMethod.GetDAGOrder, params);
     }
     getMemPool() {
-        return this.post(RPCMethod.GetMempool);
+        return this.post(DaemonRPCMethod.GetMempool);
     }
     getTransaction(hash) {
-        return this.post(RPCMethod.GetTransaction, { hash });
+        return this.post(DaemonRPCMethod.GetTransaction, { hash });
     }
     getTransactions(txHashes) {
-        return this.post(RPCMethod.GetTransactions, { tx_hashes: txHashes });
+        return this.post(DaemonRPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
     getBlocksRangeByTopoheight(params) {
-        return this.post(RPCMethod.GetBlocksRangeByTopoheight, params);
+        return this.post(DaemonRPCMethod.GetBlocksRangeByTopoheight, params);
     }
     getBlocksRangeByHeight(params) {
-        return this.post(RPCMethod.GetBlocksRangeByHeight, params);
+        return this.post(DaemonRPCMethod.GetBlocksRangeByHeight, params);
     }
     getAccounts(params) {
-        return this.post(RPCMethod.GetAccounts, params);
+        return this.post(DaemonRPCMethod.GetAccounts, params);
     }
     submitBlock(blockTemplate) {
-        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
+        return this.post(DaemonRPCMethod.SubmitBlock, { block_template: blockTemplate });
     }
     submitTransaction(hexData) {
-        return this.post(RPCMethod.SubmitTransaction, { data: hexData });
+        return this.post(DaemonRPCMethod.SubmitTransaction, { data: hexData });
     }
 }
 export default RPC;

package/daemon/websocket.d.ts

@@ -1,28 +1,12 @@
-/// <reference types="node" />
 import { MessageEvent } from 'ws';
-import WebSocket from 'isomorphic-ws';
-import { Block, RPCResponse, GetInfoResult, RPCEvent, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetLastBalanceResult, HeightRangeParams, BlockOrdered, GetLastBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from './types';
-declare class WS {
-    endpoint: string;
-    socket?: WebSocket;
-    timeout: number;
-    connected: boolean;
-    unsubscribeSuspense: number;
-    private events;
-    constructor();
-    connect(endpoint: string): Promise<unknown>;
-    close(code?: number | undefined, data?: string | Buffer | undefined): void;
-    onClose(cb: (event: WebSocket.CloseEvent) => void): void;
-    onError(cb: (err: WebSocket.ErrorEvent) => void): void;
-    private clearEvent;
-    closeAllListens(event: RPCEvent): Promise<void>;
-    listenEvent<T>(event: RPCEvent, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
+import { Block, GetInfoResult, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetLastBalanceResult, HeightRangeParams, BlockOrdered, GetLastBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from '../lib/types';
+import { WS as BaseWS } from '../lib/websocket';
+declare class WS extends BaseWS {
     onNewBlock(onData: (msgEvent: MessageEvent, data?: Block & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onTransactionAddedInMempool(onData: (msgEvent: MessageEvent, data?: Transaction & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onTransactionExecuted(onData: (msgEvent: MessageEvent, data?: Transaction & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onBlockOrdered(onData: (msgEvent: MessageEvent, data?: BlockOrdered & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    call<T>(method: string, params?: any): Promise<RPCResponse<T>>;
-    dataCall<T>(method: string, params?: any): Promise<T>;
+    getVersion(): Promise<string>;
     getInfo(): Promise<GetInfoResult>;
     getHeight(): Promise<number>;
     getTopoHeight(): Promise<number>;

package/daemon/websocket.js

@@ -1,140 +1,6 @@
-import WebSocket from 'isomorphic-ws';
-import to from 'await-to-js';
-import { RPCEvent, RPCMethod } from './types';
-function createRequestMethod(method, params) {
-    const id = Math.floor(Date.now() * Math.random());
-    const request = { id: id, jsonrpc: `2.0`, method };
-    if (params)
-        request.params = params;
-    const data = JSON.stringify(request);
-    return { data, id };
-}
-class WS {
-    constructor() {
-        this.endpoint = "";
-        this.timeout = 3000;
-        this.connected = false;
-        this.events = {};
-        this.unsubscribeSuspense = 1000;
-    }
-    connect(endpoint) {
-        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
-            this.socket.close();
-        }
-        return new Promise((resolve, reject) => {
-            this.socket = new WebSocket(endpoint);
-            this.endpoint = endpoint;
-            this.socket.addEventListener(`open`, (event) => {
-                this.connected = true;
-                resolve(event);
-            });
-            this.socket.addEventListener(`close`, () => {
-                this.connected = false;
-                reject();
-            });
-            this.socket.addEventListener(`error`, (err) => {
-                this.connected = false;
-                reject(err);
-            });
-        });
-    }
-    close(code, data) {
-        this.socket && this.socket.close(code, data);
-    }
-    onClose(cb) {
-        if (!this.socket)
-            return;
-        this.socket.addEventListener(`close`, (event) => {
-            cb(event);
-        });
-    }
-    onError(cb) {
-        if (!this.socket)
-            return;
-        this.socket.addEventListener(`error`, (err) => {
-            cb(err);
-        });
-    }
-    clearEvent(event) {
-        this.events[event].listeners.forEach(listener => {
-            this.socket && this.socket.removeEventListener(`message`, listener);
-        });
-        Reflect.deleteProperty(this.events, event);
-    }
-    async closeAllListens(event) {
-        if (this.events[event]) {
-            const [err, _] = await to(this.call(`unsubscribe`, { notify: event }));
-            if (err)
-                return Promise.reject(err);
-            this.clearEvent(event);
-        }
-        return Promise.resolve();
-    }
-    async listenEvent(event, onData) {
-        const onMessage = (msgEvent) => {
-            if (this.events[event]) {
-                const { id } = this.events[event];
-                if (typeof msgEvent.data === `string`) {
-                    try {
-                        const data = JSON.parse(msgEvent.data);
-                        if (data.id === id) {
-                            if (data.error) {
-                                onData(msgEvent, undefined, new Error(data.error.message));
-                            }
-                            else {
-                                onData(msgEvent, data.result, undefined);
-                            }
-                        }
-                    }
-                    catch (_a) {
-                        // can't parse json -- do nothing
-                    }
-                }
-            }
-        };
-        if (this.events[event]) {
-            const { unsubscribeTimeoutId } = this.events[event];
-            if (unsubscribeTimeoutId) {
-                // clear timeout to unsubscribe 
-                // because we got a new registered event and want to cancel the pending unsubscribe grace period
-                clearTimeout(unsubscribeTimeoutId);
-            }
-            this.events[event].listeners.push(onMessage);
-        }
-        else {
-            // important if multiple listenEvent are called without await atleast we store listener before getting id
-            this.events[event] = { listeners: [onMessage] };
-            const [err, res] = await to(this.call(`subscribe`, { notify: event }));
-            if (err) {
-                this.clearEvent(event);
-                return Promise.reject(err);
-            }
-            this.events[event].id = res.id;
-        }
-        this.socket && this.socket.addEventListener(`message`, onMessage);
-        const closeListen = () => {
-            const eventData = this.events[event];
-            if (eventData) {
-                const listeners = eventData.listeners;
-                for (let i = 0; i < listeners.length; i++) {
-                    if (listeners[i] === onMessage) {
-                        listeners.splice(i, 1);
-                        break;
-                    }
-                }
-                if (listeners.length === 0) {
-                    this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
-                        // no more listener so we unsubscribe from daemon websocket
-                        this.call(`unsubscribe`, { notify: event });
-                        Reflect.deleteProperty(this.events, event);
-                    }, this.unsubscribeSuspense);
-                }
-            }
-            this.socket && this.socket.removeEventListener(`message`, onMessage);
-            return Promise.resolve();
-        };
-        return Promise.resolve(closeListen);
-    }
+import { RPCEvent, DaemonRPCMethod } from '../lib/types';
+import { WS as BaseWS } from '../lib/websocket';
+class WS extends BaseWS {
     onNewBlock(onData) {
         return this.listenEvent(RPCEvent.NewBlock, onData);
     }
@@ -147,114 +13,83 @@ class WS {
     onBlockOrdered(onData) {
         return this.listenEvent(RPCEvent.BlockOrdered, onData);
     }
-    call(method, params) {
-        return new Promise((resolve, reject) => {
-            const { data, id } = createRequestMethod(method, params);
-            let timeoutId = null;
-            const onMessage = (msgEvent) => {
-                if (typeof msgEvent.data === `string`) {
-                    const data = JSON.parse(msgEvent.data);
-                    if (data.id === id) {
-                        clearTimeout(timeoutId);
-                        this.socket && this.socket.removeEventListener(`message`, onMessage);
-                        if (data.error)
-                            return reject(new Error(data.error.message));
-                        else
-                            resolve(data);
-                    }
-                }
-            };
-            // make sure you listen before sending data
-            this.socket && this.socket.addEventListener(`message`, onMessage); // we don't use { once: true } option because of timeout feature
-            timeoutId = setTimeout(() => {
-                this.socket && this.socket.removeEventListener(`message`, onMessage);
-                reject(new Error(`timeout`));
-            }, this.timeout);
-            this.socket && this.socket.send(data);
-        });
-    }
-    dataCall(method, params) {
-        return new Promise(async (resolve, reject) => {
-            const [err, res] = await to(this.call(method, params));
-            if (err)
-                return reject(err);
-            return resolve(res.result);
-        });
+    getVersion() {
+        return this.dataCall(DaemonRPCMethod.GetVersion);
     }
     getInfo() {
-        return this.dataCall(RPCMethod.GetInfo);
+        return this.dataCall(DaemonRPCMethod.GetInfo);
     }
     getHeight() {
-        return this.dataCall(RPCMethod.GetHeight);
+        return this.dataCall(DaemonRPCMethod.GetHeight);
     }
     getTopoHeight() {
-        return this.dataCall(RPCMethod.GetTopoHeight);
+        return this.dataCall(DaemonRPCMethod.GetTopoHeight);
     }
     getStableHeight() {
-        return this.dataCall(RPCMethod.GetStableHeight);
+        return this.dataCall(DaemonRPCMethod.GetStableHeight);
     }
     getBlockTemplate(address) {
-        return this.dataCall(RPCMethod.GetBlockTemplate, { address });
+        return this.dataCall(DaemonRPCMethod.GetBlockTemplate, { address });
     }
     getBlockAtTopoHeight(params) {
-        return this.dataCall(RPCMethod.GetBlockAtTopoHeight, params);
+        return this.dataCall(DaemonRPCMethod.GetBlockAtTopoHeight, params);
     }
     getBlocksAtHeight(params) {
-        return this.dataCall(RPCMethod.GetBlocksAtHeight, params);
+        return this.dataCall(DaemonRPCMethod.GetBlocksAtHeight, params);
     }
     getBlockByHash(params) {
-        return this.dataCall(RPCMethod.GetBlockByHash, params);
+        return this.dataCall(DaemonRPCMethod.GetBlockByHash, params);
     }
     getTopBlock(params) {
-        return this.dataCall(RPCMethod.GetTopBlock, params);
+        return this.dataCall(DaemonRPCMethod.GetTopBlock, params);
     }
     getNonce(address) {
-        return this.dataCall(RPCMethod.GetNonce, { address });
+        return this.dataCall(DaemonRPCMethod.GetNonce, { address });
     }
     getLastBalance(params) {
-        return this.dataCall(RPCMethod.GetLastBalance, params);
+        return this.dataCall(DaemonRPCMethod.GetLastBalance, params);
     }
     getBalanceAtTopoHeight(params) {
-        return this.dataCall(RPCMethod.GetBalanceAtTopoHeight, params);
+        return this.dataCall(DaemonRPCMethod.GetBalanceAtTopoHeight, params);
     }
     getAssets() {
-        return this.dataCall(RPCMethod.GetAssets);
+        return this.dataCall(DaemonRPCMethod.GetAssets);
     }
     countTransactions() {
-        return this.dataCall(RPCMethod.CountTransactions);
+        return this.dataCall(DaemonRPCMethod.CountTransactions);
     }
     getTips() {
-        return this.dataCall(RPCMethod.GetTips);
+        return this.dataCall(DaemonRPCMethod.GetTips);
     }
     p2pStatus() {
-        return this.dataCall(RPCMethod.P2PStatus);
+        return this.dataCall(DaemonRPCMethod.P2PStatus);
     }
     getDAGOrder(params) {
-        return this.dataCall(RPCMethod.GetDAGOrder, params);
+        return this.dataCall(DaemonRPCMethod.GetDAGOrder, params);
     }
     getMemPool() {
-        return this.dataCall(RPCMethod.GetMempool);
+        return this.dataCall(DaemonRPCMethod.GetMempool);
     }
     getTransaction(hash) {
-        return this.dataCall(RPCMethod.GetTransaction, { hash });
+        return this.dataCall(DaemonRPCMethod.GetTransaction, { hash });
     }
     getTransactions(txHashes) {
-        return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
+        return this.dataCall(DaemonRPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
     getBlocksRangeByTopoheight(params) {
-        return this.dataCall(RPCMethod.GetBlocksRangeByTopoheight, params);
+        return this.dataCall(DaemonRPCMethod.GetBlocksRangeByTopoheight, params);
     }
     getBlocksRangeByHeight(params) {
-        return this.dataCall(RPCMethod.GetBlocksRangeByHeight, params);
+        return this.dataCall(DaemonRPCMethod.GetBlocksRangeByHeight, params);
     }
     getAccounts(params) {
-        return this.dataCall(RPCMethod.GetAccounts, params);
+        return this.dataCall(DaemonRPCMethod.GetAccounts, params);
     }
     submitBlock(blockTemplate) {
-        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
+        return this.dataCall(DaemonRPCMethod.SubmitBlock, { block_template: blockTemplate });
     }
     submitTransaction(hexData) {
-        return this.dataCall(RPCMethod.SubmitTransaction, { data: hexData });
+        return this.dataCall(DaemonRPCMethod.SubmitTransaction, { data: hexData });
     }
 }
 export default WS;

package/lib/rpc.d.ts

@@ -0,0 +1,6 @@
+import { RPCResponse } from './types';
+export declare class RPC {
+    endpoint: string;
+    constructor(endpoint: string);
+    post<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+}

package/lib/rpc.js

@@ -0,0 +1,24 @@
+export class RPC {
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    async post(method, params) {
+        try {
+            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
+            const res = await fetch(this.endpoint, { method: `POST`, body });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.error) {
+                    return Promise.reject(new Error(data.error.message));
+                }
+                return Promise.resolve(data);
+            }
+            else {
+                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+}

package/{daemon → lib}/types.d.ts

@@ -135,7 +135,48 @@ export interface GetBlockByHashParams {
 export interface GetTopBlockParams {
     include_txs?: boolean;
 }
-export declare enum RPCMethod {
+export interface GetAddressParams {
+    integrated_data?: string;
+}
+export interface SplitAddressParams {
+    address: string;
+}
+export interface SplitAddressResult {
+    address: string;
+    integrated_data: string;
+}
+export interface BuildTransactionParams {
+    tx_type: TransactionData;
+    broadcast: boolean;
+    fee?: number;
+}
+export interface BuildTransactionResult {
+    hash: string;
+    data: Transaction;
+}
+export interface ListTransactionParams {
+    min_topoheight?: number;
+    max_topoheight?: number;
+    address?: string;
+    accept_incoming?: boolean;
+    accept_outgoing?: boolean;
+    accept_coinbase?: boolean;
+    accept_burn?: boolean;
+}
+export declare enum WalletRPCMethod {
+    GetVersion = "get_version",
+    GetNetwork = "get_network",
+    GetNonce = "get_nonce",
+    GetTopoheight = "get_topoheight",
+    GetAddress = "get_address",
+    SplitAddress = "split_address",
+    GetBalance = "get_balance",
+    GetTrackedAssets = "get_tracked_assets",
+    GetTransaction = "get_transaction",
+    BuildTransaction = "build_transaction",
+    ListTransactions = "list_transactions"
+}
+export declare enum DaemonRPCMethod {
     GetVersion = "get_version",
     GetInfo = "get_info",
     GetHeight = "get_height",

package/lib/types.js

@@ -0,0 +1,51 @@
+export var WalletRPCMethod;
+(function (WalletRPCMethod) {
+    WalletRPCMethod["GetVersion"] = "get_version";
+    WalletRPCMethod["GetNetwork"] = "get_network";
+    WalletRPCMethod["GetNonce"] = "get_nonce";
+    WalletRPCMethod["GetTopoheight"] = "get_topoheight";
+    WalletRPCMethod["GetAddress"] = "get_address";
+    WalletRPCMethod["SplitAddress"] = "split_address";
+    WalletRPCMethod["GetBalance"] = "get_balance";
+    WalletRPCMethod["GetTrackedAssets"] = "get_tracked_assets";
+    WalletRPCMethod["GetTransaction"] = "get_transaction";
+    WalletRPCMethod["BuildTransaction"] = "build_transaction";
+    WalletRPCMethod["ListTransactions"] = "list_transactions";
+})(WalletRPCMethod || (WalletRPCMethod = {}));
+export var DaemonRPCMethod;
+(function (DaemonRPCMethod) {
+    DaemonRPCMethod["GetVersion"] = "get_version";
+    DaemonRPCMethod["GetInfo"] = "get_info";
+    DaemonRPCMethod["GetHeight"] = "get_height";
+    DaemonRPCMethod["GetTopoHeight"] = "get_topoheight";
+    DaemonRPCMethod["GetStableHeight"] = "get_stableheight";
+    DaemonRPCMethod["GetBlockTemplate"] = "get_block_template";
+    DaemonRPCMethod["GetBlockAtTopoHeight"] = "get_block_at_topoheight";
+    DaemonRPCMethod["GetBlocksAtHeight"] = "get_blocks_at_height";
+    DaemonRPCMethod["GetBlockByHash"] = "get_block_by_hash";
+    DaemonRPCMethod["GetTopBlock"] = "get_top_block";
+    DaemonRPCMethod["GetNonce"] = "get_nonce";
+    DaemonRPCMethod["GetLastBalance"] = "get_last_balance";
+    DaemonRPCMethod["GetBalanceAtTopoHeight"] = "get_balance_at_topoheight";
+    DaemonRPCMethod["GetAssets"] = "get_assets";
+    DaemonRPCMethod["CountAssets"] = "count_assets";
+    DaemonRPCMethod["CountTransactions"] = "count_transactions";
+    DaemonRPCMethod["GetTips"] = "get_tips";
+    DaemonRPCMethod["P2PStatus"] = "p2p_status";
+    DaemonRPCMethod["GetDAGOrder"] = "get_dag_order";
+    DaemonRPCMethod["GetMempool"] = "get_mempool";
+    DaemonRPCMethod["GetTransaction"] = "get_transaction";
+    DaemonRPCMethod["GetTransactions"] = "get_transactions";
+    DaemonRPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
+    DaemonRPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
+    DaemonRPCMethod["GetAccounts"] = "get_accounts";
+    DaemonRPCMethod["SubmitBlock"] = "submit_block";
+    DaemonRPCMethod["SubmitTransaction"] = "submit_transaction";
+})(DaemonRPCMethod || (DaemonRPCMethod = {}));
+export var RPCEvent;
+(function (RPCEvent) {
+    RPCEvent["NewBlock"] = "NewBlock";
+    RPCEvent["TransactionAddedInMempool"] = "TransactionAddedInMempool";
+    RPCEvent["TransactionExecuted"] = "TransactionExecuted";
+    RPCEvent["BlockOrdered"] = "BlockOrdered";
+})(RPCEvent || (RPCEvent = {}));

package/lib/websocket.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { MessageEvent } from 'ws';
+import WebSocket from 'isomorphic-ws';
+import { RPCResponse, RPCEvent, RPCEventResult } from './types';
+export declare class WS {
+    endpoint: string;
+    socket?: WebSocket;
+    timeout: number;
+    connected: boolean;
+    unsubscribeSuspense: number;
+    private events;
+    constructor();
+    connect(endpoint: string): Promise<unknown>;
+    close(code?: number | undefined, data?: string | Buffer | undefined): void;
+    onClose(cb: (event: WebSocket.CloseEvent) => void): void;
+    onError(cb: (err: WebSocket.ErrorEvent) => void): void;
+    private clearEvent;
+    closeAllListens(event: RPCEvent): Promise<void>;
+    listenEvent<T>(event: RPCEvent, onData: (msgEvent: MessageEvent, data?: T & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    call<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+    dataCall<T>(method: string, params?: any): Promise<T>;
+}

package/lib/websocket.js

@@ -0,0 +1,171 @@
+import WebSocket from 'isomorphic-ws';
+import to from 'await-to-js';
+function createRequestMethod(method, params) {
+    const id = Math.floor(Date.now() * Math.random());
+    const request = { id: id, jsonrpc: `2.0`, method };
+    if (params)
+        request.params = params;
+    const data = JSON.stringify(request);
+    return { data, id };
+}
+export class WS {
+    constructor() {
+        this.endpoint = "";
+        this.timeout = 3000;
+        this.connected = false;
+        this.events = {};
+        this.unsubscribeSuspense = 1000;
+    }
+    connect(endpoint) {
+        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+            this.socket.close();
+        }
+        return new Promise((resolve, reject) => {
+            this.socket = new WebSocket(endpoint);
+            this.endpoint = endpoint;
+            this.socket.addEventListener(`open`, (event) => {
+                this.connected = true;
+                resolve(event);
+            });
+            this.socket.addEventListener(`close`, () => {
+                this.connected = false;
+                reject();
+            });
+            this.socket.addEventListener(`error`, (err) => {
+                this.connected = false;
+                reject(err);
+            });
+        });
+    }
+    close(code, data) {
+        this.socket && this.socket.close(code, data);
+    }
+    onClose(cb) {
+        if (!this.socket)
+            return;
+        this.socket.addEventListener(`close`, (event) => {
+            cb(event);
+        });
+    }
+    onError(cb) {
+        if (!this.socket)
+            return;
+        this.socket.addEventListener(`error`, (err) => {
+            cb(err);
+        });
+    }
+    clearEvent(event) {
+        this.events[event].listeners.forEach(listener => {
+            this.socket && this.socket.removeEventListener(`message`, listener);
+        });
+        Reflect.deleteProperty(this.events, event);
+    }
+    async closeAllListens(event) {
+        if (this.events[event]) {
+            const [err, _] = await to(this.call(`unsubscribe`, { notify: event }));
+            if (err)
+                return Promise.reject(err);
+            this.clearEvent(event);
+        }
+        return Promise.resolve();
+    }
+    async listenEvent(event, onData) {
+        const onMessage = (msgEvent) => {
+            if (this.events[event]) {
+                const { id } = this.events[event];
+                if (typeof msgEvent.data === `string`) {
+                    try {
+                        const data = JSON.parse(msgEvent.data);
+                        if (data.id === id) {
+                            if (data.error) {
+                                onData(msgEvent, undefined, new Error(data.error.message));
+                            }
+                            else {
+                                onData(msgEvent, data.result, undefined);
+                            }
+                        }
+                    }
+                    catch (_a) {
+                        // can't parse json -- do nothing
+                    }
+                }
+            }
+        };
+        if (this.events[event]) {
+            const { unsubscribeTimeoutId } = this.events[event];
+            if (unsubscribeTimeoutId) {
+                // clear timeout to unsubscribe 
+                // because we got a new registered event and want to cancel the pending unsubscribe grace period
+                clearTimeout(unsubscribeTimeoutId);
+            }
+            this.events[event].listeners.push(onMessage);
+        }
+        else {
+            // important if multiple listenEvent are called without await atleast we store listener before getting id
+            this.events[event] = { listeners: [onMessage] };
+            const [err, res] = await to(this.call(`subscribe`, { notify: event }));
+            if (err) {
+                this.clearEvent(event);
+                return Promise.reject(err);
+            }
+            this.events[event].id = res.id;
+        }
+        this.socket && this.socket.addEventListener(`message`, onMessage);
+        const closeListen = () => {
+            const eventData = this.events[event];
+            if (eventData) {
+                const listeners = eventData.listeners;
+                for (let i = 0; i < listeners.length; i++) {
+                    if (listeners[i] === onMessage) {
+                        listeners.splice(i, 1);
+                        break;
+                    }
+                }
+                if (listeners.length === 0) {
+                    this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
+                        // no more listener so we unsubscribe from daemon websocket
+                        this.call(`unsubscribe`, { notify: event });
+                        Reflect.deleteProperty(this.events, event);
+                    }, this.unsubscribeSuspense);
+                }
+            }
+            this.socket && this.socket.removeEventListener(`message`, onMessage);
+            return Promise.resolve();
+        };
+        return Promise.resolve(closeListen);
+    }
+    call(method, params) {
+        return new Promise((resolve, reject) => {
+            const { data, id } = createRequestMethod(method, params);
+            let timeoutId = null;
+            const onMessage = (msgEvent) => {
+                if (typeof msgEvent.data === `string`) {
+                    const data = JSON.parse(msgEvent.data);
+                    if (data.id === id) {
+                        clearTimeout(timeoutId);
+                        this.socket && this.socket.removeEventListener(`message`, onMessage);
+                        if (data.error)
+                            return reject(new Error(data.error.message));
+                        else
+                            resolve(data);
+                    }
+                }
+            };
+            // make sure you listen before sending data
+            this.socket && this.socket.addEventListener(`message`, onMessage); // we don't use { once: true } option because of timeout feature
+            timeoutId = setTimeout(() => {
+                this.socket && this.socket.removeEventListener(`message`, onMessage);
+                reject(new Error(`timeout`));
+            }, this.timeout);
+            this.socket && this.socket.send(data);
+        });
+    }
+    dataCall(method, params) {
+        return new Promise(async (resolve, reject) => {
+            const [err, res] = await to(this.call(method, params));
+            if (err)
+                return reject(err);
+            return resolve(res.result);
+        });
+    }
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.4",
+  "version": "0.4.0",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "repository": {

package/react/{context.d.ts → daemon.d.ts}

@@ -1,7 +1,7 @@
 import React, { PropsWithChildren } from 'react';
 import { MessageEvent } from 'ws';
 import DaemonWS from '../daemon/websocket';
-import { RPCEvent } from '../daemon/types';
+import { RPCEvent } from '../lib/types';
 interface NodeSocket {
     daemon: DaemonWS;
     loading: boolean;

package/wallet/rpc.d.ts

@@ -0,0 +1,15 @@
+import { Transaction, GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams } from '../lib/types';
+import { RPC as BaseRPC } from '../lib/rpc';
+declare class RPC extends BaseRPC {
+    getVersion(): Promise<import("../lib/types").RPCResponse<string>>;
+    getNonce(): Promise<import("../lib/types").RPCResponse<number>>;
+    getTopoheight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getAddress(params?: GetAddressParams): Promise<import("../lib/types").RPCResponse<string>>;
+    splitAddress(params: SplitAddressParams): Promise<import("../lib/types").RPCResponse<SplitAddressResult>>;
+    getBalance(asset?: string): Promise<import("../lib/types").RPCResponse<number>>;
+    getTrackedAssets(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<Transaction>>;
+    buildTransaction(params: BuildTransactionParams): Promise<import("../lib/types").RPCResponse<BuildTransactionResult>>;
+    listTransactions(params?: ListTransactionParams): Promise<import("../lib/types").RPCResponse<Transaction[]>>;
+}
+export default RPC;

package/wallet/rpc.js

@@ -0,0 +1,35 @@
+import { WalletRPCMethod } from '../lib/types';
+import { RPC as BaseRPC } from '../lib/rpc';
+class RPC extends BaseRPC {
+    getVersion() {
+        return this.post(WalletRPCMethod.GetVersion);
+    }
+    getNonce() {
+        return this.post(WalletRPCMethod.GetNonce);
+    }
+    getTopoheight() {
+        return this.post(WalletRPCMethod.GetTopoheight);
+    }
+    getAddress(params) {
+        return this.post(WalletRPCMethod.GetAddress, params);
+    }
+    splitAddress(params) {
+        return this.post(WalletRPCMethod.SplitAddress, params);
+    }
+    getBalance(asset) {
+        return this.post(WalletRPCMethod.GetBalance, { asset });
+    }
+    getTrackedAssets() {
+        return this.post(WalletRPCMethod.GetTrackedAssets);
+    }
+    getTransaction(hash) {
+        return this.post(WalletRPCMethod.GetTransaction, { hash });
+    }
+    buildTransaction(params) {
+        return this.post(WalletRPCMethod.BuildTransaction, params);
+    }
+    listTransactions(params) {
+        return this.post(WalletRPCMethod.ListTransactions, params);
+    }
+}
+export default RPC;

package/wallet/websocket.d.ts

@@ -0,0 +1,16 @@
+import { WS as BaseWS } from '../lib/websocket';
+import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult, Transaction } from '../lib/types';
+declare class WS extends BaseWS {
+    getVersion(): Promise<string>;
+    getNetwork(): Promise<string>;
+    getNonce(): Promise<number>;
+    getTopoheight(): Promise<number>;
+    getAddress(params?: GetAddressParams): Promise<string>;
+    splitAddress(params: SplitAddressParams): Promise<SplitAddressResult>;
+    getBalance(asset?: string): Promise<number>;
+    getTrackedAssets(): Promise<string[]>;
+    getTransaction(hash: string): Promise<Transaction>;
+    buildTransaction(params: BuildTransactionParams): Promise<BuildTransactionResult>;
+    listTransactions(params?: ListTransactionParams): Promise<Transaction[]>;
+}
+export default WS;

package/wallet/websocket.js

@@ -0,0 +1,38 @@
+import { WS as BaseWS } from '../lib/websocket';
+import { WalletRPCMethod } from '../lib/types';
+class WS extends BaseWS {
+    getVersion() {
+        return this.dataCall(WalletRPCMethod.GetVersion);
+    }
+    getNetwork() {
+        return this.dataCall(WalletRPCMethod.GetNetwork);
+    }
+    getNonce() {
+        return this.dataCall(WalletRPCMethod.GetNonce);
+    }
+    getTopoheight() {
+        return this.dataCall(WalletRPCMethod.GetTopoheight);
+    }
+    getAddress(params) {
+        return this.dataCall(WalletRPCMethod.GetAddress, params);
+    }
+    splitAddress(params) {
+        return this.dataCall(WalletRPCMethod.SplitAddress, params);
+    }
+    getBalance(asset) {
+        return this.dataCall(WalletRPCMethod.GetBalance, { asset });
+    }
+    getTrackedAssets() {
+        return this.dataCall(WalletRPCMethod.GetTrackedAssets);
+    }
+    getTransaction(hash) {
+        return this.dataCall(WalletRPCMethod.GetTransaction, { hash });
+    }
+    buildTransaction(params) {
+        return this.dataCall(WalletRPCMethod.BuildTransaction, params);
+    }
+    listTransactions(params) {
+        return this.dataCall(WalletRPCMethod.GetTransaction, params);
+    }
+}
+export default WS;

package/daemon/types.js

@@ -1,37 +0,0 @@
-export var RPCMethod;
-(function (RPCMethod) {
-    RPCMethod["GetVersion"] = "get_version";
-    RPCMethod["GetInfo"] = "get_info";
-    RPCMethod["GetHeight"] = "get_height";
-    RPCMethod["GetTopoHeight"] = "get_topoheight";
-    RPCMethod["GetStableHeight"] = "get_stableheight";
-    RPCMethod["GetBlockTemplate"] = "get_block_template";
-    RPCMethod["GetBlockAtTopoHeight"] = "get_block_at_topoheight";
-    RPCMethod["GetBlocksAtHeight"] = "get_blocks_at_height";
-    RPCMethod["GetBlockByHash"] = "get_block_by_hash";
-    RPCMethod["GetTopBlock"] = "get_top_block";
-    RPCMethod["GetNonce"] = "get_nonce";
-    RPCMethod["GetLastBalance"] = "get_last_balance";
-    RPCMethod["GetBalanceAtTopoHeight"] = "get_balance_at_topoheight";
-    RPCMethod["GetAssets"] = "get_assets";
-    RPCMethod["CountAssets"] = "count_assets";
-    RPCMethod["CountTransactions"] = "count_transactions";
-    RPCMethod["GetTips"] = "get_tips";
-    RPCMethod["P2PStatus"] = "p2p_status";
-    RPCMethod["GetDAGOrder"] = "get_dag_order";
-    RPCMethod["GetMempool"] = "get_mempool";
-    RPCMethod["GetTransaction"] = "get_transaction";
-    RPCMethod["GetTransactions"] = "get_transactions";
-    RPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
-    RPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
-    RPCMethod["GetAccounts"] = "get_accounts";
-    RPCMethod["SubmitBlock"] = "submit_block";
-    RPCMethod["SubmitTransaction"] = "submit_transaction";
-})(RPCMethod || (RPCMethod = {}));
-export var RPCEvent;
-(function (RPCEvent) {
-    RPCEvent["NewBlock"] = "NewBlock";
-    RPCEvent["TransactionAddedInMempool"] = "TransactionAddedInMempool";
-    RPCEvent["TransactionExecuted"] = "TransactionExecuted";
-    RPCEvent["BlockOrdered"] = "BlockOrdered";
-})(RPCEvent || (RPCEvent = {}));