@leofcoin/peernet 0.11.12 → 0.11.15

package/dist/module/peernet.js

@@ -6,20 +6,16 @@ import bs58 from '@vandeurenglenn/base58';
 import isHex from '@vandeurenglenn/is-hex';
 import varint from 'varint';
 import createKeccakHash from 'keccak';
-import fetch from 'node-fetch';
 import generateAccount from '@leofcoin/generate-account';
 import * as bs58check from 'bs58check';
 import bs58check__default from 'bs58check';
-import { generateMnemonic, mnemonicToSeed } from 'bip39';
 import * as bip32 from 'bip32';
-import { publicKeyConvert } from 'secp256k1';
 import ecc from 'tiny-secp256k1';
+import Mnemonic from '@leofcoin/mnemonic';
 import MultiSignature from 'multi-signature';
-import AES from 'crypto-js/aes.js';
-import 'crypto-js/sha512.js';
-import ENC from 'crypto-js/enc-utf8.js';
+import randombytes from 'randombytes';
 
-/* socket-request-client version 1.6.1 */
+/* socket-request-client version 1.6.3 */
 
 class LittlePubSub {
   constructor(verbose = true) {
@@ -206,9 +202,6 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
       peernet: api.peernet(client),
       server: api.server(client),
       close: exit => {
-        client.onclose = message => {
-          if (exit) process.exit();
-        };
         client.close();
       }
     }
@@ -275,6 +268,10 @@ class Peer {
     return this.#connected
   }
 
+  get readyState() {
+    return this.channel?.readyState
+  }
+
 /**
  * @params {Object} options
  * @params {string} options.channelName - this peerid : otherpeer id
@@ -314,8 +311,19 @@ constructor(options = {}) {
    }
 
    send(message) {
-     this.bw.up += message.length || message.byteLength;
-     this.channel.send(message);
+     switch (this.channel?.readyState) {
+       case 'open':
+        this.bw.up += message.length || message.byteLength;
+        this.channel.send(message);
+       break;
+       case 'closed':
+       case 'closing':
+        debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+       break;
+       case undefined:
+       debug(`trying to send before a channel is created`);
+       break;
+     }
    }
 
    request(data) {
@@ -388,7 +396,6 @@ constructor(options = {}) {
         this.channel.onmessage = (message) => {
           pubsub.publish('peer:data', message);
           debug(`incoming message from ${this.peerId}`);
-          debug(message);
           this.bw.down += message.length || message.byteLength;
         };
 
@@ -448,6 +455,7 @@ constructor(options = {}) {
 
  close() {
    debug(`closing ${this.peerId}`);
+   this.#connected = false;
    this.channel?.close();
    this.#connection?.close();
 
@@ -464,6 +472,10 @@ class Client {
     return { ...this.#connections }
   }
 
+  get peers() {
+    return Object.entries(this.#connections)
+  }
+
   constructor(id, identifiers = ['peernet-v0.1.0'], stars = []) {
     this.id = id || Math.random().toString(36).slice(-12);
     if (!Array.isArray(identifiers)) identifiers = [identifiers];
@@ -578,6 +590,15 @@ class Client {
     debug(`peer ${id} joined`);
   }
 
+  removePeer(peer) {
+    const id = peer.peerId || peer;
+    if (this.#connections[id]) {
+      this.#connections[id].connected && this.#connections[id].close();
+      delete this.#connections[id];
+    }
+    debug(`peer ${id} removed`);
+  }
+
 
 }
 
@@ -984,14 +1005,14 @@ class FormatInterface {
     this.protoDecode = proto.decode;
     this.hashFormat = options.hashFormat || 'bs32';
     if (options.name) this.name = options.name;
-    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
+    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer);
+    else if (buffer instanceof ArrayBuffer) this.fromArrayBuffer(buffer);
     else if (buffer.name === options.name) return buffer
-    else if (typeof buffer === 'string') {
-        if (isHex(buffer)) this.fromHex(buffer);
-        else if (bs32.isBase32(buffer)) this.fromBs32(buffer);
-        else if (bs58.isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
+    else if (buffer instanceof String) {
+      if (isHex(buffer)) this.fromHex(buffer);
+      else if (bs32.isBase32(buffer)) this.fromBs32(buffer);
+      else if (bs58.isBase58(buffer)) this.fromBs58(buffer);
+      else throw new Error(`unsupported string ${buffer}`)
     } else {
       this.create(buffer);
     }
@@ -1677,6 +1698,7 @@ const bitcoin = {
 	messagePrefix: '\x18Bitcoin Signed Message:\n',
 	bech32: 'bc',
 	pubKeyHash: 0x00,
+	multiCodec: 0x00,
 	scriptHash: 0x05,
 	wif: 0x80,
 	coin_type: 0,
@@ -1725,12 +1747,15 @@ const fromNetworkString = network => {
   network = networks[parts[0]];
   if (parts[1]) {
     if (network[parts[1]]) network = network[parts[1]];
-    
+
     network.coin_type = 1;
   }
 	return network;
 };
 
+// import { createHash } from 'crypto'
+// import { createHash as _createHash } from './hash'
+
 const { encode: encode$1, decode: decode$1 } = bs58check__default;
 class HDWallet {
 
@@ -1758,20 +1783,48 @@ class HDWallet {
 		return this.ifNotLocked(() => this.publicKeyBuffer.toString('hex'))
 	}
 
+	get ethereumAddress() {
+		const buffer = ecc.pointFromScalar(this.hdnode.__D, false);
+		let hash = createKeccakHash('keccak256').update(buffer.slice(1)).digest();
+		return `0x${hash.slice(-20).toString('hex')}`
+	}
+
+	// async bitcoinAddress() {
+	// 	const chainCode = this.privateKeyBuffer
+	//
+	// 	const node = bip32.fromPrivateKey(this.privateKeyBuffer, chainCode, networks['bitcoin'])
+	// 	let buffer = await _createHash(node.publicKey, 'SHA-256')
+	// 	buffer = createHash('ripemd160').update(buffer).digest()
+	// 	// buffer = Buffer.from(`0x00${buffer.toString('hex')}`, 'hex')
+	// 	// buffer = createHash('sha256').update(buffer).digest()
+	// 	// const mainHash = buffer
+	// 	// buffer = createHash('sha256').update(buffer).digest()
+	// 	// const checksum = buffer.toString('hex').substring(0, 8)
+	// 	// return base58.encode(Buffer.concat([mainHash, Buffer.from(checksum, 'hex')]))
+	// 	const payload = Buffer.allocUnsafe(21)
+	//   payload.writeUInt8(networks['bitcoin'].pubKeyHash, 0)
+	//   buffer.copy(payload, 1)
+	//
+  // 	return encode(payload)
+	// }
+
+	get leofcoinAddress() {
+		return encode$1(this.neutered.publicKeyBuffer)
+	}
+
 	get address() {
-		// override testnet coin_type
-		let coin_type = this.hdnode.network.coin_type;
+		return this.getAddressForCoin()
+	}
+
+	getAddressForCoin(coin_type) {
+		if (!coin_type) coin_type = this.hdnode.network.coin_type;
 		if (coin_type === 1) {
 			if (this.networkName?.split(':')[0] === 'ethereum') coin_type = 60;
 			if (this.networkName?.split(':')[0] === 'leofcoin') coin_type = 640;
 		}
-		if (coin_type === 60 || coin_type === 640) {
-			let buffer = ecc.pointFromScalar(this.hdnode.__D, false);
-			buffer = Buffer.from(publicKeyConvert(buffer, false)).slice(1);
-			let hash = createKeccakHash('keccak256').update(buffer).digest();
-			return hash.slice(-20).toString('hex')
-		}
-		return encode$1(this.neutered.publicKeyBuffer)
+		// if (coin_type === 0) return this.bitcoinAddress
+		if (coin_type === 60) return this.ethereumAddress
+		if (coin_type === 640) return this.leofcoinAddress
 	}
 
 	get accountAddress() {
@@ -1818,10 +1871,10 @@ class HDWallet {
 
 	async generate(password, network) {
 		network = this.validateNetwork(network);
-		const mnemonic = generateMnemonic(256);
-		const seed = await mnemonicToSeed(mnemonic, password);
+		const mnemonic = new Mnemonic().generate();
+		const seed = new Mnemonic().seedFromMnemonic(mnemonic, password);
 		this.defineHDNode(bip32.fromSeed(seed, network));
-		return mnemonic; // userpw
+		return mnemonic;
 	}
 
 	/**
@@ -1829,7 +1882,7 @@ class HDWallet {
    */
 	async recover(mnemonic, password, network) {
 		network = this.validateNetwork(network, password);
-		const seed = await mnemonicToSeed(mnemonic);
+		const seed = new Mnemonic().seedFromMnemonic(mnemonic, password);
 		this.defineHDNode(bip32.fromSeed(seed, network));
 	}
 
@@ -1862,6 +1915,71 @@ class HDWallet {
 	}
 }
 
