@xelis/sdk 0.6.1 → 0.8.0

package/config.js

@@ -1,25 +0,0 @@
-export const DAEMON_RPC_PORT = `8080`;
-export const WALLET_RPC_PORT = `8081`;
-export const XSWD_PORT = `44325`;
-export const MAINNET_NODE_URL = `node.xelis.io`;
-export const TESTNET_NODE_URL = `testnet-node.xelis.io`;
-export const LOCAL_NODE_URL = `127.0.0.1:${DAEMON_RPC_PORT}`;
-export const MAINNET_NODE_RPC = `https://${MAINNET_NODE_URL}/json_rpc`;
-export const TESTNET_NODE_RPC = `https://${TESTNET_NODE_URL}/json_rpc`;
-export const LOCAL_NODE_RPC = `http://${LOCAL_NODE_URL}/json_rpc`;
-export const MAINNET_NODE_WS = `wss://${MAINNET_NODE_URL}/json_rpc`;
-export const TESTNET_NODE_WS = `wss://${TESTNET_NODE_URL}/json_rpc`;
-export const LOCAL_NODE_WS = `ws://${LOCAL_NODE_URL}/json_rpc`;
-export const LOCAL_WALLET_URL = `127.0.0.1:${WALLET_RPC_PORT}`;
-export const LOCAL_WALLET_RPC = `http://${LOCAL_WALLET_URL}/json_rpc`;
-export const LOCAL_WALLET_WS = `ws://${LOCAL_WALLET_URL}/json_rpc`;
-export const LOCAL_XSWD_URL = `127.0.0.1:${XSWD_PORT}`;
-export const LOCAL_XSWD_WS = `ws://${LOCAL_XSWD_URL}/xswd`;
-export default {
-    MAINNET_NODE_URL, TESTNET_NODE_URL,
-    MAINNET_NODE_RPC, TESTNET_NODE_RPC, LOCAL_NODE_RPC,
-    MAINNET_NODE_WS, TESTNET_NODE_WS, LOCAL_NODE_WS,
-    DAEMON_RPC_PORT, WALLET_RPC_PORT, XSWD_PORT,
-    LOCAL_WALLET_URL, LOCAL_WALLET_RPC, LOCAL_WALLET_WS,
-    LOCAL_XSWD_URL, LOCAL_XSWD_WS
-};

package/daemon/rpc.js

