@xelis/sdk 0.5.18 → 0.6.0

package/README.md

@@ -12,33 +12,67 @@ Install library with NPM.
 
 Import library and start working :).
 
-Use http/rpc connection.
+Use Daemon HTTP RPC connection.
 
 ```js
-import { TESTNET_NODE_RPC } from '@xelis/sdk/config/nodes'
+import { TESTNET_NODE_RPC } from '@xelis/sdk/config'
 import DaemonRPC from '@xelis/sdk/daemon/rpc'
 
 const main = async () => {
-  const daemonRPC = new DaemonRPC(TESTNET_NODE_RPC)
-  const info = await daemonRPC.getInfo()
+  const daemon = new DaemonRPC(TESTNET_NODE_RPC)
+  const info = await daemon.getInfo()
   console.log(info)
 }
 
 main()
 ```
 
-Use websocket connection.
+Use Daemon WebSocket RPC connection.
 
 ```js
-import { TESTNET_NODE_WS } from '@xelis/sdk/config/nodes'
+import { TESTNET_NODE_WS } from '@xelis/sdk/config'
 import DaemonWS from '@xelis/sdk/daemon/websocket'
 
 const main = async () => {
-  const daemonWS = new DaemonWS()
-  await daemonWS.connect(TESTNET_NODE_WS)
-  const info = await daemonWS.getInfo()
+  const daemon = new DaemonWS()
+  await daemon.connect(TESTNET_NODE_WS)
+  const info = await daemon.methods.getInfo()
   console.log(info)
 }
 
 main()
 ```
+
+Use Wallet WebSocket RPC connection.
+
+```js
+import { LOCAL_WALLET_WS } from '@xelis/sdk/config'
+import DaemonWS from '@xelis/sdk/wallet/websocket'
+
+const main = async () => {
+  const wallet = new WalletWS(`test`, `test`) // username, password
+  await wallet.connect(LOCAL_WALLET_WS)
+  const address = await wallet.methods.getAddress()
+  console.log(address)
+}
+
+main()
+```
+
+Use XSWD protocol.
+
+```js
+import { LOCAL_XSWD_WS } from '@xelis/sdk/config'
+import XSWD from '@xelis/sdk/xswd/websocket'
+
+const main = async () => {
+  const xswd = new XSWD()
+  await xswd.connect(LOCAL_XSWD_WS)
+  const info = await xswd.daemon.getInfo()
+  console.log(info)
+  const address = await xswd.wallet.getAddress()
+  console.log(address)
+}
+
+main()
+```

package/config.d.ts

@@ -0,0 +1,36 @@
+export declare const DAEMON_RPC_PORT = "8080";
+export declare const WALLET_RPC_PORT = "8081";
+export declare const XSWD_PORT = "44325";
+export declare const MAINNET_NODE_URL = "node.xelis.io";
+export declare const TESTNET_NODE_URL = "testnet-node.xelis.io";
+export declare const LOCAL_NODE_URL: string;
+export declare const MAINNET_NODE_RPC: string;
+export declare const TESTNET_NODE_RPC: string;
+export declare const LOCAL_NODE_RPC: string;
+export declare const MAINNET_NODE_WS: string;
+export declare const TESTNET_NODE_WS: string;
+export declare const LOCAL_NODE_WS: string;
+export declare const LOCAL_WALLET_URL: string;
+export declare const LOCAL_WALLET_RPC: string;
+export declare const LOCAL_WALLET_WS: string;
+export declare const LOCAL_XSWD_URL: string;
+export declare const LOCAL_XSWD_WS: string;
+declare const _default: {
+    MAINNET_NODE_URL: string;
+    TESTNET_NODE_URL: string;
+    MAINNET_NODE_RPC: string;
+    TESTNET_NODE_RPC: string;
+    LOCAL_NODE_RPC: string;
+    MAINNET_NODE_WS: string;
+    TESTNET_NODE_WS: string;
+    LOCAL_NODE_WS: string;
+    DAEMON_RPC_PORT: string;
+    WALLET_RPC_PORT: string;
+    XSWD_PORT: string;
+    LOCAL_WALLET_URL: string;
+    LOCAL_WALLET_RPC: string;
+    LOCAL_WALLET_WS: string;
+    LOCAL_XSWD_URL: string;
+    LOCAL_XSWD_WS: string;
+};
+export default _default;

package/config.js