+const { subtle } = crypto;
+
+const generateAesKey = async (length = 256) => {
+  const key = await subtle.generateKey({
+    name: 'AES-CBC',
+    length
+  }, true, ['encrypt', 'decrypt']);
+
+  return key;
+};
+
+const importAesKey = async (exported, format = 'raw', length = 256) => {
+  return await subtle.importKey(format, exported, {
+    name: 'AES-CBC',
+    length
+  }, true, ['encrypt', 'decrypt'])
+};
+
+const exportAesKey = async (key, format = 'raw') => {
+  return await subtle.exportKey(format, key)
+};
+
+const encryptAes = async (uint8Array, key, iv) => subtle.encrypt({
+    name: 'AES-CBC',
+    iv,
+  }, key, uint8Array);
+
+const uint8ArrayToHex = uint8Array =>
+  [...uint8Array].map(x => x.toString(16).padStart(2, '0')).join('');
+
+const arrayBufferToHex = arrayBuffer =>
+  uint8ArrayToHex(new Uint8Array(arrayBuffer));
+
+const hexToUint8Array = hex =>
+  new Uint8Array(hex.match(/[\da-f]{2}/gi).map(x => parseInt(x, 16)));
+
+const encrypt = async string => {
+  const ec = new TextEncoder();
+  const key = await generateAesKey();
+  const iv = await randombytes(16);
+
+  const ciphertext = await encryptAes(ec.encode(string), key, iv);
+  const exported = await exportAesKey(key);
+
+  return {
+    key: arrayBufferToHex(exported),
+    iv: iv.toString('hex'),
+    cipher: arrayBufferToHex(ciphertext)
+  }
+};
+
+const decrypt = async (cipher, key, iv) => {
+  if (!key.type) key = await importAesKey(hexToUint8Array(key));
+  cipher = new Uint8Array(hexToUint8Array(cipher));
+  iv = new Uint8Array(hexToUint8Array(iv));
+
+  const dec = new TextDecoder();
+  const plaintext = await subtle.decrypt({
+   name: 'AES-CBC',
+   iv,
+  }, key, cipher);
+
+  return dec.decode(plaintext);
+};
+
 const { encode, decode } = bs58check;
 
 // TODO: multihash addresses
