@steemit/steem-js 0.8.0 → 1.0.0

package/lib/auth/ecc/src/key_utils.js

@@ -1,70 +0,0 @@
-"use strict";
-
-const PrivateKey = require('./key_private');
-const hash = require('./hash');
-const secureRandom = require('secure-random');
-
-// hash for .25 second
-const HASH_POWER_MILLS = 250;
-let entropyPos = 0,
-  entropyCount = 0;
-const entropyArray = secureRandom.randomBuffer(101);
-module.exports = {
-  addEntropy(...ints) {
-    entropyCount++;
-    for (const i of ints) {
-      const pos = entropyPos++ % 101;
-      const i2 = entropyArray[pos] += i;
-      if (i2 > 9007199254740991) entropyArray[pos] = 0;
-    }
-  },
-  /**
-      A week random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.
-       @param1 string entropy of at least 32 bytes
-  */
-  random32ByteBuffer(entropy = this.browserEntropy()) {
-    if (!(typeof entropy === 'string')) {
-      throw new Error("string required for entropy");
-    }
-    if (entropy.length < 32) {
-      throw new Error("expecting at least 32 bytes of entropy");
-    }
-    const start_t = Date.now();
-    while (Date.now() - start_t < HASH_POWER_MILLS) entropy = hash.sha256(entropy);
-    const hash_array = [];
-    hash_array.push(entropy);
-
-    // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back).
-    hash_array.push(secureRandom.randomBuffer(32));
-    return hash.sha256(Buffer.concat(hash_array));
-  },
-  get_random_key(entropy) {
-    return PrivateKey.fromBuffer(this.random32ByteBuffer(entropy));
-  },
-  // Turn invisible space like characters into a single space
-  // normalize_brain_key(brain_key){
-  //     if (!(typeof brain_key === 'string')) {
-  //         throw new Error("string required for brain_key");
-  //     }
-  //     brain_key = brain_key.trim();
-  //     return brain_key.split(/[\t\n\v\f\r ]+/).join(' ');
-  // },
-
-  browserEntropy() {
-    let entropyStr = Array(entropyArray).join();
-    try {
-      entropyStr += new Date().toString() + " " + window.screen.height + " " + window.screen.width + " " + window.screen.colorDepth + " " + " " + window.screen.availHeight + " " + window.screen.availWidth + " " + window.screen.pixelDepth + navigator.language + " " + window.location + " " + window.history.length;
-      for (let i = 0, mimeType; i < navigator.mimeTypes.length; i++) {
-        mimeType = navigator.mimeTypes[i];
-        entropyStr += mimeType.description + " " + mimeType.type + " " + mimeType.suffixes + " ";
-      }
-      console.log("INFO\tbrowserEntropy gathered", entropyCount, 'events');
-    } catch (error) {
-      //nodejs:ReferenceError: window is not defined
-      entropyStr += hash.sha256(new Date().toString());
-    }
-    const b = new Buffer(entropyStr);
-    entropyStr += b.toString('binary') + " " + new Date().toString();
-    return entropyStr;
-  }
-};

package/lib/auth/ecc/src/signature.js

