@xelis/sdk 0.7.0 → 0.8.0

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,67 +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);
-    }
-    getNetwork() {
-        return this.post(RPCMethod.GetNetwork);
-    }
-    getNonce() {
-        return this.post(RPCMethod.GetNonce);
-    }
-    getTopoheight() {
-        return this.post(RPCMethod.GetTopoheight);
-    }
-    getAddress(params = {}) {
-        return this.post(RPCMethod.GetAddress, params);
-    }
-    splitAddress(params) {
-        return this.post(RPCMethod.SplitAddress, params);
-    }
-    rescan() {
-        return this.post(RPCMethod.Rescan);
-    }
-    getBalance(asset) {
-        return this.post(RPCMethod.GetBalance, { asset });
-    }
-    hasBalance(asset) {
-        return this.post(RPCMethod.HasBalance, { 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);
-    }
-    signData(data) {
-        return this.post(RPCMethod.SignData, data);
-    }
-    estimateFees(txData) {
-        return this.post(RPCMethod.EstimateFees, { tx_type: txData });
-    }
-}
-export default RPC;

package/wallet/websocket.js

@@ -1,66 +0,0 @@
-import { WS as BaseWS } from '../lib/websocket';
-import { RPCMethod } from './types';
-export class WalletMethods {
-    constructor(ws, prefix = "") {
-        this.ws = ws;
-        this.prefix = prefix;
-    }
-    dataCall(method, params) {
-        return this.ws.dataCall(this.prefix + method, params);
-    }
-    getVersion() {
-        return this.dataCall(RPCMethod.GetVersion);
-    }
-    getNetwork() {
-        return this.dataCall(RPCMethod.GetNetwork);
-    }
-    getNonce() {
-        return this.dataCall(RPCMethod.GetNonce);
-    }
-    getTopoheight() {
-        return this.dataCall(RPCMethod.GetTopoheight);
-    }
-    getAddress(params = {}) {
-        return this.dataCall(RPCMethod.GetAddress, params);
-    }
-    splitAddress(params) {
-        return this.dataCall(RPCMethod.SplitAddress, params);
-    }
-    rescan() {
-        return this.dataCall(RPCMethod.Rescan);
-    }
-    getBalance(asset) {
-        return this.dataCall(RPCMethod.GetBalance, { asset });
-    }
-    getTrackedAssets() {
-        return this.dataCall(RPCMethod.GetTrackedAssets);
-    }
-    getAssetPrecision(params) {
-        return this.dataCall(RPCMethod.GetAssetPrecision, params);
-    }
-    getTransaction(hash) {
-        return this.dataCall(RPCMethod.GetTransaction, { hash });
-    }
-    buildTransaction(params) {
-        return this.dataCall(RPCMethod.BuildTransaction, params);
-    }
-    listTransactions(params) {
-        return this.dataCall(RPCMethod.GetTransaction, params);
-    }
-    isOnline() {
-        return this.dataCall(RPCMethod.IsOnline);
-    }
-    signData(data) {
-        return this.dataCall(RPCMethod.SignData, data);
-    }
-    estimateFees(txData) {
-        return this.dataCall(RPCMethod.EstimateFees, { tx_type: txData });
-    }
-}
-export class WS extends BaseWS {
-    constructor(username, password) {
-        super({ auth: `${username}:${password}` });
-        this.methods = new WalletMethods(this);
-    }
-}
-export default WS;

package/xswd/websocket.js

@@ -1,16 +0,0 @@
-import { WS as BaseWS } from '../lib/websocket';
-import { DaemonMethods } from '../daemon/websocket';
-import { WalletMethods } from '../wallet/websocket';
-export class WS extends BaseWS {
-    constructor() {
-        super();
-        this.timeout = 0;
-        this.daemon = new DaemonMethods(this, "node.");
-        this.wallet = new WalletMethods(this, "wallet.");
-    }
-    authorize(app) {
-        const data = JSON.stringify(app);
-        return this.call("", {}, data);
-    }
-}
-export default WS;