@@ -1,113 +0,0 @@
-import { RPCMethod } from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
-export class RPC extends BaseRPC {
-    getVersion() {
-        return this.post(RPCMethod.GetVersion);
-    }
-    getInfo() {
-        return this.post(RPCMethod.GetInfo);
-    }
-    getHeight() {
-        return this.post(RPCMethod.GetHeight);
-    }
-    getTopoHeight() {
-        return this.post(RPCMethod.GetTopoHeight);
-    }
-    getStableHeight() {
-        return this.post(RPCMethod.GetStableHeight);
-    }
-    getBlockTemplate(address) {
-        return this.post(RPCMethod.GetBlockTemplate, { address });
-    }
-    getBlockAtTopoHeight(params) {
-        return this.post(RPCMethod.GetBlockAtTopoHeight, params);
-    }
-    getBlocksAtHeight(params) {
-        return this.post(RPCMethod.GetBlocksAtHeight, params);
-    }
-    getBlockByHash(params) {
-        return this.post(RPCMethod.GetBlockByHash, params);
-    }
-    getTopBlock(params) {
-        return this.post(RPCMethod.GetTopBlock, params);
-    }
-    getNonce(params) {
-        return this.post(RPCMethod.GetNonce, params);
-    }
-    getBalance(params) {
-        return this.post(RPCMethod.GetBalance, params);
-    }
-    hasBalance(params) {
-        return this.post(RPCMethod.HasBalance, params);
-    }
-    getBalanceAtTopoHeight(params) {
-        return this.post(RPCMethod.GetBalanceAtTopoHeight, params);
-    }
-    getAsset(params) {
-        return this.post(RPCMethod.GetAsset, params);
-    }
-    getAssets() {
-        return this.post(RPCMethod.GetAssets);
-    }
-    countTransactions() {
-        return this.post(RPCMethod.CountTransactions);
-    }
-    countAssets() {
-        return this.post(RPCMethod.CountAssets);
-    }
-    countAccounts() {
-        return this.post(RPCMethod.CountAccounts);
-    }
-    getTips() {
-        return this.post(RPCMethod.GetTips);
-    }
-    p2pStatus() {
-        return this.post(RPCMethod.P2PStatus);
-    }
-    getDAGOrder(params) {
-        return this.post(RPCMethod.GetDAGOrder, params);
-    }
-    getMemPool() {
-        return this.post(RPCMethod.GetMempool);
-    }
-    getTransaction(hash) {
-        return this.post(RPCMethod.GetTransaction, { hash });
-    }
-    getTransactions(txHashes) {
-        return this.post(RPCMethod.GetTransactions, { tx_hashes: txHashes });
-    }
-    getBlocksRangeByTopoheight(params) {
-        return this.post(RPCMethod.GetBlocksRangeByTopoheight, params);
-    }
-    getBlocksRangeByHeight(params) {
-        return this.post(RPCMethod.GetBlocksRangeByHeight, params);
-    }
-    getAccounts(params) {
-        return this.post(RPCMethod.GetAccounts, params);
-    }
-    submitBlock(blockTemplate) {
-        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
-    }
-    submitTransaction(hexData) {
-        return this.post(RPCMethod.SubmitTransaction, { data: hexData });
-    }
-    getAccountHistory(params) {
-        return this.post(RPCMethod.GetAccountHistory, params);
-    }
-    getAccountAssets(address) {
-        return this.post(RPCMethod.GetAccountAssets, { address });
-    }
-    getPeers() {
-        return this.post(RPCMethod.GetPeers);
-    }
-    getDevFeeThresholds() {
-        return this.post(RPCMethod.GetDevFeeThresholds);
-    }
-    getSizeOnDisk() {
-        return this.post(RPCMethod.GetSizeOnDisk);
-    }
-    isTxExecutedInBlock(params) {
-        return this.post(RPCMethod.IsTxExecutedInBlock, params);
-    }
-}
-export default RPC;

package/daemon/websocket.js

