@leofcoin/launch-chain 0.2.4 → 0.2.6

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 vandeurenglenn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2022 vandeurenglenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/index.d.ts

@@ -1,30 +1,38 @@
-import Chain from '@leofcoin/chain/chain';
-type launchMode = 'direct' | 'remote';
-type endpointReturns = {
-    http?: string[];
-    ws?: string[];
-};
-type launchReturn = {
-    chain: Chain;
-    mode: launchMode;
-    endpoints: endpointReturns;
-};
-type endpointOptions = {
-    port: number;
-    url?: string;
-};
-type launchOptions = {
-    network?: string;
-    networkVersion?: string;
-    stars: string[];
-    forceRemote: boolean;
-    ws?: endpointOptions[] | undefined;
-    http?: endpointOptions[] | undefined;
-};
-/**
- *
- * @param {object} options { ws: boolean || {url: string, port: number}, http: boolean || {url: string, port: number}, network}
- * @returns '{ mode: string, endpoints: object, chain}'
- */
-declare const launch: (options: launchOptions) => Promise<launchReturn>;
-export { launch as default };
+import Chain from '@leofcoin/chain/chain';
+import WSClient from '@leofcoin/endpoint-clients/ws';
+import HttpClient from '@leofcoin/endpoint-clients/http';
+type launchMode = 'direct' | 'remote';
+type endpointReturns = {
+    http?: string[];
+    ws?: string[];
+};
+type clientReturns = {
+    http?: HttpClient[];
+    ws?: WSClient[];
+};
+type launchReturn = {
+    chain: Chain;
+    mode: launchMode;
+    endpoints: endpointReturns;
+    clients: clientReturns;
+};
+type endpointOptions = {
+    port: number;
+    url?: string;
+};
+type launchOptions = {
+    network?: string;
+    networkVersion?: string;
+    stars: string[];
+    forceRemote: boolean;
+    mode?: launchMode;
+    ws?: endpointOptions[] | undefined;
+    http?: endpointOptions[] | undefined;
+};
+/**
+ *
+ * @param {object} options { ws: boolean || {url: string, port: number}, http: boolean || {url: string, port: number}, network}
+ * @returns '{ mode: string, endpoints: object, chain}'
+ */
+declare const launch: (options: launchOptions, password: string) => Promise<launchReturn>;
+export { launch as default };

package/index.js

@@ -1,135 +1,144 @@
 import Node from '@leofcoin/chain/node';
 import Chain from '@leofcoin/chain/chain';
 import nodeConfig from '@leofcoin/lib/node-config';
+import WSClient from '@leofcoin/endpoint-clients/ws';
+import HttpClient from '@leofcoin/endpoint-clients/http';
 
