@xelis/sdk 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# XELIS-JS-SDK
+
+Xelis software development kit for JS.
+
+## Install
+
+Install library with NPM.
+
+`npm i @xelis/sdk`
+
+## Usage
+
+Import library and start working :).
+
+Use http/rpc connection.
+
+```js
+import { DEV_NODE_RPC } from '@xelis/sdk/config/nodes'
+import DaemonRPC from '@xelis/sdk/daemon/rpc'
+
+const main = async () => {
+  const daemonRPC = new DaemonRPC(DEV_NODE_RPC)
+  const info = await daemonRPC.getInfo()
+  console.log(info)
+}
+
+main()
+```
+
+Use websocket connection.
+
+```js
+import { DEV_NODE_RPC } from '@xelis/sdk/config/nodes'
+import DaemonWS from '@xelis/sdk/daemon/websocket'
+
+const main = async () => {
+  const daemonWS = new DaemonWS()
+  await daemonWS.connect(DEV_NODE_RPC)
+  const info = await daemonWS.getInfo()
+  console.log(info)
+}
+
+main()
+```

package/dist/README.md

@@ -0,0 +1,44 @@
+# XELIS-JS-SDK
+
+Xelis software development kit for JS.
+
+## Install
+
+Install library with NPM.
+
+`npm i @xelis/sdk`
+
+## Usage
+
+Import library and start working :).
+
+Use http/rpc connection.
+
+```js
+import { DEV_NODE_RPC } from '@xelis/sdk/config/nodes'
+import DaemonRPC from '@xelis/sdk/daemon/rpc'
+
+const main = async () => {
+  const daemonRPC = new DaemonRPC(DEV_NODE_RPC)
+  const info = await daemonRPC.getInfo()
+  console.log(info)
+}
+
+main()
+```
+
+Use websocket connection.
+
+```js
+import { DEV_NODE_RPC } from '@xelis/sdk/config/nodes'
+import DaemonWS from '@xelis/sdk/daemon/websocket'
+
+const main = async () => {
+  const daemonWS = new DaemonWS()
+  await daemonWS.connect(DEV_NODE_RPC)
+  const info = await daemonWS.getInfo()
+  console.log(info)
+}
+
+main()
+```

package/dist/config/nodes.d.ts

@@ -0,0 +1,21 @@
+export declare const NODE_URL = "node.xelis.io";
+export declare const TESTNET_NODE_URL = "testnet-node.xelis.io";
+export declare const DEV_NODE_URL = "dev-node.xelis.io";
+export declare const NODE_RPC: string;
+export declare const TESTNET_NODE_RPC: string;
+export declare const DEV_NODE_RPC: string;
+export declare const NODE_WS: string;
+export declare const TESTNET_NODE_WS: string;
+export declare const DEV_NODE_WS: string;
+declare const _default: {
+    NODE_URL: string;
+    TESTNET_NODE_URL: string;
+    DEV_NODE_URL: string;
+    NODE_RPC: string;
+    TESTNET_NODE_RPC: string;
+    DEV_NODE_RPC: string;
+    NODE_WS: string;
+    TESTNET_NODE_WS: string;
+    DEV_NODE_WS: string;
+};
+export default _default;

package/dist/config/nodes.js

@@ -0,0 +1,14 @@
+export const NODE_URL = `node.xelis.io`;
+export const TESTNET_NODE_URL = `testnet-node.xelis.io`;
+export const DEV_NODE_URL = `dev-node.xelis.io`;
+export const NODE_RPC = `https://${NODE_URL}/json_rpc`;
+export const TESTNET_NODE_RPC = `https://${TESTNET_NODE_URL}/json_rpc`;
+export const DEV_NODE_RPC = `https://${DEV_NODE_URL}/json_rpc`;
+export const NODE_WS = `wss://${NODE_URL}/ws`;
+export const TESTNET_NODE_WS = `wss://${TESTNET_NODE_URL}/ws`;
+export const DEV_NODE_WS = `wss://${DEV_NODE_URL}/ws`;
+export default {
+    NODE_URL, TESTNET_NODE_URL, DEV_NODE_URL,
+    NODE_RPC, TESTNET_NODE_RPC, DEV_NODE_RPC,
+    NODE_WS, TESTNET_NODE_WS, DEV_NODE_WS
+};