@@ -1,159 +0,0 @@
-import { RPCEvent, RPCMethod } from './types';
-import { WS as BaseWS } from '../lib/websocket';
-export class DaemonMethods {
-    constructor(ws, prefix = "") {
-        this.ws = ws;
-        this.prefix = prefix;
-    }
-    async listenEvent(event, onData) {
-        return this.ws.listenEvent(this.prefix + event, onData);
-    }
-    dataCall(method, params) {
-        return this.ws.dataCall(this.prefix + method, params);
-    }
-    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);
-    }
-    onPeerConnected(onData) {
-        return this.listenEvent(RPCEvent.PeerConnected, onData);
-    }
-    onPeerDisconnected(onData) {
-        return this.listenEvent(RPCEvent.PeerDisconnected, onData);
-    }
-    onPeerPeerListUpdated(onData) {
-        return this.listenEvent(RPCEvent.PeerPeerListUpdated, onData);
-    }
-    onPeerPeerDisconnected(onData) {
-        return this.listenEvent(RPCEvent.PeerPeerDisconnected, onData);
-    }
-    onPeerStateUpdated(onData) {
-        return this.listenEvent(RPCEvent.PeerStateUpdated, onData);
-    }
-    onNewAsset(onData) {
-        return this.listenEvent(RPCEvent.NewAsset, onData);
-    }
-    onBlockOrphaned(onData) {
-        return this.listenEvent(RPCEvent.BlockOrphaned, onData);
-    }
-    getVersion() {
-        return this.dataCall(RPCMethod.GetVersion);
-    }
-    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(params) {
-        return this.dataCall(RPCMethod.GetBlockAtTopoHeight, params);
-    }
-    getBlocksAtHeight(params) {
-        return this.dataCall(RPCMethod.GetBlocksAtHeight, params);
-    }
-    getBlockByHash(params) {
-        return this.dataCall(RPCMethod.GetBlockByHash, params);
-    }
-    getTopBlock(params) {
-        return this.dataCall(RPCMethod.GetTopBlock, params);
-    }
-    getNonce(params) {
-        return this.dataCall(RPCMethod.GetNonce, params);
-    }
-    getBalance(params) {
-        return this.dataCall(RPCMethod.GetBalance, params);
-    }
-    hasBalance(params) {
-        return this.dataCall(RPCMethod.HasBalance, params);
-    }
-    getBalanceAtTopoHeight(params) {
-        return this.dataCall(RPCMethod.GetBalanceAtTopoHeight, params);
-    }
-    getAsset(params) {
-        return this.dataCall(RPCMethod.GetAsset, 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 });
-    }
-    getBlocksRangeByTopoheight(params) {
-        return this.dataCall(RPCMethod.GetBlocksRangeByTopoheight, params);
-    }
-    getBlocksRangeByHeight(params) {
-        return this.dataCall(RPCMethod.GetBlocksRangeByHeight, params);
-    }
-    getAccounts(params) {
-        return this.dataCall(RPCMethod.GetAccounts, params);
-    }
-    submitBlock(blockTemplate) {
-        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
-    }
-    submitTransaction(hexData) {
-        return this.dataCall(RPCMethod.SubmitTransaction, { data: hexData });
-    }
-    countAccounts() {
-        return this.dataCall(RPCMethod.CountAccounts);
-    }
-    getAccountHistory(params) {
-        return this.dataCall(RPCMethod.GetAccountHistory, params);
-    }
-    getAccountAssets(address) {
-        return this.dataCall(RPCMethod.GetAccountAssets, { address });
-    }
-    getPeers() {
-        return this.dataCall(RPCMethod.GetPeers);
-    }
-    getDevFeeThresholds() {
-        return this.dataCall(RPCMethod.GetDevFeeThresholds);
-    }
-    getSizeOnDisk() {
-        return this.dataCall(RPCMethod.GetSizeOnDisk);
-    }
-    isTxExecutedInBlock(params) {
-        return this.dataCall(RPCMethod.IsTxExecutedInBlock, params);
-    }
-}
-export class WS extends BaseWS {
-    constructor() {
-        super();
-        this.methods = new DaemonMethods(this);
-    }
-}
-export default WS;

package/lib/rpc.js

@@ -1,38 +0,0 @@
-export class RPC {
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-        this.timeout = 3000;
-    }
-    async post(method, params, headers) {
-        try {
-            const controller = new AbortController();
-            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
-            const timeoutId = setTimeout(() => {
-                controller.abort();
-            }, this.timeout);
-            headers = headers || new Headers();
-            headers.set(`Content-Type`, `application/json`);
-            const res = await fetch(this.endpoint, {
-                headers,
-                method: `POST`,
-                body,
-                signal: controller.signal
-            });
-            clearTimeout(timeoutId);
-            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) {
-            console.log(err);
-            return Promise.reject(err);
-        }
-    }
-}

package/lib/websocket.js

