@leofcoin/launch-chain 0.2.2 → 0.2.4

package/README.md

@@ -19,6 +19,7 @@ const {chain, endpoints, mode} = await launch()
 {
   network: 'leofcoin:peach',
   stars: ['wss://peach.leofcoin.org'],
+  forceRemote: false, // when set to true only tries to connect to an external/local exposed node
   ws: {
     port: 4040,
     url: 'ws://localhost:4040'

package/index.d.ts

@@ -0,0 +1,30 @@
+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 };

package/index.js

@@ -0,0 +1,135 @@
+import Node from '@leofcoin/chain/node';
+import Chain from '@leofcoin/chain/chain';
+import nodeConfig from '@leofcoin/lib/node-config';
+
+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
+    };
+};
+
+export { launch as default };

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@leofcoin/launch-chain",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "",
   "exports": {
-    ".": "./exports/launch.js"
+    ".": "./index.js"
   },
+  "types": "./index.d.ts",
   "type": "module",
   "scripts": {
+    "build": "rollup -c",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
@@ -23,5 +25,10 @@
   "dependencies": {
     "@leofcoin/chain": "^1.4.8",
     "@leofcoin/endpoints": "^0.2.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^11.0.0",
+    "rollup": "^3.9.1",
+    "tslib": "^2.4.1"
   }
 }

package/rollup.config.js

@@ -0,0 +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)
+  ]
+}]

package/src/index.ts

@@ -0,0 +1,178 @@
+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
+  }
+}
+
+export { launch as default}

package/test.js

@@ -1,6 +1,6 @@
-import launch from './exports/launch.js'
+import launch from './index.js'
 
-launch({
+console.log(await launch({
   network: 'leofcoin:peach',
   networkVersion: 'peach'
-})
+}));

package/tsconfig.json

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

package/exports/launch.js

@@ -1,116 +0,0 @@
-import Node from '@leofcoin/chain/node'
-import Chain from '@leofcoin/chain/chain'
-import nodeConfig from '@leofcoin/lib/node-config'
-
-/**
- * 
- * @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
-  }
-}
-
-/**
- * 
- * @param {string} httpURL 
- * @param {string} wsURL 
- * @param {string} networkVersion 
- * @returns Promise({http: boolean, ws: boolean})
- */
-const hasClient = async (httpURL, wsURL, networkVersion) => {
-  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 = {}) => {
-  if (!options) options = {}
-  if (!options.network) options.network = 'leofcoin:peach'
-  if (!options.stars) options.stars = ['wss://peach.leofcoin.org']
-  if (options.ws === undefined) options.ws = { port: 4040 }
-  if (options.http === undefined) options.http = { port: 8080 }
-  if (options.networkVersion === undefined) options.networkVersion = options.network.replace(':', '-')
-
-  if (options.http?.port && !options.http.url) options.http.url = `http://localhost:${options.http.port}`
-  if (options.ws?.port && !options.ws.url) options.ws.url = `ws://localhost:${options.ws.port}`
-
-  const clients = await hasClient(options.http.url, options.ws.url, options.networkVersion)
-  let endpoints = {}
-  let chain
-  let mode
-
-  if (clients.http || clients.ws) {
-    Object.entries(clients).forEach(([key, value]) => {
-      if (value) endpoints[key] = options[key].url      
-    })
-    mode = 'remote'
-  } else {    
-    await new Node({ network: options.network, stars: options.stars })
-    await nodeConfig({ network: options.network, stars: options.stars })
-
-    chain = await new Chain()
-
-    if (options.ws) {
-      const importee = await import('@leofcoin/endpoints/ws')
-      const wsServer = importee.default
-      await wsServer(chain, options.ws.port, options.networkVersion)
-      endpoints.ws = options.ws.url
-    }
-    if (options.http) {
-      const importee = await import('@leofcoin/endpoints/http')
-      const httpServer = importee.default
-      await httpServer(chain, options.http.port, options.networkVersion)
-      endpoints.http = options.http.url
-    }
-    mode = 'direct'
-  }
-  return {
-    chain,
-    mode,
-    endpoints
-  }
-}
-
-export { launch as default}