@leofcoin/peernet 0.16.7 → 0.17.1

package/exports/store.js

@@ -0,0 +1,225 @@
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { readdirSync } from 'fs';
+import { execSync } from 'child_process';
+import { ClassicLevel } from 'classic-level';
+
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode$1 = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
+};
+
+const decode$1 = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+};
+
+class KeyValue {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode$1(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyValue) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
+    }
+  }
+
+  isKeyValue() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'utf8') {
+    return decode$1(this.uint8Array)
+  }
+
+}
+
+const mkdirp = path => execSync(`mkdir "${platform() === 'win32' ? path.replace(/\//g, '\\') : path}"`);
+
+const init = (root, home = true) => {
+  let _root;
+  if (home) _root = join(homedir(), root);
+    if (readdirSync) try {
+      readdirSync(_root);
+    } catch (e) {
+      mkdirp(_root);
+    }
+
+    return _root
+};
+
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
+};
+
+const decode = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+};
+
+const pathSepS = '/';
+class KeyPath {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyPath) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
+    }
+  }
+  
+  isKeyPath() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'hex') {
+    return decode(this.uint8Array)
+  }
+
+  /**
+   * Returns the `list` representation of this path.
+   *
+   * @returns string[]
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+   * ```
+   */
+  list() {
+    return this.toString().split(pathSepS).slice(1)
+  }
+
+}
+
+class Store {
+  constructor(name = 'storage', root, version = 'v1.0.0') {
+    this.name = name;
+    this.root = init(root);
+    this.version = version;
+
+    this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view'});
+  }
+
+  toKeyPath(key) {
+    if (!key.isKeyPath()) key = new KeyPath(key);
+    return key.toString('base32')
+  }
+  
+  toKeyValue(value) {
+    if (!value.isKeyValue()) value = new KeyValue(value);
+    return value.uint8Array
+  }
+
+  async get(key) {
+    return this.db.get(this.toKeyPath(key))
+  }
+
+  async put(key, value) {
+    return this.db.put(this.toKeyPath(key), this.toKeyValue(value))
+  }
+
+  async delete(key) {
+    return this.db.del(this.toKeyPath(key))
+  }
+
+  async clear() {
+    return this.db.clear()
+  }
+
+  async values(limit = -1) {
+    const values = [];
+    for await (const value of this.db.values({limit})) {
+      values.push(value);
+    }
+    return values
+  }
+
+  async keys(limit = -1) {
+    const keys = [];
+    for await (const key of this.db.keys({limit})) {
+      keys.push(key);
+    }
+    return keys
+  }
+
+    /**
+     * 
+     * @param {object} options {  limit, gt, lt, reverse }
+     * @returns 
+     */
+  iterate(options) {
+    return this.db.iterator(options)
+  }
+
+}
+
+export { Store as default };

package/index.html

@@ -9,9 +9,9 @@
     </script> -->
 
     <script type="module">
-      import Peernet from './dist/browser/peernet.mjs';
+      import Peernet from './dist/peernet.js';
       (async () => {
-        const peernet = await new Peernet()
+        const peernet = await new Peernet({network: 'leofcoin:peach', networkVersion: 'peach'})
         peernet.addRequestHandler('lastBlock', () => new peernet.protos['peernet-response']({response: new TextEncoder().encode(100)}))
       })()
     </script>

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.16.7",
+  "version": "0.17.1",
   "description": "",
   "main": "src/peernet.js",