@@ -1,202 +0,0 @@
-import WebSocket from 'isomorphic-ws';
-import to from 'await-to-js';
-export class WS {
-    constructor(options) {
-        this.connectionTries = 0;
-        this.methodIdIncrement = 0;
-        this.endpoint = "";
-        this.timeout = 15000; // default to 15s
-        this.events = {};
-        this.unsubscribeSuspense = 1000;
-        this.maxConnectionTries = 3;
-        this.reconnectOnConnectionLoss = true;
-        this.options = options;
-    }
-    connect(endpoint) {
-        // force disconnect if already connected
-        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-            this.socket.close();
-        }
-        this.events = {};
-        this.connectionTries = 0;
-        return new Promise((resolve, reject) => {
-            this.socket = new WebSocket(endpoint, this.options);
-            this.endpoint = endpoint;
-            this.socket.addEventListener(`open`, (event) => {
-                resolve(event);
-            });
-            this.socket.addEventListener(`close`, (event) => {
-                if (this.reconnectOnConnectionLoss && !event.wasClean) {
-                    this.tryReconnect();
-                    reject(new Error(`Unhandled close. Reconnecting...`));
-                }
-                else {
-                    reject(event);
-                }
-            });
-            this.socket.addEventListener(`error`, (err) => {
-                reject(err);
-            });
-        });
-    }
-    tryReconnect() {
-        this.connectionTries++;
-        if (this.connectionTries > this.maxConnectionTries) {
-            return;
-        }
-        this.socket = new WebSocket(this.endpoint, this.options);
-        this.socket.addEventListener(`open`, () => {
-            this.connectionTries = 0;
-        });
-        this.socket.addEventListener(`close`, (event) => {
-            this.tryReconnect();
-        });
-    }
-    close() {
-        if (!this.socket)
-            return;
-        this.socket.close();
-    }
-    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 at least 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;
-                    }
-                }
-                // no more listener so we unsubscribe from daemon websocket if socket still open
-                if (listeners.length === 0) {
-                    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                        // we use a grace period to unsubscribe (mostly because of react useEffect and avoid unecessary subscribe)
-                        this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
-                            this.call(`unsubscribe`, { notify: event });
-                            Reflect.deleteProperty(this.events, event);
-                        }, this.unsubscribeSuspense);
-                    }
-                    else {
-                        // socket is closed so we don't send unsubscribe and no grace period delete right away
-                        Reflect.deleteProperty(this.events, event);
-                    }
-                }
-            }
-            this.socket && this.socket.removeEventListener(`message`, onMessage);
-            return Promise.resolve();
-        };
-        return Promise.resolve(closeListen);
-    }
-    call(method, params, overwriteData) {
-        return new Promise((resolve, reject) => {
-            if (!this.socket)
-                return reject(new Error(`Socket is not initialized.`));
-            if (this.socket.readyState !== WebSocket.OPEN)
-                return reject(new Error(`Can't send msg. Socket is not opened.`));
-            let requestMethod = this.createRequestMethod(method, params);
-            // for XSWD we want to send the application data without request method wrapping
-            if (overwriteData) {
-                requestMethod.id = null;
-                requestMethod.data = overwriteData;
-            }
-            let timeoutId = null;
-            const onMessage = (msgEvent) => {
-                if (typeof msgEvent.data === `string`) {
-                    const data = JSON.parse(msgEvent.data);
-                    if (data.id === requestMethod.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
-            if (this.timeout > 0) {
-                timeoutId = setTimeout(() => {
-                    this.socket && this.socket.removeEventListener(`message`, onMessage);
-                    reject(new Error(`timeout`));
-                }, this.timeout);
-            }
-            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                this.socket.send(requestMethod.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);
-        });
-    }
-    createRequestMethod(method, params) {
-        const id = this.methodIdIncrement++;
-        const request = { id: id, jsonrpc: `2.0`, method };
-        if (params)
-            request.params = params;
-        const data = JSON.stringify(request);
-        return { data, id };
-    }
-}

package/react/daemon.js

@@ -1,82 +0,0 @@
-import React, { createContext, useContext, useEffect, useState } from 'react';
-import to from 'await-to-js';
-import DaemonWS from '../daemon/websocket';
-export const INITIATING = -1;
-const daemon = new DaemonWS();
-const Context = createContext({
-    err: undefined,
-    daemon,
-    readyState: INITIATING
-});
-export const NodeSocketProvider = (props) => {
-    const { children, endpoint, timeout } = props;
-    const [readyState, setReadyState] = useState(INITIATING);
-    const [err, setErr] = useState();
-    useEffect(() => {
-        const connect = async () => {
-            setErr(undefined);
-            const [err, _] = await to(daemon.connect(endpoint));
-            if (err)
-                setErr(err);
-        };
-        connect();
-    }, [endpoint]);
-    useEffect(() => {
-        if (!timeout)
-            return;
-        daemon.timeout = timeout;
-    }, [timeout]);
-    useEffect(() => {
-        if (!daemon.socket)
-            return;
-        setReadyState(daemon.socket.readyState);
-        const onOpen = () => {
-            if (!daemon.socket)
-                return;
-            setReadyState(daemon.socket.readyState);
-            setErr(undefined);
-        };
-        const onClose = (event) => {
-            if (!daemon.socket)
-                return;
-            setReadyState(daemon.socket.readyState);
-            setErr(new Error(event.reason));
-        };
-        const onError = (err) => {
-            if (!daemon.socket)
-                return;
-            setReadyState(daemon.socket.readyState);
-            setErr(new Error(err.message));
-        };
-        daemon.socket.addEventListener(`open`, onOpen);
-        daemon.socket.addEventListener(`close`, onClose);
-        daemon.socket.addEventListener(`error`, onError);
-        return () => {
-            if (!daemon.socket)
-                return;
-            daemon.socket.removeEventListener(`open`, onOpen);
-            daemon.socket.removeEventListener(`close`, onClose);
-            daemon.socket.removeEventListener(`error`, onError);
-        };
-    }, [daemon.socket]);
-    return React.createElement(Context.Provider, { value: { daemon, err, readyState } }, children);
-};
-export const useNodeSocketSubscribe = ({ event, onLoad, onData }, dependencies) => {
-    const nodeSocket = useNodeSocket();
-    useEffect(() => {
-        if (nodeSocket.readyState !== WebSocket.OPEN)
-            return;
-        if (typeof onLoad === `function`)
-            onLoad();
-        let closeEvent;
-        const listen = async () => {
-            closeEvent = await nodeSocket.daemon.listenEvent(event, onData);
-        };
-        listen();
-        return () => {
-            closeEvent && closeEvent();
-        };
-    }, [nodeSocket, ...dependencies]);
-};
-export const useNodeSocket = () => useContext(Context);
-export default useNodeSocket;

package/wallet/rpc.js

@@ -1,55 +0,0 @@
-import { Base64 } from 'js-base64';
-import { RPCMethod } from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
-export class RPC extends BaseRPC {
-    constructor(endpoint, username, password) {
-        super(endpoint);
-        const authValue = Base64.encode(`${username}:${password}`);
-        this.auth = `Basic ${authValue}`;
-    }
-    async post(method, params) {
-        const headers = new Headers();
-        headers.set(`Authorization`, this.auth);
-        return super.post(method, params, headers);
-    }
-    getVersion() {
-        return this.post(RPCMethod.GetVersion);
-    }
-    getNonce() {
-        return this.post(RPCMethod.GetNonce);
-    }
-    getTopoheight() {
-        return this.post(RPCMethod.GetTopoheight);
-    }
-    getAddress(params = {}) {
-        return this.post(RPCMethod.GetAddress, params);
-    }
-    rescan() {
-        return this.post(RPCMethod.Rescan);
-    }
-    splitAddress(params) {
-        return this.post(RPCMethod.SplitAddress, params);
-    }
-    getBalance(asset) {
-        return this.post(RPCMethod.GetBalance, { asset });
-    }
-    getTrackedAssets() {
-        return this.post(RPCMethod.GetTrackedAssets);
-    }
-    getAssetPrecision(params) {
-        return this.post(RPCMethod.GetAssetPrecision, params);
-    }
-    getTransaction(hash) {
-        return this.post(RPCMethod.GetTransaction, { hash });
-    }
-    buildTransaction(params) {
-        return this.post(RPCMethod.BuildTransaction, params);
-    }
-    listTransactions(params) {
-        return this.post(RPCMethod.ListTransactions, params);
-    }
-    isOnline() {
-        return this.post(RPCMethod.IsOnline);
-    }
-}
-export default RPC;