package/dist/daemon/rpc.d.ts

@@ -0,0 +1,30 @@
+import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetLastBalanceResult, P2PStatusResult, RPCMethod, RPCResponse, Transaction, BalanceParams } from './types';
+declare class RPC {
+    endpoint: string;
+    constructor(endpoint: string);
+    fetch<T>(method: RPCMethod, params?: any): Promise<RPCResponse<T>>;
+    getInfo(): Promise<RPCResponse<GetInfoResult>>;
+    getHeight(): Promise<RPCResponse<number>>;
+    getTopoHeight(): Promise<RPCResponse<number>>;
+    getStableHeight(): Promise<RPCResponse<number>>;
+    getBlockTemplate(address: string): Promise<RPCResponse<string>>;
+    getBlockAtTopoHeight(topoHeight: number): Promise<RPCResponse<Block>>;
+    getBlocksAtHeight(height: number): Promise<RPCResponse<Block[]>>;
+    getBlockByHash(hash: string): Promise<RPCResponse<Block>>;
+    getTopBlock(): Promise<RPCResponse<Block>>;
+    getNonce(address: string): Promise<RPCResponse<number>>;
+    getLastBalance(params: BalanceParams): Promise<RPCResponse<GetLastBalanceResult>>;
+    getBalanceAtTopoHeight(params: BalanceParams): Promise<RPCResponse<Balance>>;
+    getAssets(): Promise<RPCResponse<string[]>>;
+    countTransactions(): 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[]>>;
+    getBlocks(params: TopoHeightRangeParams): Promise<RPCResponse<Block[]>>;
+    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<RPCResponse<Block[]>>;
+    getBlocksRangeByHeight(params: HeightRangeParams): Promise<RPCResponse<Block[]>>;
+}
+export default RPC;

package/dist/daemon/rpc.js