+  "exports": {
+    ".": "./exports/peernet.js",
+    "./browser": "./exports/browser/peernet.js"
+  },
   "type": "module",
   "engines": {
     "node": ">=19.0.0"
   },
   "scripts": {
+    "build": "rollup -c",
+    "watch": "rollup -c -w",
     "set-flags": "set NODE_OPTIONS=--openssl-legacy-provider",
     "test": "npm run set-flags && node test/index.js",
     "server": "discovery-swarm-webrtc --port=4000",
@@ -19,20 +25,29 @@
   "license": "MIT",
   "dependencies": {
     "@leofcoin/codec-format-interface": "^1.4.0",
-    "@leofcoin/generate-account": "^1.0.4",
-    "@leofcoin/multi-wallet": "^2.1.2",
+    "@leofcoin/generate-account": "^1.2.0",
+    "@leofcoin/multi-wallet": "^3.0.1",
     "@leofcoin/peernet-swarm": "^0.5.0",
     "@leofcoin/storage": "^3.0.0",
+    "@types/node": "^18.11.18",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",
     "@vandeurenglenn/debug": "^1.0.0",
     "@vandeurenglenn/is-hex": "^1.0.0",
     "@vandeurenglenn/little-pubsub": "^1.3.1",
+    "multi-signature": "^1.3.1",
     "socket-request-client": "^1.5.0",
     "socket-request-server": "^1.5.0"
   },
   "devDependencies": {
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-wasm": "^6.1.1",
+    "@types/bs58check": "^2.1.0",
+    "@types/secp256k1": "^4.0.3",
+    "@types/varint": "^6.0.1",
     "eslint": "^8.29.0",
-    "eslint-plugin-unicorn": "^45.0.1"
+    "eslint-plugin-unicorn": "^45.0.1",
+    "rollup": "^3.9.0"
   }
 }

package/rollup.config.js

@@ -0,0 +1,30 @@
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import wasm from '@rollup/plugin-wasm'
+import rimraf from 'rimraf'
+
+rimraf.sync('./exports/**')
+
+
+export default [{
+  input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/browser-store.js'],
+  output: {
+    format: 'es',
+    dir: './exports/browser'
+  },
+  plugins: [
+    json(),
+    wasm(),
+    commonjs(),
+    resolve({
+      mainFields: ["browser", "module", "main"]
+    })
+  ]
+}, {
+  input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/store.js'],
+  output: {
+    format: 'es',
+    dir: './exports'
+  }
+}]

package/src/{peernet.js → peernet.ts}

@@ -190,7 +190,7 @@ export default class Peernet {
 
     const {daemon, environment} = await target()
     this.hasDaemon = daemon
-
+    
     for (const store of this.defaultStores) {
       await this.addStore(store, options.storePrefix, options.root)
     }
@@ -253,7 +253,7 @@ export default class Peernet {
      * @type {PeernetClient}
      */
     this.client = new importee.default(this.id, this.networkVersion, this.stars)
-    if (globalThis.onbeforeunload) {
+    if (globalThis.navigator) {
       globalThis.addEventListener('beforeunload', async () => this.client.close());
     } else {
       process.on('SIGTERM', async () => {

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "module": "ES2022",
+    "target": "es2022",
+    // "noImplicitAny": true,
+    "removeComments": true,
+    "preserveConstEnums": true,
+    "outDir": ".build/",
+    "moduleResolution":"NodeNext",
+    "sourceMap": true,
+    "allowJs": true
+  },
+  "include": [
+    "./src/**/*",
+    "@vandeurenglenn/little-pubsub",
+    "@leofcoin/storage"
+  ],
+  "exclude": ["node_modules", "**/*.spec.ts"]
+}

package/src/server.js

@@ -1,24 +0,0 @@
-import server from 'socket-request-server/server';
-import socketResponse from 'socket-request-server/response';
-
-globalThis.peerMap = new Map()
-
-server({
-  peernet: (params, response) => {
-    if (params.join) {
-      peerMap.set(params.peerId, params.address)
-      response.send([...peerMap.values()])
-      for (const connection of connections) {
-        console.log(connection);
-        socketResponse(connection, 'peernet', 'peernet').send({
-          discovered: params.address,
-        })
-      }
-      return
-    }
-    if (!params.join) {
-      peerMap.delete(params.peerId)
-      return response.send()
-    }
-  },
-})