@leofcoin/launch-chain 0.2.5 → 0.2.7

package/index.d.ts

@@ -1,13 +1,20 @@
 import Chain from '@leofcoin/chain/chain';
-type launchMode = 'direct' | 'remote';
+import WSClient from '@leofcoin/endpoint-clients/ws';
+import HttpClient from '@leofcoin/endpoint-clients/http';
+type launchMode = 'direct' | 'remote' | 'server';
 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;
@@ -18,6 +25,7 @@ type launchOptions = {
     networkVersion?: string;
     stars: string[];
     forceRemote: boolean;
+    mode?: launchMode;
     ws?: endpointOptions[] | undefined;
     http?: endpointOptions[] | undefined;
 };

package/index.js

@@ -1,12 +1,15 @@
 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,
+    mode: 'direct',
     ws: [{
             port: 4040
         }],
@@ -20,22 +23,21 @@ const defaultOptions = {
  * @param {string} networkVersion network/testnet-network sepperate by -
  * @returns Promise(boolean)
  */
-const hasHttp = async (url, networkVersion) => {
+const getHttp = async (url, networkVersion) => {
     try {
-        await fetch(url + '/network');
-        return true;
+        const client = new HttpClient(url, networkVersion);
+        await client.network();
+        return client;
     }
     catch (error) {
-        return false;
+        return undefined;
     }
 };
 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);
+        const socket = await new WSClient(url, networkVersion);
+        await socket.init();
+        resolve(socket);
     }
     catch (error) {
         reject(error);
@@ -47,13 +49,13 @@ const tryWs = (url, networkVersion) => new Promise(async (resolve, reject) => {
  * @param {string} networkVersion network/testnet-network sepperate by -
  * @returns Promise(boolean)
  */
-const hasWs = async (url, networkVersion) => {
+const getWS = async (url, networkVersion) => {
     try {
-        await tryWs(url, networkVersion);
-        return true;
+        const ws = await tryWs(url, networkVersion);
+        return ws;
     }
     catch (error) {
-        return false;
+        return undefined;
     }
 };
 // chain is undefined when mode is remote
@@ -70,65 +72,98 @@ const launch = async (options, password) => {
         options = defaultOptions;
     else
         options = { ...defaultOptions, ...options };
-    const availableEndpoints = {
+    const clients = {
         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';
+    if (options.mode === 'remote') {
+        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)
+                    endpoints.http.push(endpoint.url) && clients.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)
+                    endpoints.ws.push(endpoint.url) && clients.ws.push({ url: endpoint.url, client });
+            }
+        }
+        if (endpoints.http.length === 0 && endpoints.ws.length === 0)
+            throw new Error(`no remotes connected`);
+    }
+    else if (options.mode === 'direct') {
+        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;
+            for (const endpoint of options.ws) {
+                if (endpoint.port && !endpoint.url)
+                    endpoint.url = `ws://localhost:${endpoint.port}`;
+                await wsServer(chain, endpoint.port, options.networkVersion);
+                endpoints.ws.push(endpoint.url);
+                const client = await getWS(endpoint.url, options.networkVersion);
+                if (client)
+                    endpoints.ws.push(endpoint.url) && clients.ws.push({ url: endpoint.url, client });
+            }
+        }
+        if (options.http) {
+            const importee = await import('@leofcoin/endpoints/http');
+            const httpServer = importee.default;
+            for (const endpoint of options.http) {
+                if (endpoint.port && !endpoint.url)
+                    endpoint.url = `http://localhost:${endpoint.port}`;
+                await httpServer(chain, endpoint.port, options.networkVersion);
+                endpoints.http.push(endpoint.url);
+                const client = await getHttp(endpoint.url, options.networkVersion);
+                if (client)
+                    endpoints.http.push(endpoint.url) && clients.http.push({ url: endpoint.url, client });
+            }
+        }
     }
     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);
+            for (const endpoint of options.ws) {
+                if (endpoint.port && !endpoint.url)
+                    endpoint.url = `ws://localhost:${endpoint.port}`;
+                await wsServer(chain, endpoint.port, options.networkVersion);
+                endpoints.ws.push(endpoint.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);
+            for (const endpoint of options.http) {
+                if (endpoint.port && !endpoint.url)
+                    endpoint.url = `http://localhost:${endpoint.port}`;
+                await httpServer(chain, endpoint.port, options.networkVersion);
+                endpoints.http.push(endpoint.url);
+            }
         }
-        mode = 'direct';
     }
     return {
         chain,
-        mode,
-        endpoints
+        mode: options.mode,
+        endpoints,
+        clients
     };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/launch-chain",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "",
   "exports": {
     ".": "./index.js"
@@ -24,7 +24,8 @@
   "homepage": "https://github.com/leofcoin/launch-chain#readme",
   "dependencies": {
     "@leofcoin/chain": "^1.4.8",
-    "@leofcoin/endpoints": "^0.2.0"
+    "@leofcoin/endpoint-clients": "^0.2.3",
+    "@leofcoin/endpoints": "^0.2.10"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^11.0.0",

package/src/index.ts

@@ -1,18 +1,26 @@
 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 launchMode = 'direct' | 'remote' | 'server'
 
 type endpointReturns = {
   http?: string[],
   ws?: string[],
 }
 
+type clientReturns = {
+  http?: HttpClient[],
+  ws?: WSClient[],
+}
+
 type launchReturn = {
   chain: Chain,
   mode: launchMode,
-  endpoints: endpointReturns
+  endpoints: endpointReturns,
+  clients: clientReturns
 }
 
 type endpointOptions = {
@@ -25,15 +33,17 @@ type launchOptions = {
   networkVersion?: string,
   stars: string[],
   forceRemote: boolean,
+  mode?: launchMode,
   ws?: endpointOptions[] | undefined,
   http?: endpointOptions[] | undefined,
 }
 
-const defaultOptions:launchOptions = {
+const defaultOptions: launchOptions = {
   network: 'leofcoin:peach',
   networkVersion: 'peach',
   stars: ['wss://peach.leofcoin.org'],
   forceRemote: false,
+  mode: 'direct',
   ws: [{
     port: 4040
   }],
@@ -48,21 +58,21 @@ const defaultOptions:launchOptions = {
  * @param {string} networkVersion network/testnet-network sepperate by -
  * @returns Promise(boolean)
  */
-const hasHttp = async (url: string, networkVersion: string) => {
+const getHttp = async (url: string, networkVersion: string): Promise<undefined | HttpClient> => {
   try {
-    await fetch(url + '/network')
-    return true
+    const client = new HttpClient(url, networkVersion)
+    await client.network()
+    return client
   } catch (error) {
-    return false
+    return undefined
   }
 }
 
-const tryWs = (url: string | URL, networkVersion: string | string[]): Promise<boolean> => new Promise(async (resolve, reject) => {
+const tryWs = (url: string, networkVersion: string): Promise<WSClient> => 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)
+    const socket = await new WSClient(url, networkVersion)
+    await socket.init()
+    resolve(socket)
   } catch (error) {
     reject(error)
   }
@@ -74,12 +84,12 @@ const tryWs = (url: string | URL, networkVersion: string | string[]): Promise<bo
  * @param {string} networkVersion network/testnet-network sepperate by -
  * @returns Promise(boolean)
  */
-const hasWs = async (url: string, networkVersion: string): Promise<boolean> => {
+const getWS = async (url: string, networkVersion: string): Promise<WSClient> => {
   try {
-    await tryWs(url, networkVersion)
-    return true
+    const ws = await tryWs(url, networkVersion)
+    return ws
   } catch (error) {
-    return false
+    return undefined
   }
 }
 
@@ -91,8 +101,8 @@ const hasWs = async (url: string, networkVersion: string): Promise<boolean> => {
  * @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)
+  const ws = await getWS(wsURL, networkVersion)
+  const http = await getHttp(httpURL, networkVersion)
   return {http, ws}
 }
 
@@ -109,46 +119,36 @@ const launch = async (options: launchOptions, password: string): Promise<launchR
   if (!options) options = defaultOptions
   else options = {...defaultOptions, ...options }
 
-  const availableEndpoints: endpointReturns = {
+  const clients: clientReturns = {
     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`)
-    
+  
+  if (options.mode === 'remote') {
+    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) endpoints.http.push(endpoint.url) && clients.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) endpoints.ws.push(endpoint.url) && clients.ws.push({url: endpoint.url, client})
+      }
+    }
+    if (endpoints.http.length === 0 && endpoints.ws.length === 0) throw new Error(`no remotes connected`)
+  } else if (options.mode === 'direct') {
     await new Node({ network: options.network, stars: options.stars, networkVersion: options.networkVersion }, password)
     await nodeConfig({ network: options.network, stars: options.stars, networkVersion: options.networkVersion })
 
@@ -157,21 +157,66 @@ const launch = async (options: launchOptions, password: string): Promise<launchR
     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)
+
+      for (const endpoint of options.ws) {
+        if (endpoint.port && !endpoint.url) endpoint.url = `ws://localhost:${endpoint.port}`
+        
+        await wsServer(chain, endpoint.port, options.networkVersion)
+        endpoints.ws.push(endpoint.url)
+        
+        const client = await getWS(endpoint.url, options.networkVersion)
+        if (client) endpoints.ws.push(endpoint.url) && clients.ws.push({url: endpoint.url, client})
+      } 
     }
+
     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)
+
+      for (const endpoint of options.http) {
+        if (endpoint.port && !endpoint.url) endpoint.url = `http://localhost:${endpoint.port}`
+
+        await httpServer(chain, endpoint.port, options.networkVersion)
+        endpoints.http.push(endpoint.url)
+
+        const client = await getHttp(endpoint.url, options.networkVersion)
+        if (client) endpoints.http.push(endpoint.url) && clients.http.push({url: endpoint.url, client})
+      }
+    }
+  } else {
+    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
+
+      for (const endpoint of options.ws) {
+        if (endpoint.port && !endpoint.url) endpoint.url = `ws://localhost:${endpoint.port}`
+        await wsServer(chain, endpoint.port, options.networkVersion)
+        endpoints.ws.push(endpoint.url)
+      } 
+    }
+
+    if (options.http) {
+      const importee = await import('@leofcoin/endpoints/http')
+      const httpServer = importee.default
+
+      for (const endpoint of options.http) {
+        if (endpoint.port && !endpoint.url) endpoint.url = `http://localhost:${endpoint.port}`
+        await httpServer(chain, endpoint.port, options.networkVersion)
+        endpoints.http.push(endpoint.url)
+      }
     }
-    mode = 'direct'
   }
+  
   return {
     chain,
-    mode,
-    endpoints
+    mode: options.mode,
+    endpoints,
+    clients
   }
 }
 

package/test.js

@@ -1,6 +1,8 @@
 import launch from './index.js'
 
-console.log(await launch({
+const {chain, endpoints, clients, mode } = await launch({
   network: 'leofcoin:peach',
-  networkVersion: 'peach'
-}));
+  networkVersion: 'peach',
+  mode: 'direct'
+})
+console.log(await clients.ws[0].client.networkStats());

package/tsconfig.json

@@ -1,9 +1,9 @@
 {
   "compilerOptions": {
-    "target": "es2022",
-    "module": "es2022",
+    "target": "ESNext",
+    "module": "ESNext",
     "outDir": "./",
-    "moduleResolution":"NodeNext",
+    "moduleResolution":"nodenext",
     "allowJs": true,
     "declaration": true
   },