@@ -0,0 +1,92 @@
+import { RPCMethod } from './types';
+class RPC {
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    async fetch(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();
+                return Promise.resolve(data);
+            }
+            else {
+                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    getInfo() {
+        return this.fetch(RPCMethod.GetInfo);
+    }
+    getHeight() {
+        return this.fetch(RPCMethod.GetHeight);
+    }
+    getTopoHeight() {
+        return this.fetch(RPCMethod.GetTopoHeight);
+    }
+    getStableHeight() {
+        return this.fetch(RPCMethod.GetStableHeight);
+    }
+    getBlockTemplate(address) {
+        return this.fetch(RPCMethod.GetBlockTemplate, { address });
+    }
+    getBlockAtTopoHeight(topoHeight) {
+        return this.fetch(RPCMethod.GetBlockAtTopoHeight, { topoheight: topoHeight });
+    }
+    getBlocksAtHeight(height) {
+        return this.fetch(RPCMethod.GetBlocksAtHeight, { height });
+    }
+    getBlockByHash(hash) {
+        return this.fetch(RPCMethod.GetBlockByHash, { hash });
+    }
+    getTopBlock() {
+        return this.fetch(RPCMethod.GetTopBlock);
+    }
+    getNonce(address) {
+        return this.fetch(RPCMethod.GetNonce, { address });
+    }
+    getLastBalance(params) {
+        return this.fetch(RPCMethod.GetLastBalance, params);
+    }
+    getBalanceAtTopoHeight(params) {
+        return this.fetch(RPCMethod.GetBalanceAtTopoHeight, params);
+    }
+    getAssets() {
+        return this.fetch(RPCMethod.GetAssets);
+    }
+    countTransactions() {
+        return this.fetch(RPCMethod.CountTransactions);
+    }
+    getTips() {
+        return this.fetch(RPCMethod.GetTips);
+    }
+    p2pStatus() {
+        return this.fetch(RPCMethod.P2PStatus);
+    }
+    getDAGOrder(params) {
+        return this.fetch(RPCMethod.GetDAGOrder, params);
+    }
+    getMemPool() {
+        return this.fetch(RPCMethod.GetMempool);
+    }
+    getTransaction(hash) {
+        return this.fetch(RPCMethod.GetTransaction, { hash });
+    }
+    getTransactions(txHashes) {
+        return this.fetch(RPCMethod.GetTransactions, { tx_hashes: txHashes });
+    }
+    getBlocks(params) {
+        return this.fetch(RPCMethod.GetBlocks, params);
+    }
+    getBlocksRangeByTopoheight(params) {
+        return this.fetch(RPCMethod.GetBlocksRangeByTopoheight, params);
+    }
+    getBlocksRangeByHeight(params) {
+        return this.fetch(RPCMethod.GetBlocksRangeByHeight, params);
+    }
+}
+export default RPC;

package/dist/daemon/types.d.ts

@@ -0,0 +1,132 @@
+export interface RPCRequest {
+    id: number;
+    jsonrpc: string;
+    method: string;
+    params: string;
+}
+export interface RPCError {
+    code: number;
+    message: string;
+}
+export interface RPCResponse<T> {
+    id: number;
+    result: T;
+    error: RPCError;
+}
+export interface GetInfoResult {
+    block_time_target: number;
+    difficulty: number;
+    height: number;
+    mempool_size: number;
+    native_supply: number;
+    stableheight: number;
+    top_hash: string;
+    version: string;
+    network: string;
+    topoheight: number;
+}
+export interface Block {
+    block_type: string;
+    cumulative_difficulty: number;
+    supply: number;
+    difficulty: number;
+    reward: number;
+    extra_nonce: string;
+    hash: string;
+    height: number;
+    miner_tx: {
+        owner: string;
+        signature: null;
+        variant: string;
+    };
+    miner: string;
+    nonce: number;
+    tips: string[];
+    topoheight: number;
+    total_fees: number;
+    total_size_in_bytes: number;
+    txs_hashes: string[];
+}
+export interface BalanceParams {
+    address: string;
+    asset: string;
+}
+export interface Balance {
+    balance: number;
+    previous_topoheight: number;
+}
+export interface GetLastBalanceResult {
+    topoheight: number;
+    balance: Balance;
+}
+export interface P2PStatusResult {
+    best_height: number;
+    max_peers: number;
+    our_height: number;
+    peer_count: number;
+    peer_id: number;
+    tag?: string;
+}
+export interface TopoHeightRangeParams {
+    start_topoheight?: number;
+    end_topoheight?: number;
+}
+export interface HeightRangeParams {
+    start_height?: number;
+    end_height?: number;
+}
+export interface RPCEventResult {
+    event: string;
+}
+export interface BlockOrdered {
+    topoheight: number;
+    block_hash: string;
+    block_type: string;
+}
+export interface Transaction {
+    hash: string;
+    blocks: string[];
+    data: {
+        Transfer: {
+            amount: number;
+            asset: string;
+            extra_data: any;
+            to: string;
+        }[];
+    };
+    fee: number;
+    nonce: number;
+    owner: string;
+    signature: string;
+}
+export declare enum RPCMethod {
+    GetInfo = "get_info",
+    GetHeight = "get_height",
+    GetTopoHeight = "get_topoheight",
+    GetStableHeight = "get_stableheight",
+    GetBlockTemplate = "get_block_template",
+    GetBlockAtTopoHeight = "get_block_at_topoheight",
+    GetBlocksAtHeight = "get_blocks_at_height",
+    GetBlockByHash = "get_block_by_hash",
+    GetTopBlock = "get_top_block",
+    GetNonce = "get_nonce",
+    GetLastBalance = "get_last_balance",
+    GetBalanceAtTopoHeight = "get_balance_at_topoheight",
+    GetAssets = "get_assets",
+    CountTransactions = "count_transactions",
+    GetTips = "get_tips",
+    P2PStatus = "p2p_status",
+    GetDAGOrder = "get_dag_order",
+    GetMempool = "get_mempool",
+    GetTransaction = "get_transaction",
+    GetTransactions = "get_transactions",
+    GetBlocks = "get_blocks",
+    GetBlocksRangeByTopoheight = "get_blocks_range_by_topoheight",
+    GetBlocksRangeByHeight = "get_blocks_range_by_height"
+}
+export declare enum RPCEvent {
+    NewBlock = "NewBlock",
+    TransactionAddedInMempool = "TransactionAddedInMempool",
+    TransactionExecuted = "TransactionExecuted",
+    BlockOrdered = "BlockOrdered"
+}

package/dist/daemon/types.js

@@ -0,0 +1,33 @@
+export var RPCMethod;
+(function (RPCMethod) {
+    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["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["GetBlocks"] = "get_blocks";
+    RPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
+    RPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
+})(RPCMethod || (RPCMethod = {}));
+export var RPCEvent;
+(function (RPCEvent) {
+    RPCEvent["NewBlock"] = "NewBlock";
+    RPCEvent["TransactionAddedInMempool"] = "TransactionAddedInMempool";
+    RPCEvent["TransactionExecuted"] = "TransactionExecuted";
+    RPCEvent["BlockOrdered"] = "BlockOrdered";
+})(RPCEvent || (RPCEvent = {}));

package/dist/daemon/websocket.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { MessageEvent } from 'ws';
+import WebSocket from 'isomorphic-ws';
+import { Block, RPCResponse, GetInfoResult, RPCEvent, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, BalanceParams, GetLastBalanceResult, HeightRangeParams, BlockOrdered } from './types';
+declare class WS {
+    endpoint: string;
+    socket?: WebSocket;
+    timeout: number;
+    connected: boolean;
+    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>>;
+    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>;
+    getInfo(): Promise<GetInfoResult>;
+    getHeight(): Promise<number>;
+    getTopoHeight(): Promise<number>;
+    getStableHeight(): Promise<number>;
+    getBlockTemplate(address: string): Promise<string>;
+    getBlockAtTopoHeight(topoHeight: number): Promise<Block>;
+    getBlocksAtHeight(height: number): Promise<Block[]>;
+    getBlockByHash(hash: string): Promise<Block>;
+    getTopBlock(): Promise<Block>;
+    getNonce(address: string): Promise<number>;
+    getLastBalance(params: BalanceParams): Promise<GetLastBalanceResult>;
+    getBalanceAtTopoHeight(params: BalanceParams): Promise<Balance>;
+    getAssets(): Promise<string[]>;
+    countTransactions(): Promise<number>;
+    getTips(): Promise<string[]>;
+    p2pStatus(): Promise<P2PStatusResult>;
+    getDAGOrder(params: TopoHeightRangeParams): Promise<string[]>;
+    getMemPool(): Promise<Transaction[]>;
+    getTransaction(hash: string): Promise<Transaction>;
+    getTransactions(txHashes: string[]): Promise<Transaction[]>;
+    getBlocks(params: TopoHeightRangeParams): Promise<Block[]>;
+    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<Block[]>;
+    getBlocksRangeByHeight(params: HeightRangeParams): Promise<Block[]>;
+}
+export default WS;

package/dist/daemon/websocket.js

@@ -0,0 +1,237 @@
+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 = {};
+    }
+    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]) {
+            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 = async () => {
+            if (this.events[event] && this.events[event].listeners.length === 1) {
+                // this is the last listen callback so we unsubscribe from daemon ws
+                const [err, _] = await to(this.call(`unsubscribe`, { notify: event }));
+                if (err)
+                    return Promise.reject(err);
+                Reflect.deleteProperty(this.events, event);
+            }
+            this.socket && this.socket.removeEventListener(`message`, onMessage);
+            return Promise.resolve();
+        };
+        return Promise.resolve(closeListen);
+    }
+    onNewBlock(onData) {
+        return this.listenEvent(RPCEvent.NewBlock, onData);
+    }
+    onTransactionAddedInMempool(onData) {
+        return this.listenEvent(RPCEvent.TransactionAddedInMempool, onData);
+    }
+    onTransactionExecuted(onData) {
+        return this.listenEvent(RPCEvent.TransactionExecuted, onData);
+    }
+    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);
+        });
+    }
+    getInfo() {
+        return this.dataCall(RPCMethod.GetInfo);
+    }
+    getHeight() {
+        return this.dataCall(RPCMethod.GetHeight);
+    }
+    getTopoHeight() {
+        return this.dataCall(RPCMethod.GetTopoHeight);
+    }
+    getStableHeight() {
+        return this.dataCall(RPCMethod.GetStableHeight);
+    }
+    getBlockTemplate(address) {
+        return this.dataCall(RPCMethod.GetBlockTemplate, { address });
+    }
+    getBlockAtTopoHeight(topoHeight) {
+        return this.dataCall(RPCMethod.GetBlockAtTopoHeight, { topoheight: topoHeight });
+    }
+    getBlocksAtHeight(height) {
+        return this.dataCall(RPCMethod.GetBlocksAtHeight, { height });
+    }
+    getBlockByHash(hash) {
+        return this.dataCall(RPCMethod.GetBlockByHash, { hash });
+    }
+    getTopBlock() {
+        return this.dataCall(RPCMethod.GetTopBlock);
+    }
+    getNonce(address) {
+        return this.dataCall(RPCMethod.GetNonce, { address });
+    }
+    getLastBalance(params) {
+        return this.dataCall(RPCMethod.GetLastBalance, params);
+    }
+    getBalanceAtTopoHeight(params) {
+        return this.dataCall(RPCMethod.GetBalanceAtTopoHeight, params);
+    }
+    getAssets() {
+        return this.dataCall(RPCMethod.GetAssets);
+    }
+    countTransactions() {
+        return this.dataCall(RPCMethod.CountTransactions);
+    }
+    getTips() {
+        return this.dataCall(RPCMethod.GetTips);
+    }
+    p2pStatus() {
+        return this.dataCall(RPCMethod.P2PStatus);
+    }
+    getDAGOrder(params) {
+        return this.dataCall(RPCMethod.GetDAGOrder, params);
+    }
+    getMemPool() {
+        return this.dataCall(RPCMethod.GetMempool);
+    }
+    getTransaction(hash) {
+        return this.dataCall(RPCMethod.GetTransaction, { hash });
+    }
+    getTransactions(txHashes) {
+        return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
+    }
+    getBlocks(params) {
+        return this.dataCall(RPCMethod.GetBlocks, params);
+    }
+    getBlocksRangeByTopoheight(params) {
+        return this.dataCall(RPCMethod.GetBlocksRangeByTopoheight, params);
+    }
+    getBlocksRangeByHeight(params) {
+        return this.dataCall(RPCMethod.GetBlocksRangeByHeight, params);
+    }
+}
+export default WS;