@@ -1,135 +0,0 @@
-"use strict";
-
-var ecdsa = require('./ecdsa');
-var hash = require('./hash');
-var curve = require('ecurve').getCurveByName('secp256k1');
-var assert = require('assert');
-var BigInteger = require('bigi');
-var PublicKey = require('./key_public');
-var PrivateKey = require('./key_private');
-class Signature {
-  constructor(r1, s1, i1) {
-    this.r = r1;
-    this.s = s1;
-    this.i = i1;
-    assert.equal(this.r != null, true, 'Missing parameter');
-    assert.equal(this.s != null, true, 'Missing parameter');
-    assert.equal(this.i != null, true, 'Missing parameter');
-  }
-  static fromBuffer(buf) {
-    var i, r, s;
-    assert.equal(buf.length, 65, 'Invalid signature length');
-    i = buf.readUInt8(0);
-    assert.equal(i - 27, i - 27 & 7, 'Invalid signature parameter');
-    r = BigInteger.fromBuffer(buf.slice(1, 33));
-    s = BigInteger.fromBuffer(buf.slice(33));
-    return new Signature(r, s, i);
-  }
-  toBuffer() {
-    var buf;
-    buf = new Buffer.alloc(65);
-    buf.writeUInt8(this.i, 0);
-    this.r.toBuffer(32).copy(buf, 1);
-    this.s.toBuffer(32).copy(buf, 33);
-    return buf;
-  }
-  recoverPublicKeyFromBuffer(buffer) {
-    return this.recoverPublicKey(hash.sha256(buffer));
-  }
-  /**
-      @return {PublicKey}
-  */
-  recoverPublicKey(sha256_buffer) {
-    let Q, e, i;
-    e = BigInteger.fromBuffer(sha256_buffer);
-    i = this.i;
-    i -= 27;
-    i = i & 3;
-    Q = ecdsa.recoverPubKey(curve, e, this, i);
-    return PublicKey.fromPoint(Q);
-  }
-  /**
-      @param {Buffer} buf
-      @param {PrivateKey} private_key
-      @return {Signature}
-  */
-  static signBuffer(buf, private_key) {
-    var _hash = hash.sha256(buf);
-    return Signature.signBufferSha256(_hash, private_key);
-  }
-
-  /** Sign a buffer of exactally 32 bytes in size (sha256(text))
-      @param {Buffer} buf - 32 bytes binary
-      @param {PrivateKey} private_key
-      @return {Signature}
-  */
-  static signBufferSha256(buf_sha256, private_key) {
-    if (buf_sha256.length !== 32 || !Buffer.isBuffer(buf_sha256)) throw new Error("buf_sha256: 32 byte buffer required");
-    private_key = toPrivateObj(private_key);
-    assert(private_key, 'private_key required');
-    var der, e, ecsignature, i, lenR, lenS, nonce;
-    i = null;
-    nonce = 0;
-    e = BigInteger.fromBuffer(buf_sha256);
-    while (true) {
-      ecsignature = ecdsa.sign(curve, buf_sha256, private_key.d, nonce++);
-      der = ecsignature.toDER();
-      lenR = der[3];
-      lenS = der[5 + lenR];
-      if (lenR === 32 && lenS === 32) {
-        i = ecdsa.calcPubKeyRecoveryParam(curve, e, ecsignature, private_key.toPublicKey().Q);
-        i += 4; // compressed
-        i += 27; // compact  //  24 or 27 :( forcing odd-y 2nd key candidate)
-        break;
-      }
-      if (nonce % 10 === 0) {
-        console.log("WARN: " + nonce + " attempts to find canonical signature");
-      }
-    }
-    return new Signature(ecsignature.r, ecsignature.s, i);
-  }
-  static sign(string, private_key) {
-    return Signature.signBuffer(new Buffer.from(string), private_key);
-  }
-  /**
-      @param {Buffer} un-hashed
-      @param {./PublicKey}
-      @return {boolean}
-  */
-  verifyBuffer(buf, public_key) {
-    var _hash = hash.sha256(buf);
-    return this.verifyHash(_hash, public_key);
-  }
-  verifyHash(hash, public_key) {
-    assert.equal(hash.length, 32, "A SHA 256 should be 32 bytes long, instead got " + hash.length);
-    return ecdsa.verify(curve, hash, {
-      r: this.r,
-      s: this.s
-    }, public_key.Q);
-  }
-  // toByteBuffer() {
-  //     var b;
-  //     b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-  //     this.appendByteBuffer(b);
-  //     return b.copy(0, b.offset);
-  // };
-
-  static fromHex(hex) {
-    return Signature.fromBuffer(new Buffer.from(hex, "hex"));
-  }
-  toHex() {
-    return this.toBuffer().toString("hex");
-  }
-  static signHex(hex, private_key) {
-    var buf;
-    buf = new Buffer.from(hex, 'hex');
-    return Signature.signBuffer(buf, private_key);
-  }
-  verifyHex(hex, public_key) {
-    var buf;
-    buf = new Buffer.from(hex, 'hex');
-    return this.verifyBuffer(buf, public_key);
-  }
-}
-const toPrivateObj = o => o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;
-module.exports = Signature;

package/lib/auth/index.js