@@ -1892,9 +2010,7 @@ class HDAccount {
 
 class MultiWallet extends HDWallet {
 	constructor(network, hdnode) {
-		const networkName = network;
 		super(network, hdnode);
-		if (typeof networkName === 'string') this.networkName = networkName;
 		this.multiCodec = this.network.multiCodec;
 		this.version = 0x00;
 	}
@@ -1912,7 +2028,7 @@ class MultiWallet extends HDWallet {
 	}
 
 	get neutered() {
-		const neutered = this.ifNotLocked(() => new MultiWallet(this.network, this.hdnode.neutered()));
+		const neutered = this.ifNotLocked(() => new MultiWallet(this.networkName, this.hdnode.neutered()));
 		if (neutered) this._neutered = neutered;
 		return this._neutered
 	}
@@ -1921,18 +2037,19 @@ class MultiWallet extends HDWallet {
 		let buffer = decode(id);
 		varint.decode(buffer);
 		buffer = buffer.slice(varint.decode.bytes);
-		this.fromPublicKey(buffer, null, this.network);
+		this.fromPublicKey(buffer, null, this.networkName);
 	}
 
-	lock(key, multiWIF) {
+	async lock(multiWIF) {
 		if (!multiWIF) multiWIF = this.multiWIF;
-		this.encrypted = AES.encrypt(multiWIF.toString('hex'), key).toString();
+		this.encrypted = await encrypt(multiWIF.toString('hex'));
 		this.locked = true;
+		return this.encrypted
 	}
 
-	unlock(key, encrypted) {
-		if (!encrypted) encrypted = this.encrypted;
-		this.import(AES.decrypt(encrypted, key).toString(ENC));
+	async unlock({key, iv, cipher}) {
+		const decrypted = await decrypt(cipher, key, iv);
+		this.import(decrypted);
 		this.locked = false;
 	}
 
@@ -1952,7 +2069,7 @@ class MultiWallet extends HDWallet {
 			else if (c.testnet && c.testnet.multiCodec === multiCodec) return c.testnet
 			else return p
 		}, networks['leofcoin']);
-		this.load(bs58, this.network);
+		this.load(bs58, this.networkName);
 	}
 
 	/**
@@ -1995,7 +2112,7 @@ class MultiWallet extends HDWallet {
 	 * @return { internal(addressIndex), external(addressIndex) }
 	 */
 	account(index) {
-		return new HDAccount(new MultiWallet(this.network, this.hdnode), index);
+		return new HDAccount(new MultiWallet(this.networkName, this.hdnode), index);
 	}
 
 	/**
@@ -2004,11 +2121,11 @@ class MultiWallet extends HDWallet {
 	 * see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
 	 */
 	derivePath(path) {
-		return new MultiWallet(this.network, this.hdnode.derivePath(path))
+		return new MultiWallet(this.networkName, this.hdnode.derivePath(path))
 	}
 
 	derive(index) {
-		return new MultiWallet(this.network, this.hdnode.derive(index));
+		return new MultiWallet(this.networkName, this.hdnode.derive(index));
 	}
 }
 
@@ -2138,7 +2255,7 @@ class Peernet {
       Storage = globalThis.LeofcoinStorage?.default ? globalThis.LeofcoinStorage.default : LeofcoinStorage;
     }
     globalThis[`${name}Store`] = globalThis[`${name}Store`] ||
-      await new Storage(`${prefix}-${name}`, root);
+      await new Storage(name, root);
 
     globalThis[`${name}Store`].private = isPrivate;
     if (!isPrivate) this.stores.push(name);
@@ -2169,6 +2286,13 @@ class Peernet {
     return Object.entries(this.client.connections)
   }
 
+  /**
+   * @return {String} id - peerId
+   */
+  getConnection(id) {
+    return this.client.connections[id]
+  }
+
   /**
    * @private
    *
@@ -2224,7 +2348,7 @@ class Peernet {
     const {daemon, environment} = await target();
     this.hasDaemon = daemon;
 
-    HTTP_IMPORT;
+    
 
     for (const store of this.defaultStores) {
       await this.addStore(store, options.storePrefix, options.root);
@@ -2290,6 +2414,16 @@ class Peernet {
     this.requestProtos[name] = method;
   }
 
+  sendMessage(peer, id, data) {
+    if (peer.readyState === 'open') {
+      peer.send(new TextEncoder().encode(JSON.stringify({id, data})));
+      this.bw.up += data.length;
+    } else if (peer.readyState === 'closed') {
+      this.removePeer(peer);
+    }
+
+  }
+
   /**
    * @private
    *
@@ -2314,8 +2448,7 @@ class Peernet {
         const data = new DHTMessageResponse({hash, has});
         const node = await this.prepareMessage(from, data.encoded);
 
-        peer.send(new TextEncoder().encode(JSON.stringify({id, data: node.encoded})));
-        this.bw.up += node.encoded.length;
+        sendMessage(peer, id, node.encoded);
       } else if (proto.name === 'peernet-data') {
         let { hash, store } = proto.decoded;
         let data;
@@ -2328,24 +2461,19 @@ class Peernet {
           data = await store.get(hash);
 
           if (data) {
-            data = new DataMessageResponse({hash, data: data.decoded ? new TextEncoder().encode(JSON.stringify(data.decoded)) : data});
+            data = new DataMessageResponse({hash, data});
 
             const node = await this.prepareMessage(from, data.encoded);
-            peer.send(new TextEncoder().encode(JSON.stringify({id, data: node.encoded})));
-            this.bw.up += node.encoded.length;
+            sendMessage(peer, id, node.encoded);
           }
         }
 
       } else if (proto.name === 'peernet-request') {
-        // TODO: make dynamic
-        // exposeddevapi[proto.decoded.request](proto.decoded.params)
         const method = this.requestProtos[proto.decoded.request];
         if (method) {
           const data = await method();
           const node = await this.prepareMessage(from, data.encoded);
-          peer.send(new TextEncoder().encode(JSON.stringify({id, data: node.encoded})));
-
-          this.bw.up += node.encoded.length;
+          sendMessage(peer, id, node.encoded);
         }
       } else if (proto.name === 'peernet-ps' && peer.peerId !== this.id) {
         globalSub.publish(new TextDecoder().decode(proto.decoded.topic), proto.decoded.data);
@@ -2615,13 +2743,9 @@ class Peernet {
     const id = Math.random().toString(36).slice(-12);
     data = new PsMessage({data, topic});
     for (const peer of this.connections) {
-      if (peer.connected) {
-        if (peer.peerId !== this.peerId) {
-          const node = await this.prepareMessage(peer.peerId, data.encoded);
-          peer.send(new TextEncoder().encode(JSON.stringify({id, data: node.encoded})));
-        }
-      } else {
-        this.removePeer(peer);
+      if (peer.peerId !== this.peerId) {
+        const node = await this.prepareMessage(peer.peerId, data.encoded);
+        sendMessage(peer, id, node.encoded);
       }
       // TODO: if peer subscribed
     }
@@ -2642,7 +2766,7 @@ class Peernet {
   }
 
   async removePeer(peer) {
-    delete this.client.connections[peer.peerId];
+    return this.client.removePeer(peer)
   }
 
   get Buffer() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.11.12",
+  "version": "0.11.15",
   "description": "",
   "main": "dist/commonjs/peernet.js",
   "module": "dist/module/peernet.js",
@@ -25,7 +25,7 @@
   "dependencies": {
     "@leofcoin/generate-account": "^1.0.2",
     "@leofcoin/multi-wallet": "^2.1.2",
-    "@leofcoin/peernet-swarm": "^0.1.16",
+    "@leofcoin/peernet-swarm": "^0.1.17",
     "@leofcoin/storage": "^2.3.0",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",
@@ -42,15 +42,10 @@
   },
   "devDependencies": {
     "@babel/plugin-proposal-private-methods": "^7.16.11",
-    "@rollup/plugin-commonjs": "^19.0.1",
     "@rollup/plugin-eslint": "^8.0.1",
     "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.0.4",
     "@vandeurenglenn/debug": "^1.0.0",
     "coveralls": "^3.1.1",
-    "esdoc": "^1.1.0",
-    "esdoc-ecmascript-proposal-plugin": "^1.0.0",
-    "esdoc-standard-plugin": "^1.0.0",
     "eslint": "^7.31.0",
     "eslint-config-google": "^0.14.0",
     "nyc": "^15.1.0",
@@ -58,10 +53,8 @@
     "path-browserify": "^1.0.1",
     "rollup": "^2.70.2",
     "rollup-plugin-modify": "^3.0.0",
-    "rollup-plugin-natives": "^0.7.5",
-    "rollup-plugin-node-globals": "^1.4.0",
-    "rollup-plugin-node-polyfills": "^0.2.1",
     "tape": "^5.2.2",
+    "vm-browserify": "^1.1.2",
     "webpack": "^5.72.0",
     "webpack-cli": "^4.9.2",
     "webpack-node-externals": "^3.0.0"

package/rollup.config.js

@@ -1,11 +1,7 @@
 import { execSync } from 'child_process';
 import lint from '@rollup/plugin-eslint'
-import resolve from '@rollup/plugin-node-resolve'
-import cjs from '@rollup/plugin-commonjs'
 import json from '@rollup/plugin-json'
 import modify from 'rollup-plugin-modify'
-import nativePlugin from 'rollup-plugin-natives';
-import polyfills from 'rollup-plugin-node-polyfills'
 
 try {
 	execSync('rm dist -r')
@@ -31,7 +27,8 @@ export default [{
 			} else {
 				const http = await import('./http/http.js')
 	      if (environment !== 'browser') http.default(options)
-	    }`
+	    }`,
+			SUBTLE_IMPORT: `const { subtle } = require('crypto').webcrypto`
 		})
 	]
 }, {
@@ -44,25 +41,13 @@ export default [{
 		json(),
 		modify({
 			"import fetch from 'node-fetch'": '',
-			HTTP_IMPORT: ``
+			HTTP_IMPORT: ``,
+			SUBTLE_IMPORT: `const { subtle } = crypto`
 		}),
-		// nativePlugin(),
-		// polyfills(),
-		// resolve({
-		// 	preferBuiltins: true,
-		// 	mainFields: ["browser", "module", "main"],
-		// 	extensions: ['.mjs', '.js', '.json']
-		// }),
-		// cjs({
-		// 	exclude: ['*.node'],
-		// 	extensions: ['.js']
-		// }),
 		// lint({
 		//   fix: true,
 		// 	exclude: ['package.json', "package-lock.json"]
 		// })
-
-
 	]
 }, {
 	input: 'src/peernet.js',
@@ -71,6 +56,11 @@ export default [{
 		format: 'es'
 	},
 	plugins: [
-		json()
+		json(),
+		modify({
+			"import fetch from 'node-fetch'": '',
+			HTTP_IMPORT: ``,
+			SUBTLE_IMPORT: `const { subtle } = crypto`
+		}),
 	]
 }]

package/src/codec/codec-format-interface.js

@@ -15,14 +15,14 @@ export default class FormatInterface {
     this.protoDecode = proto.decode
     this.hashFormat = options.hashFormat || 'bs32'
     if (options.name) this.name = options.name
-    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
+    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) this.fromArrayBuffer(buffer)
     else if (buffer.name === options.name) return buffer
-    else if (typeof buffer === 'string') {
-        if (isHex(buffer)) this.fromHex(buffer)
-        else if (bs32.isBase32(buffer)) this.fromBs32(buffer)
-        else if (bs58.isBase58(buffer)) this.fromBs58(buffer)
-        else throw new Error(`unsupported string ${buffer}`)
+    else if (buffer instanceof String) {
+      if (isHex(buffer)) this.fromHex(buffer)
+      else if (bs32.isBase32(buffer)) this.fromBs32(buffer)
+      else if (bs58.isBase58(buffer)) this.fromBs58(buffer)
+      else throw new Error(`unsupported string ${buffer}`)
     } else {
       this.create(buffer)
     }