@@ -0,0 +1,25 @@
+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/websocket.d.ts

@@ -1,7 +1,12 @@
 import { MessageEvent } from 'ws';
 import { Block, GetInfoResult, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetBalanceResult, HeightRangeParams, BlockOrdered, GetBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceParams, GetNonceResult, GetAccountHistoryParams, AccounHistory, Peer, PeerPeerListUpdated, PeerPeerDisconnected, DevFee, DiskSize, AssetWithData, AssetData, GetAssetParams, HasBalanceParams, HasBalanceResult, IsTxExecutedInBlockParams, BlockOrphaned } from './types';
 import { WS as BaseWS } from '../lib/websocket';
-declare class WS extends BaseWS {
+export declare class DaemonMethods {
+    ws: BaseWS;
+    prefix: string;
+    constructor(ws: BaseWS, prefix?: string);
+    listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
+    dataCall<T>(method: string, params?: any): Promise<T>;
     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>>;
@@ -49,4 +54,8 @@ declare class WS extends BaseWS {
     getSizeOnDisk(): Promise<DiskSize>;
     isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<boolean>;
 }
+declare class WS extends BaseWS {
+    methods: DaemonMethods;
+    constructor();
+}
 export default WS;

package/daemon/websocket.js

@@ -1,6 +1,16 @@
 import { RPCEvent, RPCMethod } from './types';
 import { WS as BaseWS } from '../lib/websocket';
-class WS extends BaseWS {
+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);
     }
@@ -140,4 +150,10 @@ class WS extends BaseWS {
         return this.dataCall(RPCMethod.IsTxExecutedInBlock, params);
     }
 }
+class WS extends BaseWS {
+    constructor() {
+        super();
+        this.methods = new DaemonMethods(this);
+    }
+}
 export default WS;

package/lib/rpc.d.ts

@@ -3,5 +3,5 @@ export declare class RPC {
     endpoint: string;
     timeout: number;
     constructor(endpoint: string);
-    post<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+    post<T>(method: string, params?: any, headers?: Headers): Promise<RPCResponse<T>>;
 }

package/lib/rpc.js

@@ -3,14 +3,17 @@ export class RPC {
         this.endpoint = endpoint;
         this.timeout = 3000;
     }