package/dist/package.json

@@ -0,0 +1,31 @@
+{
+  "version": "0.1.0",
+  "name": "@xelis/sdk",
+  "description": "Xelis software development kit for JS",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xelis-project/xelis-js-sdk"
+  },
+  "homepage": "https://github.com/xelis-project/xelis-js-sdk#readme",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "npx tsc --declaration && cp package.json ./dist && cp README.md ./dist",
+    "prepublish": "npm run build"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.4.0",
+    "@types/react": "^18.2.23",
+    "@types/ws": "^8.5.4",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "await-to-js": "^3.0.0",
+    "isomorphic-ws": "^5.0.0",
+    "react": "^18.2.0",
+    "ws": "^8.12.1"
+  }
+}

package/dist/react/context.d.ts

@@ -0,0 +1,22 @@
+import React, { PropsWithChildren } from 'react';
+import { MessageEvent } from 'ws';
+import DaemonWS from '../daemon/websocket';
+import { RPCEvent } from '../daemon/types';
+interface NodeSocket {
+    daemon: DaemonWS;
+    loading: boolean;
+    err: any;
+    connected: boolean;
+}
+interface NodeSocketProviderProps {
+    endpoint: string;
+}
+export declare const NodeSocketProvider: (props: PropsWithChildren<NodeSocketProviderProps>) => React.JSX.Element;
+interface NodeSocketSubscribeProps<T> {
+    event: RPCEvent;
+    onConnected: () => void;
+    onData: (msgEvent: MessageEvent, data?: T, err?: Error | undefined) => void;
+}
+export declare const useNodeSocketSubscribe: ({ event, onConnected, onData }: NodeSocketSubscribeProps<any>, dependencies: React.DependencyList) => void;
+export declare const useNodeSocket: () => NodeSocket;
+export default useNodeSocket;

