@leofcoin/codec-format-interface 1.0.1

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 vandeurenglenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# codec-format-interface
+ 

package/dist/index.js

@@ -0,0 +1,523 @@
+'use strict';
+
+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 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);
+
+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();
+  }
+}
+
+var index = { codecs, Codec: PeernetCodec, CodecHash, FormatInterface, BasicInterface };
+
+module.exports = index;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@leofcoin/codec-format-interface",
+  "version": "1.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "c": "rollup -c"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leofcoin/codec-format-interface.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/leofcoin/codec-format-interface/issues"
+  },
+  "homepage": "https://github.com/leofcoin/codec-format-interface#readme",
+  "dependencies": {
+    "@vandeurenglenn/base32": "^1.1.0",
+    "@vandeurenglenn/base58": "^1.1.0",
+    "@vandeurenglenn/is-hex": "^1.0.0",
+    "keccak": "^3.0.2",
+    "varint": "^6.0.0"
+  },
+  "devDependencies": {
+    "rollup": "^2.74.1",
+    "tape": "^5.5.3"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,7 @@
+export default [{
+  input: ['src/index.js'],
+  output: [{
+    dir: 'dist',
+    format: 'cjs'
+  }]
+}]

package/src/basic-interface.js

@@ -0,0 +1,123 @@
+import bs32 from '@vandeurenglenn/base32';
+import bs58 from '@vandeurenglenn/base58';
+import isHex from '@vandeurenglenn/is-hex';
+
+export default 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(string)
+  }
+  isBase32(string) {
+    return base32.isBase32(string)
+  }
+  isBase58(string) {
+    return base58.isBase32(string)
+  }
+  /**
+   * @param {String} encoded
+   */
+  fromBs32(encoded) {
+    this.encoded = bs32.decode(encoded)
+    return this.#handleDecode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs58(encoded) {
+    this.encoded = bs58.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.encode(this.encoded)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs58() {
+    if (!this.encoded) this.#handleEncode()
+    return bs58.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()
+    }
+  }
+}

package/src/codec-format-interface.js

@@ -0,0 +1,93 @@
+import BasicInterface from './basic-interface.js'
+import Codec from './codec.js';
+import Hash from './codec-hash.js'
+
+export default 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 Hash(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 Codec(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 Codec(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 Codec(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()
+  }
+}

package/src/codec-hash.js

@@ -0,0 +1,127 @@
+import createKeccakHash from 'keccak';
+import varint from 'varint';
+import BasicInterface from './basic-interface.js'
+import Codec from './codec';
+
+export default 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 Codec(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.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 Codec(this.name, this.codecs)
+    this.discoCodec.fromName(this.name)
+    let hashAlg = this.discoCodec.hashAlg
+    if (hashAlg.includes('dbl')) {
+      hashAlg = hashAlg.replace('dbl-', '')
+      buffer = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
+    }
+    this.digest = createKeccakHash(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.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.decode(buffer);
+
+    this.discoCodec = new Codec(codec, this.codecs)
+    // TODO: validate codec
+    buffer = buffer.slice(varint.decode.bytes);
+    this.size = varint.decode(buffer);
+    this.digest = buffer.slice(varint.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,
+    }
+  }
+}

package/src/codec.js

@@ -0,0 +1,94 @@
+import varint from 'varint';
+import codecs from './codecs.js'
+import BasicInterface from './basic-interface.js'
+
+export default class PeernetCodec extends BasicInterface {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    super()
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        const codec = varint.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.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.encode(codec)
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name)
+    this.name = name
+    this.codec = codec
+    this.hashAlg = this.getHashAlg(name)
+    this.codecBuffer = varint.encode(codec)
+  }
+
+  decode() {
+    const codec = varint.decode(this.encoded);
+    this.fromCodec(codec)
+  }
+
+  encode() {
+    const codec = varint.encode(this.decoded)
+    this.encoded = codec
+    return this.encoded
+  }
+}

package/src/codecs.js

@@ -0,0 +1,79 @@
+export default {
+  // 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',
+  },
+}

package/src/index.js

@@ -0,0 +1,7 @@
+import BasicInterface from './basic-interface.js'
+import FormatInterface from './codec-format-interface.js'
+import CodecHash from './codec-hash.js'
+import Codec from './codec.js'
+import codecs from './codecs.js'
+
+export default { codecs, Codec, CodecHash, FormatInterface, BasicInterface }

package/test/test.js

@@ -0,0 +1,9 @@
+const test = require('tape');
+const {FormatInterface} = require('./../dist/index')
+
+test('', tape => {
+  tape.plan(1)
+  const int = new FormatInterface()
+  console.log(int);
+  tape.plan('ok')
+})