@leofcoin/messages 1.0.0 → 1.0.3

package/dist/messages.js

@@ -1,13 +1,20 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var protons = require('protons');
-var codecFormatInterface = require('@leofcoin/codec-format-interface');
+var bs32 = require('@vandeurenglenn/base32');
+var bs58 = require('@vandeurenglenn/base58');
+var isHex = require('@vandeurenglenn/is-hex');
+var varint = require('varint');
+var createKeccakHash = require('keccak');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var protons__default = /*#__PURE__*/_interopDefaultLegacy(protons);
+var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
+var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
+var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
+var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
+var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
 
 var proto$4 = `
 message ContractMessage {
@@ -17,7 +24,511 @@ message ContractMessage {
 }
 `;
 
-class ContractMessage extends codecFormatInterface.FormatInterface {
+class BasicInterface {
+  #handleDecode() {
+    if (!this.decode) throw new Error('bad implementation: needs decode func')
+    this.decode();
+  }
+
+  #handleEncode() {
+    if (!this.encode) throw new Error('bad implementation: needs encode func')
+    this.encode();
+  }
+  isHex(string) {
+    return isHex__default['default'](string)
+  }
+  isBase32(string) {
+    return base32.isBase32(string)
+  }
+  isBase58(string) {
+    return base58.isBase32(string)
+  }
+  /**
+   * @param {String} encoded
+   */
+  fromBs32(encoded) {
+    this.encoded = bs32__default['default'].decode(encoded);
+    return this.#handleDecode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs58(encoded) {
+    this.encoded = bs58__default['default'].decode(encoded);
+    return this.#handleDecode()
+  }
+
+  async toArray() {
+    const array = [];
+    for await (const value of this.encoded.values()) {
+      array.push(value);
+    }
+    return array
+  }
+
+  fromString(string) {
+    this.encoded = new Uint8Array(string.split(','));
+    return this.#handleDecode()
+  }
+
+  fromArray(array) {
+    this.encoded = new Uint8Array([...array]);
+    return this.#handleDecode()
+  }
+
+  /**
+   * @param {Buffer} encoded
+   */
+  fromEncoded(encoded) {
+    this.encoded = encoded;
+    return this.#handleDecode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromHex(encoded) {
+    this.encoded = Buffer.from(encoded, 'hex');
+    return this.#handleDecode()
+  }
+
+  toString(encoding = 'utf8') {
+    if (!this.encoded) this.#handleEncode();
+    return this.encoded.toString(encoding)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toHex() {
+    return this.toString('hex')
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs32() {
+    if (!this.encoded) this.#handleEncode();
+    return bs32__default['default'].encode(this.encoded)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs58() {
+    if (!this.encoded) this.#handleEncode();
+    return bs58__default['default'].encode(this.encoded)
+  }
+
+  /**
+   * @param {Object} data
+   */
+  create(data) {
+    const decoded = {};
+    if (this.keys?.length > 0) {
+      for (const key of this.keys) {
+        Object.defineProperties(decoded, {
+          [key]: {
+            enumerable: true,
+            configurable: true,
+            set: (val) => value = data[key],
+            get: () => data[key]
+          }
+        });
+      }
+
+      this.decoded = decoded;
+      this.encode();
+    }
+  }
+}
+
+var codecs = {
+  // just a hash
+  'disco-hash': {
+    codec: parseInt('30', 16),
+    hashAlg: 'dbl-keccak-256', // ,
+    // testnet: 'olivia'
+  },
+  'peernet-peer-response': {
+    codec: parseInt('707072', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-peer': {
+    codec: parseInt('7070', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-dht': {
+    codec: parseInt('706468', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-dht-response': {
+    codec: parseInt('706472', 16),
+    hashAlg: 'keccak-256',
+  },
+  // data
+  'peernet-data': {
+    codec: parseInt('706461', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-data-response': {
+    codec: parseInt('70646172', 16),
+    hashAlg: 'keccak-256',
+  },
+  // message
+  'peernet-message': {
+    codec: parseInt('706d65', 16),
+    hashAlg: 'keccak-256',
+  },
+  // pubsub
+  'peernet-ps': {
+    codec: parseInt('707073', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-response': {
+    codec: parseInt('7072', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-request': {
+    codec: parseInt('707271', 16),
+    hashAlg: 'keccak-256',
+  },
+  // normal block
+  'leofcoin-block': {
+    codec: parseInt('6c62', 16),
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  'leofcoin-tx': {
+    codec: parseInt('6c74', 16),
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  // itx
+  'leofcoin-itx': {
+    codec: parseInt('6c69', 16),
+    hashAlg: 'keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  // peer reputation
+  'leofcoin-pr': {
+    codec: parseInt('6c70', 16),
+    hashAlg: 'keccak-256', // ,
+    // testnet: 'olivia'
+  },
+  // chat message
+  'chat-message': {
+    codec: parseInt('636d', 16),
+    hashAlg: 'dbl-keccak-256',
+  },
+};
+
+class PeernetCodec extends BasicInterface {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    super();
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        const codec = varint__default['default'].decode(buffer);
+        const name = this.getCodecName(codec);
+        if (name) {
+          this.name = name;
+          this.encoded = buffer;
+          this.decode(buffer);
+        } else {
+          this.encode(buffer);
+        }
+      } else if (buffer instanceof ArrayBuffer) {
+        const encoded = new Uint8Array(buffer.byteLength);
+
+        for (let i = 0; i < buffer.byteLength; i++) {
+          encoded[i] = buffer[i];
+        }
+        this.encoded = encoded;
+        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+        this.decode(buffer);
+        return
+      }
+      if (typeof buffer === 'string') {
+        if (this.codecs[buffer]) this.fromName(buffer);
+        else if (this.isHex(buffer)) this.fromHex(buffer);
+        else if (this.isBase32(buffer)) this.fromBs32(buffer);
+        else if (this.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+      }
+      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
+    }
+  }
+
+  fromEncoded(encoded) {
+    const codec = varint__default['default'].decode(encoded);
+    const name = this.getCodecName(codec);
+    this.name = name;
+    this.encoded = encoded;
+    this.decode(encoded);
+  }
+
+  getCodec(name) {
+    return this.codecs[name].codec
+  }
+
+  getCodecName(codec) {
+    return Object.keys(this.codecs).reduce((p, c) => {
+      const item = this.codecs[c];
+      if (item.codec === codec) return c;
+      else return p;
+    }, undefined)
+  }
+
+  getHashAlg(name) {
+    return this.codecs[name].hashAlg
+  }
+
+  fromCodec(codec) {
+    this.name = this.getCodecName(codec);
+    this.hashAlg = this.getHashAlg(this.name);
+
+    this.codec = this.getCodec(this.name);
+    this.codecBuffer = varint__default['default'].encode(codec);
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name);
+    this.name = name;
+    this.codec = codec;
+    this.hashAlg = this.getHashAlg(name);
+    this.codecBuffer = varint__default['default'].encode(codec);
+  }
+
+  decode() {
+    const codec = varint__default['default'].decode(this.encoded);
+    this.fromCodec(codec);
+  }
+
+  encode() {
+    const codec = varint__default['default'].encode(this.decoded);
+    this.encoded = codec;
+    return this.encoded
+  }
+}
+
+class CodecHash extends BasicInterface {
+  constructor(buffer, options = {}) {
+    super();
+    if (options.name) this.name = options.name;
+    else this.name = 'disco-hash';
+    if (options.codecs) this.codecs = options.codecs;
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        this.discoCodec = new PeernetCodec(buffer, this.codecs);
+        const name = this.discoCodec.name;
+
+        if (name) {
+          this.name = name;
+          this.decode(buffer);
+        } else {
+          this.encode(buffer);
+        }
+      }
+
+      if (typeof buffer === 'string') {
+        if (this.isHex(buffer)) this.fromHex(buffer);
+        if (this.isBase32(buffer)) this.fromBs32(buffer);
+        else if (this.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+      } else if (typeof buffer === 'object') this.fromJSON(buffer);
+    }
+  }
+
+  get prefix() {
+    const length = this.length;
+    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
+    uint8Array.set(length);
+    uint8Array.set(this.discoCodec.codecBuffer, length.length);
+
+    return uint8Array
+  }
+
+  get length() {
+    return varint__default['default'].encode(this.size)
+  }
+
+  get buffer() {
+    return this.encoded
+  }
+
+  get hash() {
+    return this.encoded
+  }
+
+  fromJSON(json) {
+    return this.encode(Buffer.from(JSON.stringify(json)))
+  }
+
+  encode(buffer, name) {
+    if (!this.name && name) this.name = name;
+    if (!buffer) buffer = this.buffer;
+    this.discoCodec = new PeernetCodec(this.name, this.codecs);
+    this.discoCodec.fromName(this.name);
+    let hashAlg = this.discoCodec.hashAlg;
+    if (hashAlg.includes('dbl')) {
+      hashAlg = hashAlg.replace('dbl-', '');
+      buffer = createKeccakHash__default['default'](hashAlg.replace('-', '')).update(buffer).digest();
+    }
+    this.digest = createKeccakHash__default['default'](hashAlg.replace('-', '')).update(buffer).digest();
+    this.size = this.digest.length;
+
+    this.codec = this.discoCodec.encode();
+    this.codec = this.discoCodec.codecBuffer;
+    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
+    uint8Array.set(this.prefix);
+    uint8Array.set(this.digest, this.prefix.length);
+
+    this.encoded = uint8Array;
+
+    return this.encoded
+  }
+
+  validate(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+      const codec = varint__default['default'].decode(buffer);
+      if (this.codecs[codec]) {
+        this.decode(buffer);
+      } else {
+        this.encode(buffer);
+      }
+    }
+    if (typeof buffer === 'string') {
+      if (this.isHex(buffer)) this.fromHex(buffer);
+      if (this.isBase32(buffer)) this.fromBs32(buffer);
+    }
+    if (typeof buffer === 'object') this.fromJSON(buffer);
+  }
+
+  decode(buffer) {
+    this.encoded = buffer;
+    const codec = varint__default['default'].decode(buffer);
+
+    this.discoCodec = new PeernetCodec(codec, this.codecs);
+    // TODO: validate codec
+    buffer = buffer.slice(varint__default['default'].decode.bytes);
+    this.size = varint__default['default'].decode(buffer);
+    this.digest = buffer.slice(varint__default['default'].decode.bytes);
+    if (this.digest.length !== this.size) {
+      throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
+    }
+
+    // const discoCodec = new Codec(codec, this.codecs)
+
+    this.name = this.discoCodec.name;
+
+
+    this.size = this.digest.length;
+
+    return {
+      codec: this.codec,
+      name: this.name,
+      size: this.size,
+      length: this.length,
+      digest: this.digest,
+    }
+  }
+}
+
+class FormatInterface extends BasicInterface {
+  /**
+   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+   * @param {Object} proto - {encode, decode}
+   * @param {Object} options - {hashFormat, name}
+   */
+  constructor(buffer, proto, options = {}) {
+    super();
+    this.protoEncode = proto.encode;
+    this.protoDecode = proto.decode;
+    this.hashFormat = options.hashFormat || 'bs32';
+    if (options.name) this.name = options.name;
+    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 (buffer instanceof String) {
+      if (this.isHex(buffer)) this.fromHex(buffer);
+      else if (this.isBase32(buffer)) this.fromBs32(buffer);
+      else if (this.isBase58(buffer)) this.fromBs58(buffer);
+      else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      this.create(buffer);
+    }
+  }
+
+  /**
+   * @return {PeernetHash}
+   */
+  get peernetHash() {
+    return new CodecHash(this.decoded, {name: this.name})
+  }
+
+  /**
+   * @return {peernetHash}
+   */
+  get hash() {
+    const upper = this.hashFormat.charAt(0).toUpperCase();
+    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+    return this.peernetHash[`to${format}`]()
+  }
+
+  /**
+   * @return {Object}
+   */
+  decode() {
+    let encoded = this.encoded;
+    const discoCodec = new PeernetCodec(this.encoded);
+    encoded = encoded.slice(discoCodec.codecBuffer.length);
+    this.name = discoCodec.name;
+    this.decoded = this.protoDecode(encoded);
+    return this.decoded
+  }
+
+  /**
+   * @return {Buffer}
+   */
+  encode(decoded) {
+    if (!decoded) decoded = this.decoded;
+    const codec = new PeernetCodec(this.name);
+    const encoded = this.protoEncode(decoded);
+    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+    uint8Array.set(codec.codecBuffer);
+    uint8Array.set(encoded, codec.codecBuffer.length);
+    this.encoded = uint8Array;
+    return this.encoded
+  }
+
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec = new PeernetCodec(this.encoded);
+    if (codec.name) return true
+  }
+
+  fromUint8Array(buffer) {
+    this.encoded = buffer;
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    );
+    else this.decode();
+  }
+
+  fromArrayBuffer(buffer) {
+    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    );
+    else this.decode();
+  }
+}
+
+class ContractMessage extends FormatInterface {
   get keys() {
     return ['creator', 'contract', 'constructorParameters']
   }
@@ -27,11 +538,6 @@ class ContractMessage extends codecFormatInterface.FormatInterface {
   }
 }
 
-var contract = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': ContractMessage
-});
-
 var proto$3 = `
 
 message TransactionMessage {
@@ -44,7 +550,7 @@ message TransactionMessage {
 }
 `;
 
-class TransactionMessage extends codecFormatInterface.FormatInterface {
+class TransactionMessage extends FormatInterface {
   get keys() {
     return ['timestamp', 'from', 'to', 'nonce', 'method', 'params']
   }
@@ -55,11 +561,6 @@ class TransactionMessage extends codecFormatInterface.FormatInterface {
   }
 }
 
-var transaction = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': TransactionMessage
-});
-
 var proto$2 = `
 message ValidatorMessage {
   required string address = 1;
@@ -87,7 +588,7 @@ message BlockMessage {
 }
 `;
 