@@ -1,113 +0,0 @@
-"use strict";
-
-var bigi = require('bigi'),
-  bs58 = require('bs58'),
-  ecurve = require('ecurve'),
-  Point = ecurve.Point,
-  secp256k1 = ecurve.getCurveByName('secp256k1'),
-  config = require('../config'),
-  operations = require('./serializer/src/operations'),
-  Signature = require('./ecc/src/signature'),
-  KeyPrivate = require('./ecc/src/key_private'),
-  PublicKey = require('./ecc/src/key_public'),
-  hash = require('./ecc/src/hash');
-var Auth = {};
-var transaction = operations.transaction;
-var signed_transaction = operations.signed_transaction;
-Auth.verify = function (name, password, auths) {
-  var hasKey = false;
-  var roles = [];
-  for (var role in auths) {
-    roles.push(role);
-  }
-  var pubKeys = this.generateKeys(name, password, roles);
-  roles.forEach(function (role) {
-    if (auths[role][0][0] === pubKeys[role]) {
-      hasKey = true;
-    }
-  });
-  return hasKey;
-};
-Auth.generateKeys = function (name, password, roles) {
-  var pubKeys = {};
-  roles.forEach(function (role) {
-    var seed = name + role + password;
-    var brainKey = seed.trim().split(/[\t\n\v\f\r ]+/).join(' ');
-    var hashSha256 = hash.sha256(brainKey);
-    var bigInt = bigi.fromBuffer(hashSha256);
-    var toPubKey = secp256k1.G.multiply(bigInt);
-    var point = new Point(toPubKey.curve, toPubKey.x, toPubKey.y, toPubKey.z);
-    var pubBuf = point.getEncoded(toPubKey.compressed);
-    var checksum = hash.ripemd160(pubBuf);
-    var addy = Buffer.concat([pubBuf, checksum.slice(0, 4)]);
-    pubKeys[role] = config.get('address_prefix') + bs58.encode(addy);
-  });
-  return pubKeys;
-};
-
-/**
-	@arg {string} name - blockchain account name
-	@arg {string} password - very strong password typically no shorter than a private key
-	@arg {array} roles - defaults to standard Steem blockchain-level roles
-*/
-Auth.getPrivateKeys = function (name, password, roles = ['owner', 'active', 'posting', 'memo']) {
-  var privKeys = {};
-  roles.forEach(function (role) {
-    privKeys[role] = this.toWif(name, password, role);
-    privKeys[role + 'Pubkey'] = this.wifToPublic(privKeys[role]);
-  }.bind(this));
-  return privKeys;
-};
-Auth.isWif = function (privWif) {
-  var isWif = false;
-  try {
-    var bufWif = new Buffer.from(bs58.decode(privWif));
-    var privKey = bufWif.slice(0, -4);
-    var checksum = bufWif.slice(-4);
-    var newChecksum = hash.sha256(privKey);
-    newChecksum = hash.sha256(newChecksum);
-    newChecksum = newChecksum.slice(0, 4);
-    if (checksum.toString() == newChecksum.toString()) {
-      isWif = true;
-    }
-  } catch (e) {}
-  return isWif;
-};
-Auth.toWif = function (name, password, role) {
-  var seed = name + role + password;
-  var brainKey = seed.trim().split(/[\t\n\v\f\r ]+/).join(' ');
-  var hashSha256 = hash.sha256(brainKey);
-  var privKey = Buffer.concat([new Buffer.from([0x80]), hashSha256]);
-  var checksum = hash.sha256(privKey);
-  checksum = hash.sha256(checksum);
-  checksum = checksum.slice(0, 4);
-  var privWif = Buffer.concat([privKey, checksum]);
-  return bs58.encode(privWif);
-};
-Auth.wifIsValid = function (privWif, pubWif) {
-  return this.wifToPublic(privWif) == pubWif;
-};
-Auth.wifToPublic = function (privWif) {
-  var pubWif = KeyPrivate.fromWif(privWif);
-  pubWif = pubWif.toPublic().toString();
-  return pubWif;
-};
-Auth.isPubkey = function (pubkey, address_prefix) {
-  return PublicKey.fromString(pubkey, address_prefix) != null;
-};
-Auth.signTransaction = function (trx, keys) {
-  var signatures = [];
-  if (trx.signatures) {
-    signatures = [].concat(trx.signatures);
-  }
-  var cid = new Buffer.from(config.get('chain_id'), 'hex');
-  var buf = transaction.toBuffer(trx);
-  for (var key in keys) {
-    var sig = Signature.signBuffer(Buffer.concat([cid, buf]), keys[key]);
-    signatures.push(sig.toBuffer());
-  }
-  return signed_transaction.toObject(Object.assign(trx, {
-    signatures: signatures
-  }));
-};
-module.exports = Auth;

