Feature/v13 sml changes (#101)

* Add changes to SMLEntries from the latest core version

* Fix SMLEntry.fromBuffer method

* Fix ip serialization and tests

* Add more tests

* Reverse byte order in hash in tests

* Update SMLDiff test with a new diff

* Fix SMLDiff, coinbase payload and ip serializer

* Bump module version

* Update
Fix typo in `deterministicmnlist` dir name

Author: antouhou

index.js

@@ -48,8 +48,8 @@ bitcore.errors = require('./lib/errors');
 bitcore.Address = require('./lib/address');
 bitcore.Block = require('./lib/block');
 bitcore.MerkleBlock = require('./lib/block/merkleblock');
-bitcore.SimplifiedMNListDiff = require('./lib/deterministcmnlist/SimplifiedMNListDiff');
-bitcore.SimplifiedMNListEntry = require('./lib/deterministcmnlist/SimplifiedMNListEntry');
+bitcore.SimplifiedMNListDiff = require('./lib/deterministicmnlist/SimplifiedMNListDiff');
+bitcore.SimplifiedMNListEntry = require('./lib/deterministicmnlist/SimplifiedMNListEntry');
 bitcore.BlockHeader = require('./lib/block/blockheader');
 bitcore.HDPrivateKey = require('./lib/hdprivatekey.js');
 bitcore.HDPublicKey = require('./lib/hdpublickey.js');

lib/constants/index.js

@@ -35,4 +35,5 @@ module.exports = {
   EMPTY_IPV6_ADDRESS: '[0:0:0:0:0:0:0:0]:0',
   EMPTY_IPV4_ADDRESS: '0.0.0.0:0',
   CURRENT_PROTOCOL_VERSION: 70211,
+  SML_ENTRY_SIZE: 151,
 };

lib/deterministcmnlist/PartialMerkleTree.js renamed to lib/deterministicmnlist/PartialMerkleTree.js

@@ -23,6 +23,7 @@ var constants = require('../constants');
  * @property {Transaction} cbTx;
  * @property {Array<string>} deletedMNs - sha256 hashes of deleted MNs
  * @property {Array<SimplifiedMNListEntry>} mnList
+ * @property {string} merkleRootMNList - merkle root of the whole mn list
  */
 function SimplifiedMNListDiff(arg) {
   if (arg) {
@@ -46,27 +47,28 @@ function SimplifiedMNListDiff(arg) {
  * @return {SimplifiedMNListDiff}
  */
 SimplifiedMNListDiff.fromBuffer = function fromBuffer(buffer) {
-  var bufferReader = new BufferReader(buffer);
+  var bufferReader = new BufferReader(Buffer.from(buffer));
   var data = {};
 
-  data.baseBlockHash = bufferReader.read(constants.SHA256_HASH_SIZE).toString('hex');
-  data.blockHash = bufferReader.read(constants.SHA256_HASH_SIZE).toString('hex');
+  data.baseBlockHash = bufferReader.read(constants.SHA256_HASH_SIZE).reverse().toString('hex');
+  data.blockHash = bufferReader.read(constants.SHA256_HASH_SIZE).reverse().toString('hex');
 
   data.cbTxMerkleTree = PartialMerkleTree.fromBufferReader(bufferReader);
   data.cbTx = new Transaction().fromBufferReader(bufferReader);
 
   var deletedMNsCount = bufferReader.readVarintNum();
   data.deletedMNs = [];
   for (var i = 0; i < deletedMNsCount; i++) {
-    data.deletedMNs.push(bufferReader.read(constants.SHA256_HASH_SIZE).toString('hex'));
+    data.deletedMNs.push(bufferReader.read(constants.SHA256_HASH_SIZE).reverse().toString('hex'));
   }
 
   var mnListSize = bufferReader.readVarintNum();
   data.mnList = [];
   for (var i = 0; i < mnListSize; i++) {
-    data.mnList.push(SimplifiedMNListEntry.fromBuffer(bufferReader.read(91)));
+    data.mnList.push(SimplifiedMNListEntry.fromBuffer(bufferReader.read(constants.SML_ENTRY_SIZE)));
   }
 
+  data.merkleRootMNList = data.cbTx.extraPayload.merkleRootMNList;
   return this.fromObject(data);
 };
 
@@ -85,15 +87,15 @@ SimplifiedMNListDiff.fromHexString = function fromHexString(hexString) {
 SimplifiedMNListDiff.prototype.toBuffer = function toBuffer() {
   var bufferWriter = new BufferWriter();
 
-  bufferWriter.write(Buffer.from(this.baseBlockHash, 'hex'));
-  bufferWriter.write(Buffer.from(this.blockHash, 'hex'));
+  bufferWriter.write(Buffer.from(this.baseBlockHash, 'hex').reverse());
+  bufferWriter.write(Buffer.from(this.blockHash, 'hex').reverse());
 
   bufferWriter.write(this.cbTxMerkleTree.toBuffer());
   bufferWriter.write(this.cbTx.toBuffer());
 
   bufferWriter.writeVarintNum(this.deletedMNs.length);
   this.deletedMNs.forEach(function (deleteMNHash) {
-    bufferWriter.write(Buffer.from(deleteMNHash, 'hex'));
+    bufferWriter.write(Buffer.from(deleteMNHash, 'hex').reverse());
   });
 
   bufferWriter.writeVarintNum(this.mnList.length);
@@ -125,6 +127,7 @@ SimplifiedMNListDiff.fromObject = function fromObject(obj) {
   simplifiedMNListDiff.mnList = obj.mnList.map(function (SMLEntry) {
     return new SimplifiedMNListEntry(SMLEntry);
   });
+  simplifiedMNListDiff.merkleRootMNList = obj.merkleRootMNList;
 
   return simplifiedMNListDiff;
 };
@@ -144,6 +147,7 @@ SimplifiedMNListDiff.prototype.toObject = function toObject() {
   obj.mnList = this.mnList.map(function (SMLEntry) {
     return SMLEntry.toObject();
   });
+  obj.merkleRootMNList = this.merkleRootMNList;
 
   return obj;
 };

lib/deterministcmnlist/SimplifiedMNListDiff.js renamed to lib/deterministicmnlist/SimplifiedMNListDiff.js

@@ -20,12 +20,14 @@ var serializeIp = ipUtils.ipAndPortToBuffer;
 
 var SHA256_HASH_SIZE = constants.SHA256_HASH_SIZE;
 var PUBKEY_ID_SIZE = constants.PUBKEY_ID_SIZE;
+var BLS_PUBLIC_KEY_SIZE = constants.BLS_PUBLIC_KEY_SIZE;
 
 /**
  * @typedef {Object} SMLEntry
- * @property {string} proRegTxHash uint256
+ * @property {string} proRegTxHash
+ * @property {string} confirmedHash
  * @property {string} service - ip and port
- * @property {string} keyIDOperator - public key hash, 20 bytes
+ * @property {string} pubKeyOperator - operator public key
  * @property {string} keyIDVoting - public key hash, 20 bytes
  * @property {boolean} isValid
  */
@@ -34,9 +36,10 @@ var PUBKEY_ID_SIZE = constants.PUBKEY_ID_SIZE;
  * @class SimplifiedMNListEntry
  * @param {*} arg - A Buffer, JSON string, or Object representing a SmlEntry
  * @constructor
- * @property {string} proRegTxHash uint256
+ * @property {string} proRegTxHash
+ * @property {string} confirmedHash
  * @property {string} service - ip and port
- * @property {string} keyIDOperator - public key hash, 20 bytes
+ * @property {string} pubKeyOperator - operator public key
  * @property {string} keyIDVoting - public key hash, 20 bytes
  * @property {boolean} isValid
  */
@@ -67,10 +70,11 @@ SimplifiedMNListEntry.fromBuffer = function fromBuffer(buffer) {
   var bufferReader = new BufferReader(buffer);
 
   return SimplifiedMNListEntry.fromObject({
-    proRegTxHash: bufferReader.read(SHA256_HASH_SIZE).toString('hex'),
+    proRegTxHash: bufferReader.read(SHA256_HASH_SIZE).reverse().toString('hex'),
+    confirmedHash: bufferReader.read(SHA256_HASH_SIZE).reverse().toString('hex'),
     service: parseIp(bufferReader.read(ipUtils.IP_AND_PORT_SIZE)),
-    keyIDOperator: bufferReader.read(PUBKEY_ID_SIZE).toString('hex'),
-    keyIDVoting: bufferReader.read(PUBKEY_ID_SIZE).toString('hex'),
+    pubKeyOperator: bufferReader.read(BLS_PUBLIC_KEY_SIZE).toString('hex'),
+    keyIDVoting: bufferReader.read(PUBKEY_ID_SIZE).reverse().toString('hex'),
     isValid: Boolean(bufferReader.readUInt8())
   });
 };
@@ -91,10 +95,11 @@ SimplifiedMNListEntry.prototype.toBuffer = function toBuffer() {
   this.validate();
   var bufferWriter = new BufferWriter();
 
-  bufferWriter.write(Buffer.from(this.proRegTxHash, 'hex'));
+  bufferWriter.write(Buffer.from(this.proRegTxHash, 'hex').reverse());
+  bufferWriter.write(Buffer.from(this.confirmedHash, 'hex').reverse());
   bufferWriter.write(serializeIp(this.service));
-  bufferWriter.write(Buffer.from(this.keyIDOperator, 'hex'));
-  bufferWriter.write(Buffer.from(this.keyIDVoting, 'hex'));
+  bufferWriter.write(Buffer.from(this.pubKeyOperator, 'hex'));
+  bufferWriter.write(Buffer.from(this.keyIDVoting, 'hex').reverse());
   bufferWriter.writeUInt8(Number(this.isValid));
 
   return bufferWriter.toBuffer();
@@ -108,8 +113,9 @@ SimplifiedMNListEntry.prototype.toBuffer = function toBuffer() {
 SimplifiedMNListEntry.fromObject = function fromObject(obj) {
   var SMLEntry = new SimplifiedMNListEntry();
   SMLEntry.proRegTxHash = obj.proRegTxHash;
+  SMLEntry.confirmedHash = obj.confirmedHash;
   SMLEntry.service = obj.service;
-  SMLEntry.keyIDOperator = obj.keyIDOperator;
+  SMLEntry.pubKeyOperator = obj.pubKeyOperator;
   SMLEntry.keyIDVoting = obj.keyIDVoting;
   SMLEntry.isValid = obj.isValid;
 
@@ -119,22 +125,24 @@ SimplifiedMNListEntry.fromObject = function fromObject(obj) {
 
 SimplifiedMNListEntry.prototype.validate = function validate() {
   $.checkArgument(isSha256(this.proRegTxHash), 'Expected proRegTxHash to be a sha256 hex string');
+  $.checkArgument(isSha256(this.confirmedHash), 'Expected confirmedHash to be a sha256 hex string');
   if (!ipUtils.isZeroAddress(this.service)) {
     $.checkArgument(ipUtils.isIPV4(this.service), 'Expected service to be a string with ip address and port');
   }
   if (!isHexStringOfSize(this.keyIDVoting, PUBKEY_ID_SIZE * 2)) {
     console.log(this.keyIDVoting);
   }
-  $.checkArgument(isHexStringOfSize(this.keyIDOperator, PUBKEY_ID_SIZE * 2), 'Expected keyIDOperator to be a pubkey id');
+  $.checkArgument(isHexStringOfSize(this.pubKeyOperator, BLS_PUBLIC_KEY_SIZE * 2), 'Expected pubKeyOperator to be a pubkey id');
   $.checkArgument(isHexStringOfSize(this.keyIDVoting, PUBKEY_ID_SIZE * 2), 'Expected keyIDVoting to be a pubkey id');
   $.checkArgument(typeof this.isValid === 'boolean', 'Expected isValid to be a boolean');
 };
 
 SimplifiedMNListEntry.prototype.toObject = function toObject() {
   return {
     proRegTxHash: this.proRegTxHash,
+    confirmedHash: this.confirmedHash,
     service: this.service,
-    keyIDOperator: this.keyIDOperator,
+    pubKeyOperator: this.pubKeyOperator,
     keyIDVoting: this.keyIDVoting,
     isValid: this.isValid
   };
@@ -143,7 +151,7 @@ SimplifiedMNListEntry.prototype.toObject = function toObject() {
 /**
  * @return {Buffer}
  */
-SimplifiedMNListEntry.prototype.getHash = function hash() {
+SimplifiedMNListEntry.prototype.calculateHash = function calculateHash() {
   return Hash.sha256sha256(this.toBuffer());
 };
 

lib/deterministcmnlist/SimplifiedMNListEntry.js renamed to lib/deterministicmnlist/SimplifiedMNListEntry.js

@@ -47,7 +47,7 @@ CoinbasePayload.fromBuffer = function (rawPayload) {
   var payload = new CoinbasePayload();
   payload.version = payloadBufferReader.readUInt16LE();
   payload.height = payloadBufferReader.readUInt32LE();
-  payload.merkleRootMNList = payloadBufferReader.read(HASH_SIZE).toString('hex');
+  payload.merkleRootMNList = payloadBufferReader.read(HASH_SIZE).reverse().toString('hex');
 
   if (!payloadBufferReader.finished()) {
     throw new Error('Failed to parse payload: raw payload is bigger than expected.');
@@ -110,7 +110,7 @@ CoinbasePayload.prototype.toBuffer = function toBuffer() {
   payloadBufferWriter
     .writeUInt16LE(this.version)
     .writeUInt32LE(this.height)
-    .write(Buffer.from(this.merkleRootMNList, 'hex'));
+    .write(Buffer.from(this.merkleRootMNList, 'hex').reverse());
 
   return payloadBufferWriter.toBuffer();
 };

lib/transaction/payload/coinbasepayload.js

@@ -5,7 +5,7 @@ var BufferWriter = require('../encoding/bufferwriter');
 var BufferReader = require('../encoding/bufferreader');
 var constants = require('../constants');
 var serviceRegex = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]):[0-9]+$/;
-var ipV6prefix = Buffer.alloc(12);
+var ipV6prefix = Buffer.from('00000000000000000000ffff', 'hex');
 var emptyAddress = Buffer.alloc(18);
 var EMPTY_IPV6_ADDRESS = constants.EMPTY_IPV6_ADDRESS;
 var EMPTY_IPV4_ADDRESS = constants.EMPTY_IPV4_ADDRESS;