@leofcoin/launch-chain 0.2.6 → 0.2.8

package/index.d.ts

@@ -1,7 +1,7 @@
 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 launchMode = 'direct' | 'remote' | 'server';
 type endpointReturns = {
     http?: string[];
     ws?: string[];

package/index.js

@@ -72,72 +72,98 @@ const launch = async (options, password) => {
         options = defaultOptions;
     else
         options = { ...defaultOptions, ...options };
-    const availableEndpoints = {
+    const clients = {
         http: [],
         ws: []
     };
-    const availableClients = {
+    const endpoints = {
         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 });
+    let chain;
+    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)
-                availableEndpoints.ws.push(endpoint.url) && availableClients.ws.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`);
     }
-    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.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,
+        mode: options.mode,
         endpoints,
-        clients: availableClients
+        clients
     };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/launch-chain",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "",
   "exports": {
     ".": "./index.js"
@@ -25,7 +25,7 @@
   "dependencies": {
     "@leofcoin/chain": "^1.4.8",
     "@leofcoin/endpoint-clients": "^0.2.3",
-    "@leofcoin/endpoints": "^0.2.0"
+    "@leofcoin/endpoints": "^0.2.10"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^11.0.0",

package/src/index.ts

@@ -4,7 +4,7 @@ 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[],
@@ -38,7 +38,7 @@ type launchOptions = {
   http?: endpointOptions[] | undefined,
 }
 
-const defaultOptions:launchOptions = {
+const defaultOptions: launchOptions = {
   network: 'leofcoin:peach',
   networkVersion: 'peach',
   stars: ['wss://peach.leofcoin.org'],
@@ -119,53 +119,71 @@ 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: []
   }
 
-  const availableClients: clientReturns = {
+  const endpoints: endpointReturns = {
     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})
+  let chain: Chain
+  
+  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 })
 
-  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})
+    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})
+      } 
     }
-  }
 
-  const endpoints: endpointReturns = {
-    http: [],
-    ws: []
-  }
+    if (options.http) {
+      const importee = await import('@leofcoin/endpoints/http')
+      const httpServer = importee.default
 
-  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`)
-    
+      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 })
 
@@ -174,22 +192,31 @@ 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)
+      } 
     }
+
     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,
+    mode: options.mode,
     endpoints,
-    clients: availableClients
+    clients
   }
 }
 

package/test.js

@@ -3,8 +3,6 @@ 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' }]
+  mode: 'direct'
 })
 console.log(await clients.ws[0].client.networkStats());