@leofcoin/peernet 0.11.14 → 0.11.15

package/dist/commonjs/{client-1a1f75e6.js → client-5633ba04.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-/* socket-request-client version 1.6.1 */
+/* socket-request-client version 1.6.3 */
 
 class LittlePubSub {
   constructor(verbose = true) {
@@ -187,9 +187,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();
       }
     }

package/dist/commonjs/codec-format-interface.js

@@ -25,14 +25,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__default["default"](buffer)) this.fromHex(buffer);
-        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
-        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
+    else if (buffer instanceof String) {
+      if (isHex__default["default"](buffer)) this.fromHex(buffer);
+      else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
+      else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
+      else throw new Error(`unsupported string ${buffer}`)
     } else {
       this.create(buffer);
     }

package/dist/commonjs/{http-68dd2b96.js → http-f3ec9531.js}

@@ -10,7 +10,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var PubSub__default = /*#__PURE__*/_interopDefaultLegacy(PubSub);
 var Koa__default = /*#__PURE__*/_interopDefaultLegacy(Koa);
 
-var version = "0.11.13";
+var version = "0.11.14";
 
 var api$1 = {
   version: ({send}) => send({client: '@peernet/api/http', version}),

package/dist/commonjs/peernet.js

@@ -14,16 +14,13 @@ var codec = require('./codec-45796010.js');
 var hash = require('./hash.js');
 var generateAccount = require('@leofcoin/generate-account');
 var bs58check = require('bs58check');
-var bip39 = require('bip39');
 var bip32 = require('bip32');
 var createKeccakHash = require('keccak');
-var secp256k1 = require('secp256k1');
 var ecc = require('tiny-secp256k1');
+var Mnemonic = require('@leofcoin/mnemonic');
 var MultiSignature = require('multi-signature');
 var varint = require('varint');
-var AES = require('crypto-js/aes.js');
-require('crypto-js/sha512.js');
-var ENC = require('crypto-js/enc-utf8.js');
+var randombytes = require('randombytes');
 require('@vandeurenglenn/base32');
 require('@vandeurenglenn/base58');
 require('@vandeurenglenn/is-hex');
@@ -57,12 +54,12 @@ var bs58check__namespace = /*#__PURE__*/_interopNamespace(bs58check);
 var bip32__namespace = /*#__PURE__*/_interopNamespace(bip32);
 var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
 var ecc__default = /*#__PURE__*/_interopDefaultLegacy(ecc);
+var Mnemonic__default = /*#__PURE__*/_interopDefaultLegacy(Mnemonic);
 var MultiSignature__default = /*#__PURE__*/_interopDefaultLegacy(MultiSignature);
 var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var AES__default = /*#__PURE__*/_interopDefaultLegacy(AES);
-var ENC__default = /*#__PURE__*/_interopDefaultLegacy(ENC);
+var randombytes__default = /*#__PURE__*/_interopDefaultLegacy(randombytes);
 
-/* socket-request-client version 1.6.1 */
+/* socket-request-client version 1.6.3 */
 
 class LittlePubSub {
   constructor(verbose = true) {
@@ -249,9 +246,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();
       }
     }
@@ -318,6 +312,10 @@ class Peer {
     return this.#connected
   }
 
+  get readyState() {
+    return this.channel?.readyState
+  }
+
 /**
  * @params {Object} options
  * @params {string} options.channelName - this peerid : otherpeer id
@@ -357,8 +355,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) {
@@ -431,7 +440,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;
         };
 
@@ -491,6 +499,7 @@ constructor(options = {}) {
 
  close() {
    debug(`closing ${this.peerId}`);
+   this.#connected = false;
    this.channel?.close();
    this.#connection?.close();
 
@@ -507,6 +516,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];
@@ -621,6 +634,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`);
+  }
+
 
 }
 
@@ -1080,6 +1102,7 @@ const bitcoin = {
 	messagePrefix: '\x18Bitcoin Signed Message:\n',
 	bech32: 'bc',
 	pubKeyHash: 0x00,
+	multiCodec: 0x00,
 	scriptHash: 0x05,
 	wif: 0x80,
 	coin_type: 0,
@@ -1128,12 +1151,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["default"];
 class HDWallet {
 
@@ -1161,20 +1187,48 @@ class HDWallet {
 		return this.ifNotLocked(() => this.publicKeyBuffer.toString('hex'))
 	}
 
+	get ethereumAddress() {
+		const buffer = ecc__default["default"].pointFromScalar(this.hdnode.__D, false);
+		let hash = createKeccakHash__default["default"]('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__default["default"].pointFromScalar(this.hdnode.__D, false);
-			buffer = Buffer.from(secp256k1.publicKeyConvert(buffer, false)).slice(1);
-			let hash = createKeccakHash__default["default"]('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() {
@@ -1221,10 +1275,10 @@ class HDWallet {
 
 	async generate(password, network) {
 		network = this.validateNetwork(network);
-		const mnemonic = bip39.generateMnemonic(256);
-		const seed = await bip39.mnemonicToSeed(mnemonic, password);
+		const mnemonic = new Mnemonic__default["default"]().generate();
+		const seed = new Mnemonic__default["default"]().seedFromMnemonic(mnemonic, password);
 		this.defineHDNode(bip32__namespace.fromSeed(seed, network));
-		return mnemonic; // userpw
+		return mnemonic;
 	}
 
 	/**
@@ -1232,7 +1286,7 @@ class HDWallet {
    */
 	async recover(mnemonic, password, network) {
 		network = this.validateNetwork(network, password);
-		const seed = await bip39.mnemonicToSeed(mnemonic);
+		const seed = new Mnemonic__default["default"]().seedFromMnemonic(mnemonic, password);
 		this.defineHDNode(bip32__namespace.fromSeed(seed, network));
 	}
 
@@ -1265,6 +1319,71 @@ class HDWallet {
 	}
 }
 