-    async post(method, params) {
+    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
@@ -28,6 +31,7 @@ export class RPC {
             }
         }
         catch (err) {
+            console.log(err);
             return Promise.reject(err);
         }
     }

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 export interface RPCRequest {
-    id: number;
+    id: number | null;
     jsonrpc: string;
     method: string;
     params: string;

package/lib/websocket.d.ts

@@ -1,5 +1,7 @@
-import { MessageEvent } from 'ws';
+/// <reference types="node" />
+import { ClientOptions, MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
+import { ClientRequestArgs } from 'http';
 import { RPCResponse } from './types';
 export declare class WS {
     endpoint: string;
@@ -8,20 +10,21 @@ export declare class WS {
     unsubscribeSuspense: number;
     reconnectOnConnectionLoss: boolean;
     maxConnectionTries: number;
+    options?: ClientOptions | ClientRequestArgs;
     connectionTries: number;
     methodIdIncrement: number;
     private events;
-    constructor();
+    constructor(options?: ClientOptions | ClientRequestArgs);
     connect(endpoint: string): Promise<unknown>;
     tryReconnect(): void;
     close(): void;
     private clearEvent;
     closeAllListens(event: string): Promise<void>;
     listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
-    call<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+    call<T>(method: string, params?: any, overwriteData?: string): Promise<RPCResponse<T>>;
     dataCall<T>(method: string, params?: any): Promise<T>;
     createRequestMethod(method: string, params?: any): {
         data: string;
-        id: number;
+        id: number | null;
     };
 }

package/lib/websocket.js

@@ -1,7 +1,7 @@
 import WebSocket from 'isomorphic-ws';
 import to from 'await-to-js';
 export class WS {
-    constructor() {
+    constructor(options) {
         this.connectionTries = 0;
         this.methodIdIncrement = 0;
         this.endpoint = "";
@@ -10,6 +10,7 @@ export class WS {
         this.unsubscribeSuspense = 1000;
         this.maxConnectionTries = 3;
         this.reconnectOnConnectionLoss = true;
+        this.options = options;
     }
     connect(endpoint) {
         // force disconnect if already connected
@@ -19,7 +20,7 @@ export class WS {
         this.events = {};
         this.connectionTries = 0;
         return new Promise((resolve, reject) => {
-            this.socket = new WebSocket(endpoint);
+            this.socket = new WebSocket(endpoint, this.options);
             this.endpoint = endpoint;
             this.socket.addEventListener(`open`, (event) => {
                 resolve(event);
@@ -43,7 +44,7 @@ export class WS {
         if (this.connectionTries > this.maxConnectionTries) {
             return;
         }
-        this.socket = new WebSocket(this.endpoint);
+        this.socket = new WebSocket(this.endpoint, this.options);
         this.socket.addEventListener(`open`, () => {
             this.connectionTries = 0;
         });
@@ -143,18 +144,23 @@ export class WS {
         };
         return Promise.resolve(closeListen);
     }
-    call(method, params) {
+    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.`));
-            const { data, id } = this.createRequestMethod(method, params);
+            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 === id) {
+                    if (data.id === requestMethod.id) {
                         clearTimeout(timeoutId);
                         this.socket && this.socket.removeEventListener(`message`, onMessage);
                         if (data.error)
@@ -166,12 +172,14 @@ export class WS {
             };
             // 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);
+            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(data);
+                this.socket.send(requestMethod.data);
             }
         });
     }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.18",
+  "version": "0.6.0",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "repository": {
@@ -22,6 +22,7 @@
   "dependencies": {
     "await-to-js": "^3.0.0",
     "isomorphic-ws": "^5.0.0",
+    "js-base64": "^3.7.6",
     "react": "^18.2.0",
     "ws": "^8.12.1"
   }

package/wallet/rpc.d.ts

@@ -1,19 +1,23 @@
 import { Transaction, GetAssetParams } from '../daemon/types';
 import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
+import { RPCResponse } from '../lib/types';
 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>>;
-    rescan(): Promise<import("../lib/types").RPCResponse<void>>;
-    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[]>>;
-    getAssetPrecision(params: GetAssetParams): Promise<import("../lib/types").RPCResponse<number>>;
-    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[]>>;
-    isOnline(): Promise<import("../lib/types").RPCResponse<boolean>>;
+    auth: string;
+    constructor(endpoint: string, username: string, password: string);
+    post<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+    getVersion(): Promise<RPCResponse<string>>;
+    getNonce(): Promise<RPCResponse<number>>;
+    getTopoheight(): Promise<RPCResponse<number>>;
+    getAddress(params?: GetAddressParams): Promise<RPCResponse<string>>;
+    rescan(): Promise<RPCResponse<void>>;
+    splitAddress(params: SplitAddressParams): Promise<RPCResponse<SplitAddressResult>>;
+    getBalance(asset?: string): Promise<RPCResponse<number>>;
+    getTrackedAssets(): Promise<RPCResponse<string[]>>;
+    getAssetPrecision(params: GetAssetParams): Promise<RPCResponse<number>>;
+    getTransaction(hash: string): Promise<RPCResponse<Transaction>>;
+    buildTransaction(params: BuildTransactionParams): Promise<RPCResponse<BuildTransactionResult>>;
+    listTransactions(params?: ListTransactionParams): Promise<RPCResponse<Transaction[]>>;
+    isOnline(): Promise<RPCResponse<boolean>>;
 }
 export default RPC;

package/wallet/rpc.js

@@ -1,6 +1,17 @@
+import { Base64 } from 'js-base64';
 import { RPCMethod } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
 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);
     }
@@ -10,7 +21,7 @@ class RPC extends BaseRPC {
     getTopoheight() {
         return this.post(RPCMethod.GetTopoheight);
     }
-    getAddress(params) {
+    getAddress(params = {}) {
         return this.post(RPCMethod.GetAddress, params);
     }
     rescan() {

package/wallet/types.d.ts

@@ -45,3 +45,16 @@ export declare enum RPCMethod {
     SignData = "sign_data",
     EstimateFees = "estimate_fees"
 }
+export declare enum Permission {
+    Ask = 0,
+    AcceptAlways = 1,
+    DenyAlways = 2
+}
+export interface ApplicationData {
+    id: string;
+    name: string;
+    description: string;
+    url?: string;
+    permissions: Map<string, Permission>;
+    signature?: string;
+}

package/wallet/types.js

@@ -17,3 +17,9 @@ export var RPCMethod;
     RPCMethod["SignData"] = "sign_data";
     RPCMethod["EstimateFees"] = "estimate_fees";
 })(RPCMethod || (RPCMethod = {}));
+export var Permission;
+(function (Permission) {
+    Permission[Permission["Ask"] = 0] = "Ask";
+    Permission[Permission["AcceptAlways"] = 1] = "AcceptAlways";
+    Permission[Permission["DenyAlways"] = 2] = "DenyAlways";
+})(Permission || (Permission = {}));

package/wallet/websocket.d.ts

@@ -1,7 +1,11 @@
 import { WS as BaseWS } from '../lib/websocket';
 import { GetAssetParams, Transaction } from '../daemon/types';
 import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult } from './types';
-declare class WS extends BaseWS {
+export declare class WalletMethods {
+    ws: BaseWS;
+    prefix: string;
+    constructor(ws: BaseWS, prefix?: string);
+    dataCall<T>(method: string, params?: any): Promise<T>;
     getVersion(): Promise<string>;
     getNetwork(): Promise<string>;
     getNonce(): Promise<number>;
@@ -17,4 +21,8 @@ declare class WS extends BaseWS {
     listTransactions(params?: ListTransactionParams): Promise<Transaction[]>;
     isOnline(): Promise<boolean>;
 }
+declare class WS extends BaseWS {
+    methods: WalletMethods;
+    constructor(username: string, password: string);
+}
 export default WS;

package/wallet/websocket.js

@@ -1,6 +1,13 @@
 import { WS as BaseWS } from '../lib/websocket';
 import { RPCMethod } from './types';
-class WS extends BaseWS {
+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);
     }
@@ -13,7 +20,7 @@ class WS extends BaseWS {
     getTopoheight() {
         return this.dataCall(RPCMethod.GetTopoheight);
     }
-    getAddress(params) {
+    getAddress(params = {}) {
         return this.dataCall(RPCMethod.GetAddress, params);
     }
     rescan() {
@@ -44,4 +51,10 @@ class WS extends BaseWS {
         return this.dataCall(RPCMethod.IsOnline);
     }
 }
+class WS extends BaseWS {
+    constructor(username, password) {
+        super({ auth: `${username}:${password}` });
+        this.methods = new WalletMethods(this);
+    }
+}
 export default WS;

package/xswd/types.d.ts

@@ -0,0 +1,13 @@
+export declare enum Permission {
+    Ask = 0,
+    AcceptAlways = 1,
+    DenyAlways = 2
+}
+export interface ApplicationData {
+    id: string;
+    name: string;
+    description: string;
+    url?: string;
+    permissions: Map<string, Permission>;
+    signature?: string;
+}

package/xswd/types.js

@@ -0,0 +1,6 @@
+export var Permission;
+(function (Permission) {
+    Permission[Permission["Ask"] = 0] = "Ask";
+    Permission[Permission["AcceptAlways"] = 1] = "AcceptAlways";
+    Permission[Permission["DenyAlways"] = 2] = "DenyAlways";
+})(Permission || (Permission = {}));

package/xswd/websocket.d.ts

@@ -0,0 +1,11 @@
+import { WS as BaseWS } from '../lib/websocket';
+import { ApplicationData } from '../wallet/types';
+import { DaemonMethods } from '../daemon/websocket';
+import { WalletMethods } from '../wallet/websocket';
+declare class WS extends BaseWS {
+    daemon: DaemonMethods;
+    wallet: WalletMethods;
+    constructor();
+    authorize(app: ApplicationData): Promise<import("../lib/types").RPCResponse<unknown>>;
+}
+export default WS;

package/xswd/websocket.js

@@ -0,0 +1,16 @@
+import { WS as BaseWS } from '../lib/websocket';
+import { DaemonMethods } from '../daemon/websocket';
+import { WalletMethods } from '../wallet/websocket';
+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;

package/config/nodes.d.ts

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

package/config/nodes.js

@@ -1,11 +0,0 @@
-export const NODE_URL = `node.xelis.io`;
-export const TESTNET_NODE_URL = `testnet-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 NODE_WS = `wss://${NODE_URL}/json_rpc`;
-export const TESTNET_NODE_WS = `wss://${TESTNET_NODE_URL}/json_rpc`;
-export default {
-    NODE_URL, TESTNET_NODE_URL,
-    NODE_RPC, TESTNET_NODE_RPC,
-    NODE_WS, TESTNET_NODE_WS
-};