package/lib/auth/memo.js

@@ -1,119 +0,0 @@
-"use strict";
-
-const ByteBuffer = require('bytebuffer');
-const assert = require('assert');
-const base58 = require('bs58');
-const ecc = require('./ecc');
-const Aes = ecc.Aes;
-const PrivateKey = ecc.PrivateKey;
-const PublicKey = ecc.PublicKey;
-const serializer = require('./serializer');
-const ops = serializer.ops;
-const encMemo = ops.encrypted_memo;
-
-/**
-    Some fields are only required if the memo is marked for decryption (starts with a hash).
-    @arg {string|PrivateKey} private_key - WIF or PrivateKey object
-    @arg {string} memo - plain text is returned, hash prefix base58 is decrypted
-    @return {string} - utf8 decoded string (hash prefix)
-*/
-function decode(private_key, memo) {
-  assert(memo, 'memo is required');
-  assert.equal(typeof memo, 'string', 'memo');
-  if (!/^#/.test(memo)) return memo;
-  memo = memo.substring(1);
-  assert(private_key, 'private_key is required');
-  checkEncryption();
-  private_key = toPrivateObj(private_key);
-  memo = base58.decode(memo);
-  memo = encMemo.fromBuffer(new Buffer.from(memo, 'binary'));
-  const {
-    from,
-    to,
-    nonce,
-    check,
-    encrypted
-  } = memo;
-  const pubkey = private_key.toPublicKey().toString();
-  const otherpub = pubkey === from.toString() ? to.toString() : from.toString();
-  memo = Aes.decrypt(private_key, otherpub, nonce, encrypted, check);
-
-  // remove varint length prefix
-  const mbuf = ByteBuffer.fromBinary(memo.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-  try {
-    mbuf.mark();
-    return '#' + mbuf.readVString();
-  } catch (e) {
-    mbuf.reset();
-    // Sender did not length-prefix the memo
-    memo = new Buffer.from(mbuf.toString('binary'), 'binary').toString('utf-8');
-    return '#' + memo;
-  }
-}
-
-/**
-    Some fields are only required if the memo is marked for encryption (starts with a hash).
-    @arg {string|PrivateKey} private_key - WIF or PrivateKey object
-    @arg {string|PublicKey} public_key - Recipient
-    @arg {string} memo - plain text is returned, hash prefix text is encrypted
-    @arg {string} [testNonce = undefined] - just for testing
-    @return {string} - base64 decoded string (or plain text)
-*/
-function encode(private_key, public_key, memo, testNonce) {
-  assert(memo, 'memo is required');
-  assert.equal(typeof memo, 'string', 'memo');
-  if (!/^#/.test(memo)) return memo;
-  memo = memo.substring(1);
-  assert(private_key, 'private_key is required');
-  assert(public_key, 'public_key is required');
-  checkEncryption();
-  private_key = toPrivateObj(private_key);
-  public_key = toPublicObj(public_key);
-  const mbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-  mbuf.writeVString(memo);
-  memo = new Buffer.from(mbuf.copy(0, mbuf.offset).toBinary(), 'binary');
-  const {
-    nonce,
-    message,
-    checksum
-  } = Aes.encrypt(private_key, public_key, memo, testNonce);
-  memo = encMemo.fromObject({
-    from: private_key.toPublicKey(),
-    to: public_key,
-    nonce,
-    check: checksum,
-    encrypted: message
-  });
-  // serialize
-  memo = encMemo.toBuffer(memo);
-  return '#' + base58.encode(new Buffer.from(memo, 'binary'));
-}
-let encodeTest = undefined;
-
-/**
-  Memo encryption has failed in the browser before.  An Error will be thrown
-  if a memo can't be encrypted and decrypted.
-*/
-function checkEncryption() {
-  if (encodeTest === undefined) {
-    let plaintext;
-    encodeTest = true; // prevent infinate looping
-    try {
-      const wif = '5JdeC9P7Pbd1uGdFVEsJ41EkEnADbbHGq6p1BwFxm6txNBsQnsw';
-      const pubkey = 'STM8m5UgaFAAYQRuaNejYdS8FVLVp9Ss3K1qAVk5de6F8s3HnVbvA';
-      const cyphertext = encode(wif, pubkey, '#memo爱');
-      plaintext = decode(wif, cyphertext);
-    } catch (e) {
-      console.error(e);
-    } finally {
-      encodeTest = plaintext === '#memo爱';
-    }
-  }
-  if (encodeTest === false) throw new Error('This environment does not support encryption.');
-}
-const toPrivateObj = o => o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;
-const toPublicObj = o => o ? o.Q ? o : PublicKey.fromString(o) : o /*null or undefined*/;
-module.exports = {
-  decode,
-  encode
-};

package/lib/auth/serializer/index.js

@@ -1,15 +0,0 @@
-"use strict";
-
-module.exports = {
-  // Primary class for creating operations
-  Serializer: require('./src/serializer'),
-  // helper functions for creating operations
-  fp: require('./src/fast_parser'),
-  // Low level types
-  types: require('./src/types'),
-  // Higher level operations (made out of generic types)
-  ops: require('./src/operations'),
-  // Utility that generates JSON examples
-  template: require('./src/template'),
-  number_utils: require('./src/number_utils')
-};

package/lib/auth/serializer/src/ChainTypes.js

@@ -1,87 +0,0 @@
-"use strict";
-
-var ChainTypes;
-module.exports = ChainTypes = {};
-ChainTypes.reserved_spaces = {
-  relative_protocol_ids: 0,
-  protocol_ids: 1,
-  implementation_ids: 2
-};
-ChainTypes.operations = {
-  vote: 0,
-  comment: 1,
-  transfer: 2,
-  transfer_to_vesting: 3,
-  withdraw_vesting: 4,
-  limit_order_create: 5,
-  limit_order_cancel: 6,
-  feed_publish: 7,
-  convert: 8,
-  account_create: 9,
-  account_update: 10,
-  witness_update: 11,
-  account_witness_vote: 12,
-  account_witness_proxy: 13,
-  pow: 14,
-  custom: 15,
-  report_over_production: 16,
-  delete_comment: 17,
-  custom_json: 18,
-  comment_options: 19,
-  set_withdraw_vesting_route: 20,
-  limit_order_create2: 21,
-  claim_account: 22,
-  create_claimed_account: 23,
-  request_account_recovery: 24,
-  recover_account: 25,
-  change_recovery_account: 26,
-  escrow_transfer: 27,
-  escrow_dispute: 28,
-  escrow_release: 29,
-  pow2: 30,
-  escrow_approve: 31,
-  transfer_to_savings: 32,
-  transfer_from_savings: 33,
-  cancel_transfer_from_savings: 34,
-  custom_binary: 35,
-  decline_voting_rights: 36,
-  reset_account: 37,
-  set_reset_account: 38,
-  claim_reward_balance: 39,
-  delegate_vesting_shares: 40,
-  account_create_with_delegation: 41,
-  witness_set_properties: 42,
-  account_update2: 43,
-  create_proposal: 44,
-  update_proposal_votes: 45,
-  remove_proposal: 46,
-  claim_reward_balance2: 47,
-  vote2: 48,
-  smt_setup: 49,
-  smt_setup_emissions: 50,
-  smt_setup_ico_tier: 51,
-  smt_set_setup_parameters: 52,
-  smt_set_runtime_parameters: 53,
-  smt_create: 54,
-  smt_contribute: 55,
-  fill_convert_request: 56,
-  author_reward: 57,
-  curation_reward: 58,
-  comment_reward: 59,
-  liquidity_reward: 60,
-  interest: 61,
-  fill_vesting_withdraw: 62,
-  fill_order: 63,
-  shutdown_witness: 64,
-  fill_transfer_from_savings: 65,
-  hardfork: 66,
-  comment_payout_update: 67,
-  return_vesting_delegation: 68,
-  comment_benefactor_reward: 69
-};
-
-//types.hpp
-ChainTypes.object_type = {
-  "null": 0,
-  base: 1
-};

package/lib/auth/serializer/src/convert.js

@@ -1,34 +0,0 @@
-"use strict";
-
-var ByteBuffer = require('bytebuffer');
-module.exports = function (type) {
-  return {
-    fromHex(hex) {
-      var b = ByteBuffer.fromHex(hex, ByteBuffer.LITTLE_ENDIAN);
-      return type.fromByteBuffer(b);
-    },
-    toHex(object) {
-      var b = toByteBuffer(type, object);
-      return b.toHex();
-    },
-    fromBuffer(buffer) {
-      var b = ByteBuffer.fromBinary(buffer.toString(), ByteBuffer.LITTLE_ENDIAN);
-      return type.fromByteBuffer(b);
-    },
-    toBuffer(object) {
-      return new Buffer(toByteBuffer(type, object).toBinary(), 'binary');
-    },
-    fromBinary(string) {
-      var b = ByteBuffer.fromBinary(string, ByteBuffer.LITTLE_ENDIAN);
-      return type.fromByteBuffer(b);
-    },
-    toBinary(object) {
-      return toByteBuffer(type, object).toBinary();
-    }
-  };
-};
-var toByteBuffer = function (type, object) {
-  var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-  type.appendByteBuffer(b, object);
-  return b.copy(0, b.offset);
-};

package/lib/auth/serializer/src/error_with_cause.js

@@ -1,27 +0,0 @@
-"use strict";
-
-/** Exception nesting.  */
-class ErrorWithCause {
-  constructor(message, cause) {
-    this.message = message;
-    if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) {
-      this.message = `cause\t${cause.message}\t` + this.message;
-    }
-    var stack = ""; //(new Error).stack
-    if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) {
-      stack = `caused by\n\t${cause.stack}\t` + stack;
-    }
-    this.stack = this.message + "\n" + stack;
-  }
-  static throw(message, cause) {
-    var msg = message;
-    if (typeof cause !== "undefined" && cause !== null ? cause.message : undefined) {
-      msg += `\t cause: ${cause.message} `;
-    }
-    if (typeof cause !== "undefined" && cause !== null ? cause.stack : undefined) {
-      msg += `\n stack: ${cause.stack} `;
-    }
-    throw new Error(msg);
-  }
-}
-module.exports = ErrorWithCause;

package/lib/auth/serializer/src/fast_parser.js

@@ -1,57 +0,0 @@
-"use strict";
-
-const ecc = require("../../ecc");
-const PublicKey = ecc.PublicKey;
-class FastParser {
-  static fixed_data(b, len, buffer) {
-    if (!b) {
-      return;
-    }
-    if (buffer) {
-      let data = buffer.slice(0, len).toString('binary');
-      b.append(data, 'binary');
-      while (len-- > data.length) {
-        b.writeUint8(0);
-      }
-    } else {
-      let b_copy = b.copy(b.offset, b.offset + len);
-      b.skip(len);
-      return new Buffer.from(b_copy.toBinary(), 'binary');
-    }
-  }
-  static public_key(b, public_key) {
-    if (!b) {
-      return;
-    }
-    if (public_key) {
-      var buffer = public_key.toBuffer();
-      b.append(buffer.toString('binary'), 'binary');
-      return;
-    } else {
-      buffer = FastParser.fixed_data(b, 33);
-      return PublicKey.fromBuffer(buffer);
-    }
-  }
-  static ripemd160(b, ripemd160) {
-    if (!b) {
-      return;
-    }
-    if (ripemd160) {
-      FastParser.fixed_data(b, 20, ripemd160);
-      return;
-    } else {
-      return FastParser.fixed_data(b, 20);
-    }
-  }
-  static time_point_sec(b, epoch) {
-    if (epoch) {
-      epoch = Math.ceil(epoch / 1000);
-      b.writeInt32(epoch);
-      return;
-    } else {
-      epoch = b.readInt32(); // fc::time_point_sec
-      return new Date(epoch * 1000);
-    }
-  }
-}
-module.exports = FastParser;