-class BlockMessage extends codecFormatInterface.FormatInterface {
+class BlockMessage extends FormatInterface {
   get keys() {
     return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
   }
@@ -98,11 +599,6 @@ class BlockMessage extends codecFormatInterface.FormatInterface {
   }
 }
 
-var block = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': BlockMessage
-});
-
 var proto$1 = `
 
 message BWMessage {
@@ -111,7 +607,7 @@ message BWMessage {
 }
 `;
 
-class BWMessage extends codecFormatInterface.FormatInterface {
+class BWMessage extends FormatInterface {
   get keys() {
     return ['up', 'down']
   }
@@ -122,18 +618,13 @@ class BWMessage extends codecFormatInterface.FormatInterface {
   }
 }
 
-var bw = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': BWMessage
-});
-
 var proto = `
 
 message BWRequestMessage {
 }
 `;
 
-class BWRequestMessage extends codecFormatInterface.FormatInterface {
+class BWRequestMessage extends FormatInterface {
   get keys() {
     return []
   }
@@ -144,13 +635,12 @@ class BWRequestMessage extends codecFormatInterface.FormatInterface {
   }
 }
 
-var bwRequest = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  'default': BWRequestMessage
-});
+var messages = {
+  ContractMessage,
+  TransactionMessage,
+  BlockMessage,
+  BWMessage,
+  BWRequestMessage
+};
 