-const defaultOptions = {
-    network: 'leofcoin:peach',
-    networkVersion: 'peach',
-    stars: ['wss://peach.leofcoin.org'],
-    forceRemote: false,
-    ws: [{
-            port: 4040
-        }],
-    http: [{
-            port: 8080
-        }]
-};
-/**
- *
- * @param {string} url
- * @param {string} networkVersion network/testnet-network sepperate by -
- * @returns Promise(boolean)
- */
-const hasHttp = async (url, networkVersion) => {
-    try {
-        await fetch(url + '/network');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-};
-const tryWs = (url, networkVersion) => new Promise(async (resolve, reject) => {
-    try {
-        const socket = await new WebSocket(url, networkVersion);
-        socket.onerror = () => resolve(false);
-        if (socket.readyState === 1)
-            socket.close();
-        resolve(true);
-    }
-    catch (error) {
-        reject(error);
-    }
-});
-/**
- *
- * @param {string} url
- * @param {string} networkVersion network/testnet-network sepperate by -
- * @returns Promise(boolean)
- */
-const hasWs = async (url, networkVersion) => {
-    try {
-        await tryWs(url, networkVersion);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-};
-// chain is undefined when mode is remote
-// endpoints contain urls to connect to the desired remote
-// when mode is remote means an instance is already running
-// when mode is direct means chain is directly available and no endpoint is needed to interact with it
-/**
- *
- * @param {object} options { ws: boolean || {url: string, port: number}, http: boolean || {url: string, port: number}, network}
- * @returns '{ mode: string, endpoints: object, chain}'
- */
-const launch = async (options) => {
-    if (!options)
-        options = defaultOptions;
-    else
-        options = { ...defaultOptions, ...options };
-    const availableEndpoints = {
-        http: [],
-        ws: []
-    };
-    if (options.http) {
-        for (const endpoint of options.http) {
-            if (endpoint.port && !endpoint.url)
-                endpoint.url = `http://localhost:${endpoint.port}`;
-            if (await hasHttp(endpoint.url, options.networkVersion))
-                availableEndpoints.http.push(endpoint.url);
-        }
-    }
-    if (options.ws) {
-        for (const endpoint of options.ws) {
-            if (endpoint.port && !endpoint.url)
-                endpoint.url = `ws://localhost:${endpoint.port}`;
-            if (await hasWs(endpoint.url, options.networkVersion))
-                availableEndpoints.ws.push(endpoint.url);
-        }
-    }
-    const endpoints = {
-        http: [],
-        ws: []
-    };
-    let chain;
-    let mode;
-    if (availableEndpoints.http.length > 0 || availableEndpoints.ws.length > 0) {
-        availableEndpoints.http.forEach(endpoint => {
-            endpoints.http.push(endpoint);
-        });
-        availableEndpoints.ws.forEach(endpoint => {
-            endpoints.ws.push(endpoint);
-        });
-        mode = 'remote';
-    }
-    else {
-        if (options.forceRemote)
-            throw new Error(`forceRemote was set but no remotes connected`);
-        await new Node({ network: options.network, stars: options.stars, networkVersion: options.networkVersion });
-        await nodeConfig({ network: options.network, stars: options.stars, networkVersion: options.networkVersion });
-        chain = await new Chain();
-        if (options.ws) {
-            const importee = await import('@leofcoin/endpoints/ws');
-            const wsServer = importee.default;
-            await wsServer(chain, options.ws[0].port, options.networkVersion);
-            endpoints.ws.push(options.ws[0].url);
-        }
-        if (options.http) {
-            const importee = await import('@leofcoin/endpoints/http');
-            const httpServer = importee.default;
-            await httpServer(chain, options.http[0].port, options.networkVersion);
-            endpoints.http.push(options.http[0].url);
-        }
-        mode = 'direct';
-    }
-    return {
-        chain,
-        mode,
-        endpoints
-    };
+const defaultOptions = {
+    network: 'leofcoin:peach',
+    networkVersion: 'peach',
+    stars: ['wss://peach.leofcoin.org'],
+    forceRemote: false,
+    mode: 'direct',
+    ws: [{
+            port: 4040
+        }],
+    http: [{
+            port: 8080
+        }]
+};
+/**
+ *
+ * @param {string} url
+ * @param {string} networkVersion network/testnet-network sepperate by -
+ * @returns Promise(boolean)
+ */
+const getHttp = async (url, networkVersion) => {
+    try {
+        const client = new HttpClient(url, networkVersion);
+        await client.network();
+        return client;
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+const tryWs = (url, networkVersion) => new Promise(async (resolve, reject) => {
+    try {
+        const socket = await new WSClient(url, networkVersion);
+        await socket.init();
+        resolve(socket);
+    }
+    catch (error) {
+        reject(error);
+    }
+});
+/**
+ *
+ * @param {string} url
+ * @param {string} networkVersion network/testnet-network sepperate by -
+ * @returns Promise(boolean)
+ */
+const getWS = async (url, networkVersion) => {
+    try {
+        const ws = await tryWs(url, networkVersion);
+        return ws;
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+// chain is undefined when mode is remote
+// endpoints contain urls to connect to the desired remote
+// when mode is remote means an instance is already running
+// when mode is direct means chain is directly available and no endpoint is needed to interact with it
+/**
+ *
+ * @param {object} options { ws: boolean || {url: string, port: number}, http: boolean || {url: string, port: number}, network}
+ * @returns '{ mode: string, endpoints: object, chain}'
+ */
+const launch = async (options, password) => {
+    if (!options)
+        options = defaultOptions;
+    else
+        options = { ...defaultOptions, ...options };
+    const availableEndpoints = {
+        http: [],
+        ws: []
+    };
+    const availableClients = {
+        http: [],
+        ws: []
+    };
+    if (options.http) {
+        for (const endpoint of options.http) {
+            if (endpoint.port && !endpoint.url)
+                endpoint.url = `http://localhost:${endpoint.port}`;
+            const client = await getHttp(endpoint.url, options.networkVersion);
+            if (client)
+                availableEndpoints.http.push(endpoint.url) && availableClients.http.push({ url: endpoint.url, client });
+        }
+    }
+    if (options.ws) {
+        for (const endpoint of options.ws) {
+            if (endpoint.port && !endpoint.url)
+                endpoint.url = `ws://localhost:${endpoint.port}`;
+            const client = await getWS(endpoint.url, options.networkVersion);
+            if (client)
+                availableEndpoints.ws.push(endpoint.url) && availableClients.ws.push({ url: endpoint.url, client });
+        }
+    }
+    const endpoints = {
+        http: [],
+        ws: []
+    };
+    let chain;
+    let mode;
+    if (availableEndpoints.http.length > 0 || availableEndpoints.ws.length > 0) {
+        availableEndpoints.http.forEach(endpoint => {
+            endpoints.http.push(endpoint);
+        });
+        availableEndpoints.ws.forEach(endpoint => {
+            endpoints.ws.push(endpoint);
+        });
+        mode = 'remote';
+    }
+    else {
+        if (options.forceRemote)
+            throw new Error(`forceRemote was set but no remotes connected`);
+        await new Node({ network: options.network, stars: options.stars, networkVersion: options.networkVersion }, password);
+        await nodeConfig({ network: options.network, stars: options.stars, networkVersion: options.networkVersion });
+        chain = await new Chain();
+        if (options.ws) {
+            const importee = await import('@leofcoin/endpoints/ws');
+            const wsServer = importee.default;
+            await wsServer(chain, options.ws[0].port, options.networkVersion);
+            endpoints.ws.push(options.ws[0].url);
+        }
+        if (options.http) {
+            const importee = await import('@leofcoin/endpoints/http');
+            const httpServer = importee.default;
+            await httpServer(chain, options.http[0].port, options.networkVersion);
+            endpoints.http.push(options.http[0].url);
+        }
+        mode = 'direct';
+    }
+    return {
+        chain,
+        mode,
+        endpoints,
+        clients: availableClients
+    };
 };
 
 export { launch as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/launch-chain",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "",
   "exports": {
     ".": "./index.js"
@@ -24,6 +24,7 @@
   "homepage": "https://github.com/leofcoin/launch-chain#readme",
   "dependencies": {
     "@leofcoin/chain": "^1.4.8",
+    "@leofcoin/endpoint-clients": "^0.2.3",
     "@leofcoin/endpoints": "^0.2.0"
   },
   "devDependencies": {

package/rollup.config.js

@@ -1,13 +1,13 @@
-import typescript from '@rollup/plugin-typescript';
-import tsconfig from './tsconfig.json' assert { type: 'json'};
-
-export default [{
-  input: ['./src/index.ts'],
-  output: {
-    format: 'es',
-    dir: './'
-  },
-  plugins: [
-    typescript(tsconfig)
-  ]
+import typescript from '@rollup/plugin-typescript';
+import tsconfig from './tsconfig.json' assert { type: 'json'};
+
+export default [{
+  input: ['./src/index.ts'],
+  output: {
+    format: 'es',
+    dir: './'
+  },
+  plugins: [
+    typescript(tsconfig)
+  ]
 }]

package/src/index.ts

@@ -1,178 +1,196 @@
-import Node from '@leofcoin/chain/node'
-import Chain from '@leofcoin/chain/chain'
-import nodeConfig from '@leofcoin/lib/node-config'
-
-type launchMode = 'direct' | 'remote'
-
-type endpointReturns = {
-  http?: string[],
-  ws?: string[],
-}
-
-type launchReturn = {
-  chain: Chain,
-  mode: launchMode,
-  endpoints: endpointReturns
-}
-
-type endpointOptions = {
-  port: number,
-  url?: string
-}
-
-type launchOptions = {
-  network?: string,
-  networkVersion?: string,
-  stars: string[],
-  forceRemote: boolean,
-  ws?: endpointOptions[] | undefined,
-  http?: endpointOptions[] | undefined,
-}
-
-const defaultOptions:launchOptions = {
-  network: 'leofcoin:peach',
-  networkVersion: 'peach',
-  stars: ['wss://peach.leofcoin.org'],
-  forceRemote: false,
-  ws: [{
-    port: 4040
-  }],
-  http: [{
-    port: 8080
-  }]
-}
-
-/**
- * 
- * @param {string} url 
- * @param {string} networkVersion network/testnet-network sepperate by -
- * @returns Promise(boolean)
- */
-const hasHttp = async (url: string, networkVersion: string) => {
-  try {
-    await fetch(url + '/network')
-    return true
-  } catch (error) {
-    return false
-  }
-}
-
-const tryWs = (url: string | URL, networkVersion: string | string[]): Promise<boolean> => new Promise(async (resolve, reject) => {
-  try {
-    const socket = await new WebSocket(url, networkVersion)
-    socket.onerror = () => resolve(false)
-    if (socket.readyState === 1) socket.close()
-    resolve(true)
-  } catch (error) {
-    reject(error)
-  }
-})
-
-/**
- * 
- * @param {string} url 
- * @param {string} networkVersion network/testnet-network sepperate by -
- * @returns Promise(boolean)
- */
-const hasWs = async (url: string, networkVersion: string): Promise<boolean> => {
-  try {
-    await tryWs(url, networkVersion)
-    return true
-  } catch (error) {
-    return false
-  }
-}
-
-/**
- * 
- * @param {string} httpURL 
- * @param {string} wsURL 
- * @param {string} networkVersion 
- * @returns Promise({http: boolean, ws: boolean})
- */
-const hasClient = async (httpURL: string, wsURL: string, networkVersion: string) => {
-  const ws = await hasWs(wsURL, networkVersion)
-  const http = await hasHttp(httpURL, networkVersion)
-  return {http, ws}
-}
-
-// chain is undefined when mode is remote
-// endpoints contain urls to connect to the desired remote
-// when mode is remote means an instance is already running
-// when mode is direct means chain is directly available and no endpoint is needed to interact with it
-/**
- * 
- * @param {object} options { ws: boolean || {url: string, port: number}, http: boolean || {url: string, port: number}, network}
- * @returns '{ mode: string, endpoints: object, chain}'
- */
-const launch = async (options: launchOptions): Promise<launchReturn> => {
-  if (!options) options = defaultOptions
-  else options = {...defaultOptions, ...options }
-
-  const availableEndpoints: endpointReturns = {
-    http: [],
-    ws: []
-  }
-
-  if (options.http) {
-    for (const endpoint of options.http) {
-      if (endpoint.port && !endpoint.url) endpoint.url = `http://localhost:${endpoint.port}`
-      if (await hasHttp(endpoint.url, options.networkVersion)) availableEndpoints.http.push(endpoint.url)
-    }
-  }
-
-  if (options.ws) {
-    for (const endpoint of options.ws) {
-      if (endpoint.port && !endpoint.url) endpoint.url = `ws://localhost:${endpoint.port}`      
-      if (await hasWs(endpoint.url, options.networkVersion)) availableEndpoints.ws.push(endpoint.url)
-    }
-  }
-
-  const endpoints: endpointReturns = {
-    http: [],
-    ws: []
-  }
-
-  let chain: Chain
-  let mode: launchMode
-
-  if (availableEndpoints.http.length > 0 || availableEndpoints.ws.length > 0) {
-    availableEndpoints.http.forEach(endpoint => {
-      endpoints.http.push(endpoint)
-    })
-
-    availableEndpoints.ws.forEach(endpoint => {
-      endpoints.ws.push(endpoint)
-    })
-    
-    mode = 'remote'
-  } else {   
-    if (options.forceRemote) throw new Error(`forceRemote was set but no remotes connected`)
-    
-    await new Node({ network: options.network, stars: options.stars, networkVersion: options.networkVersion })
-    await nodeConfig({ network: options.network, stars: options.stars, networkVersion: options.networkVersion })
-
-    chain = await new Chain()
-
-    if (options.ws) {
-      const importee = await import('@leofcoin/endpoints/ws')
-      const wsServer = importee.default
-      await wsServer(chain, options.ws[0].port, options.networkVersion)
-      endpoints.ws.push(options.ws[0].url)
-    }
-    if (options.http) {
-      const importee = await import('@leofcoin/endpoints/http')
-      const httpServer = importee.default
-      await httpServer(chain, options.http[0].port, options.networkVersion)
-      endpoints.http.push(options.http[0].url)
-    }
-    mode = 'direct'
-  }
-  return {
-    chain,
-    mode,
-    endpoints
-  }
-}
-
+import Node from '@leofcoin/chain/node'
+import Chain from '@leofcoin/chain/chain'
+import nodeConfig from '@leofcoin/lib/node-config'
+import WSClient from '@leofcoin/endpoint-clients/ws'
+import HttpClient from '@leofcoin/endpoint-clients/http'
+
+type launchMode = 'direct' | 'remote'
+
+type endpointReturns = {
+  http?: string[],
+  ws?: string[],
+}
+
+type clientReturns = {
+  http?: HttpClient[],
+  ws?: WSClient[],
+}
+
+type launchReturn = {
+  chain: Chain,
+  mode: launchMode,
+  endpoints: endpointReturns,
+  clients: clientReturns
+}
+
+type endpointOptions = {
+  port: number,
+  url?: string
+}
+
+type launchOptions = {
+  network?: string,
+  networkVersion?: string,
+  stars: string[],
+  forceRemote: boolean,
+  mode?: launchMode,
+  ws?: endpointOptions[] | undefined,
+  http?: endpointOptions[] | undefined,
+}
+
+const defaultOptions:launchOptions = {
+  network: 'leofcoin:peach',
+  networkVersion: 'peach',
+  stars: ['wss://peach.leofcoin.org'],
+  forceRemote: false,
+  mode: 'direct',
+  ws: [{
+    port: 4040
+  }],
+  http: [{
+    port: 8080
+  }]
+}
+
+/**
+ * 
+ * @param {string} url 
+ * @param {string} networkVersion network/testnet-network sepperate by -
+ * @returns Promise(boolean)
+ */
+const getHttp = async (url: string, networkVersion: string): Promise<undefined | HttpClient> => {
+  try {
+    const client = new HttpClient(url, networkVersion)
+    await client.network()
+    return client
+  } catch (error) {
+    return undefined
+  }
+}
+
+const tryWs = (url: string, networkVersion: string): Promise<WSClient> => new Promise(async (resolve, reject) => {
+  try {
+    const socket = await new WSClient(url, networkVersion)
+    await socket.init()
+    resolve(socket)
+  } catch (error) {
+    reject(error)
+  }
+})
+
+/**
+ * 
+ * @param {string} url 
+ * @param {string} networkVersion network/testnet-network sepperate by -
+ * @returns Promise(boolean)
+ */
+const getWS = async (url: string, networkVersion: string): Promise<WSClient> => {
+  try {
+    const ws = await tryWs(url, networkVersion)
+    return ws
+  } catch (error) {
+    return undefined
+  }
+}
+
+/**
+ * 
+ * @param {string} httpURL 
+ * @param {string} wsURL 
+ * @param {string} networkVersion 
+ * @returns Promise({http: boolean, ws: boolean})
+ */
+const hasClient = async (httpURL: string, wsURL: string, networkVersion: string) => {
+  const ws = await getWS(wsURL, networkVersion)
+  const http = await getHttp(httpURL, networkVersion)
+  return {http, ws}
+}
+
+// chain is undefined when mode is remote
+// endpoints contain urls to connect to the desired remote
+// when mode is remote means an instance is already running
+// when mode is direct means chain is directly available and no endpoint is needed to interact with it
+/**
+ * 
+ * @param {object} options { ws: boolean || {url: string, port: number}, http: boolean || {url: string, port: number}, network}
+ * @returns '{ mode: string, endpoints: object, chain}'
+ */
+const launch = async (options: launchOptions, password: string): Promise<launchReturn> => {
+  if (!options) options = defaultOptions
+  else options = {...defaultOptions, ...options }
+
+  const availableEndpoints: endpointReturns = {
+    http: [],
+    ws: []
+  }
+
+  const availableClients: clientReturns = {
+    http: [],
+    ws: []
+  }
+
+  if (options.http) {
+    for (const endpoint of options.http) {
+      if (endpoint.port && !endpoint.url) endpoint.url = `http://localhost:${endpoint.port}`
+      const client = await getHttp(endpoint.url, options.networkVersion)
+      if (client) availableEndpoints.http.push(endpoint.url) && availableClients.http.push({url: endpoint.url, client})
+    }
+  }
+
+  if (options.ws) {
+    for (const endpoint of options.ws) {
+      if (endpoint.port && !endpoint.url) endpoint.url = `ws://localhost:${endpoint.port}`      
+      const client = await getWS(endpoint.url, options.networkVersion)
+      if (client) availableEndpoints.ws.push(endpoint.url) && availableClients.ws.push({url: endpoint.url, client})
+    }
+  }
+
+  const endpoints: endpointReturns = {
+    http: [],
+    ws: []
+  }
+
+  let chain: Chain
+  let mode: launchMode
+
+  if (availableEndpoints.http.length > 0 || availableEndpoints.ws.length > 0) {
+    availableEndpoints.http.forEach(endpoint => {
+      endpoints.http.push(endpoint)
+    })
+
+    availableEndpoints.ws.forEach(endpoint => {
+      endpoints.ws.push(endpoint)
+    })
+    
+    mode = 'remote'
+  } else {   
+    if (options.forceRemote) throw new Error(`forceRemote was set but no remotes connected`)
+    
+    await new Node({ network: options.network, stars: options.stars, networkVersion: options.networkVersion }, password)
+    await nodeConfig({ network: options.network, stars: options.stars, networkVersion: options.networkVersion })
+
+    chain = await new Chain()
+
+    if (options.ws) {
+      const importee = await import('@leofcoin/endpoints/ws')
+      const wsServer = importee.default
+      await wsServer(chain, options.ws[0].port, options.networkVersion)
+      endpoints.ws.push(options.ws[0].url)
+    }
+    if (options.http) {
+      const importee = await import('@leofcoin/endpoints/http')
+      const httpServer = importee.default
+      await httpServer(chain, options.http[0].port, options.networkVersion)
+      endpoints.http.push(options.http[0].url)
+    }
+    mode = 'direct'
+  }
+  return {
+    chain,
+    mode,
+    endpoints,
+    clients: availableClients
+  }
+}
+
 export { launch as default}

package/test.js

@@ -1,6 +1,10 @@
-import launch from './index.js'
-
-console.log(await launch({
-  network: 'leofcoin:peach',
-  networkVersion: 'peach'
-}));
+import launch from './index.js'
+
+const {chain, endpoints, clients, mode } = await launch({
+  network: 'leofcoin:peach',
+  networkVersion: 'peach',
+  forceRemote: true,
+  ws: [{ url:'wss://ws-remote.leofcoin.org'}],
+  http: [{ url: 'https://remote.leofcoin.org' }]
+})
+console.log(await clients.ws[0].client.networkStats());

package/tsconfig.json

@@ -1,14 +1,14 @@
-{
-  "compilerOptions": {
-    "target": "es2022",
-    "module": "es2022",
-    "outDir": "./",
-    "moduleResolution":"NodeNext",
-    "allowJs": true,
-    "declaration": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": ["./node_modules"]
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "outDir": "./",
+    "moduleResolution":"nodenext",
+    "allowJs": true,
+    "declaration": true
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": ["./node_modules"]
 }