package/dist/react/context.js

@@ -0,0 +1,57 @@
+import React, { createContext, useContext, useEffect, useState } from 'react';
+import to from 'await-to-js';
+import DaemonWS from '../daemon/websocket';
+const daemon = new DaemonWS();
+const Context = createContext({
+    connected: false,
+    err: null,
+    loading: false,
+    daemon,
+});
+export const NodeSocketProvider = (props) => {
+    const { children, endpoint } = props;
+    const [loading, setLoading] = useState(true);
+    const [connected, setConnected] = useState(false);
+    const [err, setErr] = useState();
+    useEffect(() => {
+        const load = async () => {
+            setLoading(true);
+            const [err, res] = await to(daemon.connect(endpoint));
+            if (err)
+                setErr(err);
+            else
+                setConnected(true);
+            setLoading(false);
+            daemon.onError((err) => {
+                setErr(err);
+                setConnected(false);
+            });
+            daemon.onClose(() => {
+                setConnected(false);
+            });
+        };
+        load();
+    }, [endpoint]);
+    return React.createElement(Context.Provider, { value: { daemon, loading, err, connected } }, children);
+};
+export const useNodeSocketSubscribe = ({ event, onConnected, onData }, dependencies) => {
+    const nodeSocket = useNodeSocket();
+    useEffect(() => {
+        if (!nodeSocket.connected)
+            return;
+        if (typeof onConnected === `function`)
+            onConnected();
+        let closeEvent;
+        const listen = async () => {
+            if (!nodeSocket.daemon)
+                return;
+            closeEvent = await nodeSocket.daemon.listenEvent(event, onData);
+        };
+        listen();
+        return () => {
+            closeEvent && closeEvent();
+        };
+    }, [nodeSocket, ...dependencies]);
+};
+export const useNodeSocket = () => useContext(Context);
+export default useNodeSocket;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "version": "0.1.0",
+  "name": "@xelis/sdk",
+  "description": "Xelis software development kit for JS",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xelis-project/xelis-js-sdk"
+  },
+  "homepage": "https://github.com/xelis-project/xelis-js-sdk#readme",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "npx tsc --declaration && cp package.json ./dist && cp README.md ./dist",
+    "prepublish": "npm run build"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.4.0",
+    "@types/react": "^18.2.23",
+    "@types/ws": "^8.5.4",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "await-to-js": "^3.0.0",
+    "isomorphic-ws": "^5.0.0",
+    "react": "^18.2.0",
+    "ws": "^8.12.1"
+  }
+}