-exports.BWMessage = bw;
-exports.BWRequestMessage = bwRequest;
-exports.BlockMessage = block;
-exports.ContractMessage = contract;
-exports.TransactionMessage = transaction;
+module.exports = messages;

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@leofcoin/messages",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "",
   "main": "dist/messages.js",
-  "module": "src/messages/js",
+  "module": "dist/messages.esm",
   "scripts": {
-    "build": "rollup -c",
+    "build": "rollup -c && webpack",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [],
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@leofcoin/codec-format-interface": "^1.0.1"
+    "@leofcoin/codec-format-interface": "^1.0.1",
+    "protons": "^2.0.1"
+  },
+  "devDependencies": {
+    "webpack": "^5.73.0",
+    "webpack-cli": "^4.9.2"
   }
 }

package/src/messages/block.js

@@ -1,8 +1,8 @@
 import protons from 'protons'
 import proto from './../protos/block.proto.js'
-import { FormatInterface as CodecFormat } from '@leofcoin/codec-format-interface'
+import FormatInterface from './../../node_modules/@leofcoin/codec-format-interface/src/codec-format-interface'
 
-export default class BlockMessage extends CodecFormat {
+export default class BlockMessage extends FormatInterface {
   get keys() {
     return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
   }

package/src/messages/bw-request.js

@@ -1,8 +1,8 @@
 import protons from 'protons'
 import proto from './../protos/bw-request.proto.js'
-import {FormatInterface as CodecFormat} from '@leofcoin/codec-format-interface'
+import FormatInterface from './../../node_modules/@leofcoin/codec-format-interface/src/codec-format-interface'
 
-export default class BWRequestMessage extends CodecFormat {
+export default class BWRequestMessage extends FormatInterface {
   get keys() {
     return []
   }

package/src/messages/bw.js

@@ -1,8 +1,8 @@
 import protons from 'protons'
 import proto from './../protos/bw.proto.js'
-import { FormatInterface as CodecFormat } from '@leofcoin/codec-format-interface'
+import FormatInterface from './../../node_modules/@leofcoin/codec-format-interface/src/codec-format-interface'
 
-export default class BWMessage extends CodecFormat {
+export default class BWMessage extends FormatInterface {
   get keys() {
     return ['up', 'down']
   }

package/src/messages/contract.js

@@ -1,8 +1,8 @@
 import protons from 'protons'
 import proto from './../protos/contract.proto.js'
-import { FormatInterface as CodecFormat } from '@leofcoin/codec-format-interface'
+import FormatInterface from './../../node_modules/@leofcoin/codec-format-interface/src/codec-format-interface'
 
-export default class ContractMessage extends CodecFormat {
+export default class ContractMessage extends FormatInterface {
   get keys() {
     return ['creator', 'contract', 'constructorParameters']
   }