+const { subtle } = require('crypto').webcrypto;
+
+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__default["default"](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__namespace;
 
 // TODO: multihash addresses
@@ -1295,9 +1414,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;
 	}
@@ -1315,7 +1432,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
 	}
@@ -1324,18 +1441,19 @@ class MultiWallet extends HDWallet {
 		let buffer = decode(id);
 		varint__default["default"].decode(buffer);
 		buffer = buffer.slice(varint__default["default"].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__default["default"].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__default["default"].decrypt(encrypted, key).toString(ENC__default["default"]));
+	async unlock({key, iv, cipher}) {
+		const decrypted = await decrypt(cipher, key, iv);
+		this.import(decrypted);
 		this.locked = false;
 	}
 
@@ -1355,7 +1473,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);
 	}
 
 	/**
@@ -1398,7 +1516,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);
 	}
 
 	/**
@@ -1407,11 +1525,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));
 	}
 }
 
@@ -1635,12 +1753,12 @@ class Peernet {
     this.hasDaemon = daemon;
 
     if (this.hasDaemon) {
-				const httpClient = await Promise.resolve().then(function () { return require('./client-1a1f75e6.js'); });
+				const httpClient = await Promise.resolve().then(function () { return require('./client-5633ba04.js'); });
 				globalThis.peernet.client = await httpClient.default({
 					protocol: 'peernet-v0.1.0', host: '127.0.0.1', port: options.port
 				});
 			} else {
-				const http = await Promise.resolve().then(function () { return require('./http-68dd2b96.js'); });
+				const http = await Promise.resolve().then(function () { return require('./http-f3ec9531.js'); });
 	      if (environment !== 'browser') http.default(options);
 	    }
 
@@ -1708,6 +1826,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
    *
@@ -1732,8 +1860,7 @@ class Peernet {
         const data = new dhtResponse({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;
@@ -1746,24 +1873,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);
@@ -2033,13 +2155,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
     }
@@ -2060,7 +2178,7 @@ class Peernet {
   }
 
   async removePeer(peer) {
-    delete this.client.connections[peer.peerId];
+    return this.client.removePeer(peer)
   }
 
   get Buffer() {