@leofcoin/chain 1.0.4 → 1.0.7

package/chain.js

@@ -2,32 +2,14 @@
 
 var bignumber = require('@ethersproject/bignumber');
 var units = require('@ethersproject/units');
-var chalk = require('chalk');
 require('vm');
 var protons = require('protons');
-var bs32 = require('@vandeurenglenn/base32');
-var bs58 = require('@vandeurenglenn/base58');
-var isHex = require('@vandeurenglenn/is-hex');
-var varint = require('varint');
-var createKeccakHash = require('keccak');
+var codecFormatInterface = require('@leofcoin/codec-format-interface');
+require('@vandeurenglenn/base58');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
 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);
-
-// import { promisify } from 'util'
-
-const info = text => console.log(chalk__default["default"].blueBright(text));
-
-const subinfo = text => console.log(chalk__default["default"].magentaBright(text));
-// export const write = promisify(writeFile)
-// export const read = promisify(readFile)
 
 var proto$4 = `
 message ContractMessage {
@@ -37,541 +19,7 @@ message ContractMessage {
 }
 `;
 
-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 {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
-  }
-  constructor(buffer) {
-    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 (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}`)
-      }
-      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);
-  }
-
-  fromHex(hex) {
-    this.encoded = Buffer.from(hex, 'hex');
-    this.decode();
-  }
-
-  fromBs32(input) {
-    this.encoded = bs32__default["default"].decode(input);
-    this.decode();
-  }
-
-  fromBs58(input) {
-    this.encoded = bs58__default["default"].decode(input);
-    this.decode();
-  }
-
-  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);
-  }
-
-  toBs32() {
-    this.encode();
-    return bs32__default["default"].encode(this.encoded)
-  }
-
-  toBs58() {
-    this.encode();
-    return bs58__default["default"].encode(this.encoded)
-  }
-
-  toHex() {
-    return this.encoded.toString('hex')
-  }
-
-  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 PeernetHash {
-  constructor(buffer, options = {}) {
-    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 (isHex__default["default"](buffer)) this.fromHex(buffer);
-        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 (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.hash
-  }
-
-  toHex() {
-    return this.hash.toString('hex')
-  }
-
-  fromHex(hex) {
-    return this.decode(Buffer.from(hex, 'hex'))
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  toBs32() {
-    return bs32__default["default"].encode(this.hash)
-  }
-
-  fromBs32(bs) {
-    return this.decode(bs32__default["default"].decode(bs))
-  }
-
-  toBs58() {
-    return bs58__default["default"].encode(this.hash)
-  }
-
-  fromBs58(bs) {
-    return this.decode(bs58__default["default"].decode(bs))
-  }
-
-  toString(encoding = 'utf8') {
-    return this.hash.toString(encoding)
-  }
-
-  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.hash = uint8Array;
-
-    return this.hash
-  }
-
-  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 (isHex__default["default"](buffer)) this.fromHex(buffer);
-      if (bs32__default["default"].test(buffer)) this.fromBs32(buffer);
-    }
-    if (typeof buffer === 'object') this.fromJSON(buffer);
-  }
-
-  decode(buffer) {
-    this.hash = 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.hash.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 {
-  /**
-   * @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 = {}) {
-    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 (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);
-    }
-  }
-
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new PeernetHash(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();
-  }
-
-  toString() {
-    return this.encoded.toString()
-  }
-
-  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(','));
-    this.decode();
-  }
-
-  fromArray(array) {
-    this.encoded = new Uint8Array([...array]);
-    this.decode();
-  }
-
-  /**
-   * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded;
-    this.decode();
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex');
-    this.decode();
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = bs32__default["default"].decode(encoded);
-    this.decode();
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs58(encoded) {
-    this.encoded = bs58__default["default"].decode(encoded);
-    this.decode();
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    if (!this.encoded) this.encode();
-    return this.encoded.toString('hex')
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs32() {
-    if (!this.encoded) this.encode();
-    return bs32__default["default"].encode(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs58() {
-    if (!this.encoded) this.encode();
-    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();
-    }
-  }
-}
-
-class ContractMessage$1 extends FormatInterface {
+class ContractMessage$1 extends codecFormatInterface.FormatInterface {
   get keys() {
     return ['creator', 'contract', 'constructorParameters']
   }
@@ -593,7 +41,7 @@ message TransactionMessage {
 }
 `;
 
-class TransactionMessage$1 extends FormatInterface {
+class TransactionMessage$1 extends codecFormatInterface.FormatInterface {
   get keys() {
     return ['timestamp', 'from', 'to', 'nonce', 'method', 'params']
   }
@@ -631,7 +79,7 @@ message BlockMessage {
 }
 `;
 
-class BlockMessage$1 extends FormatInterface {
+class BlockMessage$1 extends codecFormatInterface.FormatInterface {
   get keys() {
     return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
   }
@@ -650,7 +98,7 @@ message BWMessage {
 }
 `;
 
-class BWMessage$1 extends FormatInterface {
+class BWMessage$1 extends codecFormatInterface.FormatInterface {
   get keys() {
     return ['up', 'down']
   }
@@ -667,7 +115,7 @@ message BWRequestMessage {
 }
 `;
 
-class BWRequestMessage$1 extends FormatInterface {
+class BWRequestMessage$1 extends codecFormatInterface.FormatInterface {
   get keys() {
     return []
   }
@@ -808,8 +256,8 @@ console.log(e);
       globalThis.msg = this.#createMessage(contractMessage.decoded.creator);
       // globalThis.msg = {sender: contractMessage.decoded.creator}
       this.#contracts[contractMessage.hash] = new Contract(...params);
-      info(`loaded contract: ${contractMessage.hash}`);
-      subinfo(`size: ${Math.round((contractMessage.encoded.length / 1024) * 100) / 100} kb`);
+      debug(`loaded contract: ${contractMessage.hash}`);
+      debug(`size: ${Math.round((contractMessage.encoded.length / 1024) * 100) / 100} kb`);
     } catch (e) {
       console.log(e);
       console.warn(`removing contract ${contractMessage.hash}`);
@@ -1027,7 +475,7 @@ class Chain {
       console.log(this.#blocks);
       let blocksSynced = localIndex > 0 ? localIndex - index : index;
       blocksSynced += 1;
-      info(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`);
+      debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`);
 
       this.#blocks.length;
       (this.#blocks.length) - blocksSynced;
@@ -1141,7 +589,7 @@ class Chain {
     this.#lastBlock = {hash: blockMessage.hash, ...blockMessage.decoded};
     await blockStore.put(blockMessage.hash, blockMessage.encoded);
     await chainStore.put('lastBlock', new TextEncoder().encode(blockMessage.hash));
-    info(`added block: ${blockMessage.hash}`);
+    debug(`added block: ${blockMessage.hash}`);
     let promises = [];
     let contracts = [];
     for (let transaction of blockMessage.decoded.transactions) {
@@ -1154,11 +602,12 @@ class Chain {
       promises = await Promise.allSettled(promises);
 
       // todo finish state
-      for (const contract of contracts) {
-        const state = await this.#machine.get(contract, 'state');
-        // await stateStore.put(contract, state)
-        console.log(state);
-      }
+      // for (const contract of contracts) {
+      //   const state = await this.#machine.get(contract, 'state')
+      //   // await stateStore.put(contract, state)
+      //   console.log(state);
+      // }
+      pubsub.publish('block-processed', blockMessage.decoded);
     } catch (e) {
       console.log(e);
     }