Skip unsupported RTM tx

index.js

@@ -7,6 +7,8 @@ const varuint = require('varuint-bitcoin');
 const crypto  = require('crypto');
 const fastMerkleRoot = require('merkle-lib/fastRoot');
 
+const rtm = require('cryptoforknote-util/rtm');
+
 function scriptCompile(addrHash) {
   return bitcoin.script.compile([
     bitcoin.opcodes.OP_DUP,
@@ -18,7 +20,7 @@ function scriptCompile(addrHash) {
 }
 
 function reverseBuffer(buff) {
-  let reversed = new Buffer(buff.length);
+  let reversed = Buffer.alloc(buff.length);
   for (var i = buff.length - 1; i >= 0; i--) reversed[buff.length - i - 1] = buff[i];
   return reversed;
 }
@@ -45,7 +47,7 @@ function hash256(buffer) {
 };
 
 function getMerkleRoot(transactions) {
-  if (transactions.length === 0) return new Buffer('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
+  if (transactions.length === 0) return Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
   const forWitness = txesHaveWitnessCommit(transactions);
   const hashes = transactions.map(transaction => transaction.getHash(forWitness));
   const rootHash = fastMerkleRoot(hashes, hash256);
@@ -75,27 +77,27 @@ module.exports.RavenBlockTemplate = function(rpcData, poolAddress) {
     bytesHeight = Math.ceil((rpcData.height << 1).toString(2).length / 8);
     const lengthDiff  = blockHeightSerial.length/2 - bytesHeight;
     for (let i = 0; i < lengthDiff; i++) blockHeightSerial = blockHeightSerial + '00';
-    const serializedBlockHeight = new Buffer.concat([
-      new Buffer('0' + bytesHeight, 'hex'),
-      reverseBuffer(new Buffer(blockHeightSerial, 'hex')),
-      new Buffer('00', 'hex') // OP_0
+    const serializedBlockHeight = Buffer.concat([
+      Buffer.from('0' + bytesHeight, 'hex'),
+      reverseBuffer(Buffer.from(blockHeightSerial, 'hex')),
+      Buffer.from('00', 'hex') // OP_0
     ]);
 
     txCoinbase.addInput(
       // will be used for our reserved_offset extra_nonce
-      new Buffer('0000000000000000000000000000000000000000000000000000000000000000', 'hex'),
+      Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex'),
       0xFFFFFFFF, 0xFFFFFFFF,
-      new Buffer.concat([serializedBlockHeight, Buffer('CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC', 'hex')]) // 17 bytes
+      Buffer.concat([serializedBlockHeight, Buffer.alloc(17, 0xCC)]) // 17 bytes
     );
 
     txCoinbase.addOutput(scriptCompile(poolAddrHash), Math.floor(rpcData.coinbasevalue));
 
     if (rpcData.default_witness_commitment) {
-      txCoinbase.addOutput(new Buffer(rpcData.default_witness_commitment, 'hex'), 0);
+      txCoinbase.addOutput(Buffer.from(rpcData.default_witness_commitment, 'hex'), 0);
     }
   }
 
-  let header = new Buffer(80);
+  let header = Buffer.alloc(80);
   { let position = 0;
     header.writeUInt32BE(rpcData.height, position, 4);                  // height         42-46
     header.write(rpcData.bits, position += 4, 4, 'hex');                // bits           47-50
@@ -106,17 +108,17 @@ module.exports.RavenBlockTemplate = function(rpcData, poolAddress) {
     header = reverseBuffer(header);
   }
   
-  let blob = new Buffer.concat([
+  let blob = Buffer.concat([
     header, // 80 bytes
-    new Buffer('AAAAAAAAAAAAAAAA', 'hex'), // 8 bytes
-    new Buffer('BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'hex'), // 32 bytes
-    varuint.encode(rpcData.transactions.length + 1, new Buffer(varuint.encodingLength(rpcData.transactions.length + 1)), 0)
+    Buffer.from('AAAAAAAAAAAAAAAA', 'hex'), // 8 bytes
+    Buffer.from('BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', 'hex'), // 32 bytes
+    varuint.encode(rpcData.transactions.length + 1, Buffer.alloc(varuint.encodingLength(rpcData.transactions.length + 1)), 0)
   ]);
   const offset1 = blob.length; 
-  blob = new Buffer.concat([ blob, new Buffer(txCoinbase.toHex(), 'hex') ]);
+  blob = Buffer.concat([ blob, Buffer.from(txCoinbase.toHex(), 'hex') ]);
 
   rpcData.transactions.forEach(function (value) {
-    blob = new Buffer.concat([ blob, new Buffer(value.data, 'hex') ]);
+    blob = Buffer.concat([ blob, Buffer.from(value.data, 'hex') ]);
   });
 
   const EPOCH_LENGTH = 7500;
@@ -126,7 +128,7 @@ module.exports.RavenBlockTemplate = function(rpcData, poolAddress) {
     if (last_epoch_number && last_epoch_number + 1 === epoch_number) {
       last_seed_hash = sha3.update(last_seed_hash).digest();
     } else {
-      last_seed_hash = new Buffer(32, 0);
+      last_seed_hash = Buffer.alloc(32, 0);
       for (let i = 0; i < epoch_number; i++) {
         last_seed_hash = sha3.update(last_seed_hash).digest();
         sha3.reset();
@@ -150,27 +152,30 @@ module.exports.RavenBlockTemplate = function(rpcData, poolAddress) {
   };
 };
 
-function update_merkle_root_hash(blob_in, blob_out) {
-  let offset = 80 + 8 + 32;
+function update_merkle_root_hash(offset, payload, blob_in, blob_out) {
   const nTransactions = varuint.decode(blob_in, offset);
   offset += varuint.decode.bytes;
   let transactions = [];
   for (let i = 0; i < nTransactions; ++i) {
-    const tx = bitcoin.Transaction.fromBuffer(blob_in.slice(offset), true);
+    const tx = bitcoin.Transaction.fromBuffer(blob_in.slice(offset), true, payload && i == 0);
     transactions.push(tx);
     offset += tx.byteLength();
   }
   getMerkleRoot(transactions).copy(blob_out, 4 + 32);
 };
 
+module.exports.blockHashBuff = function(blobBuffer) {
+  return reverseBuffer(hash256(blobBuffer));
+};
+
 module.exports.convertRavenBlob = function(blobBuffer) {
   let header = blobBuffer.slice(0, 80);
-  update_merkle_root_hash(blobBuffer, header);
-  return reverseBuffer(hash256(header));
+  update_merkle_root_hash(80 + 8 + 32, false, blobBuffer, header);
+  return module.exports.blockHashBuff(header);
 };
 
 module.exports.constructNewRavenBlob = function(blockTemplate, nonceBuff, mixhashBuff) {
-  update_merkle_root_hash(blockTemplate, blockTemplate);
+  update_merkle_root_hash(80 + 8 + 32, false, blockTemplate, blockTemplate);
   nonceBuff.copy  (blockTemplate, 80, 0, 8);
   mixhashBuff.copy(blockTemplate, 88, 0, 32);
   return blockTemplate;
@@ -199,4 +204,20 @@ module.exports.ErgBlockTemplate = function(rpcData) {
     difficulty:         difficulty,
     height:             parseInt(rpcData.h)
   };
-};
+};
+
+module.exports.RtmBlockTemplate = function(rpcData, poolAddress) {
+  return rtm.RtmBlockTemplate(rpcData, poolAddress);
+};
+
+module.exports.convertRtmBlob = function(blobBuffer) {
+  let header = blobBuffer.slice(0, 80);
+  update_merkle_root_hash(80, true, blobBuffer, header);
+  return header;
+};
+
+module.exports.constructNewRtmBlob = function(blockTemplate, nonceBuff) {
+  update_merkle_root_hash(80, true, blockTemplate, blockTemplate);
+  nonceBuff.copy(blockTemplate, 76, 0, 4);
+  return blockTemplate;
+};

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cryptoforknote-util",
-  "version": "10.1.0",
+  "version": "11.2.0",
   "main": "cryptoforknote-util",
   "author": {
     "name": "LucasJones",
@@ -16,8 +16,10 @@
     "nan": "^2.14.2",
     "bignum": "^0.13.1",
     "sha3": "*",
+    "base58-native": "*",
     "varuint-bitcoin": "^1.0.4",
-    "bitcoinjs-lib": "git+https://github.com/bitcoinjs/bitcoinjs-lib.git#533d6c2e6d0aa4111f7948b1c12003cf6ef83137"
+    "merkle-lib": "^2.0.10",
+    "bitcoinjs-lib": "git+https://github.com/MoneroOcean/bitcoinjs-lib.git"
   },
   "keywords": [
     "cryptonight",

rtm.js

@@ -0,0 +1,285 @@
+const bignum = require('bignum');
+const base58 = require('base58-native');
+
+const diff1 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
+
+function reverseBuffer(buff) {
+  let reversed = Buffer.alloc(buff.length);
+  for (let i = buff.length - 1; i >= 0; i--) reversed[buff.length - i - 1] = buff[i];
+  return reversed;
+}
+
+function reverseByteOrder(buff) {
+  for (let i = 0; i < 8; i++) buff.writeUInt32LE(buff.readUInt32BE(i * 4), i * 4);
+  return reverseBuffer(buff);
+}
+
+function packInt32LE(num) {
+  let buff = Buffer.alloc(4);
+  buff.writeInt32LE(num, 0);
+  return buff;
+}
+
+function packInt32BE(num) {
+  let buff = Buffer.alloc(4);
+  buff.writeInt32BE(num, 0);
+  return buff;
+}
+
+function packUInt16LE(num) {
+  let buff = Buffer.alloc(2);
+  buff.writeUInt16LE(num, 0);
+  return buff;
+}
+
+function packUInt32LE(num) {
+  let buff = Buffer.alloc(4);
+  buff.writeUInt32LE(num, 0);
+  return buff;
+}
+
+function packUInt32BE(num) {
+  let buff = Buffer.alloc(4);
+  buff.writeUInt32BE(num, 0);
+  return buff;
+}
+
+function packInt64LE(num){
+  let buff = Buffer.alloc(8);
+  buff.writeUInt32LE(num % Math.pow(2, 32), 0);
+  buff.writeUInt32LE(Math.floor(num / Math.pow(2, 32)), 4);
+  return buff;
+}
+
+// Defined in bitcoin protocol here:
+// https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer
+function varIntBuffer(n) {
+  if (n < 0xfd) {
+    return Buffer.from([n]);
+  } else if (n <= 0xffff) {
+    let buff = Buffer.alloc(3);
+    buff[0] = 0xfd;
+    buff.writeUInt16LE(n, 1);
+    return buff;
+  } else if (n <= 0xffffffff) {
+    let buff = Buffer.alloc(5);
+    buff[0] = 0xfe;
+    buff.writeUInt32LE(n, 1);
+    return buff;
+  } else{
+    let buff = Buffer.alloc(9);
+    buff[0] = 0xff;
+    packUInt16LE(n).copy(buff, 1);
+    return buff;
+  }
+}
+
+// "serialized CScript" formatting as defined here:
+// https://github.com/bitcoin/bips/blob/master/bip-0034.mediawiki#specification
+// Used to format height and date when putting into script signature:
+// https://en.bitcoin.it/wiki/Script
+function serializeNumber(n) {
+  // New version from TheSeven
+  if (n >= 1 && n <= 16) return Buffer.from([0x50 + n]);
+  var l = 1;
+  var buff = Buffer.alloc(9);
+  while (n > 0x7f) {
+      buff.writeUInt8(n & 0xff, l++);
+      n >>= 8;
+  }
+  buff.writeUInt8(l, 0);
+  buff.writeUInt8(n, l++);
+  return buff.slice(0, l);
+}
+
+// Used for serializing strings used in script signature
+function serializeString(s) {
+  if (s.length < 253) {
+    return Buffer.concat([ Buffer.from([s.length]), Buffer.from(s) ]);
+  } else if (s.length < 0x10000) {
+    return Buffer.concat([ Buffer.from([253]), packUInt16LE(s.length), Buffer.from(s) ]);
+  } else if (s.length < 0x100000000) {
+    return Buffer.concat([ Buffer.from([254]), packUInt32LE(s.length), Buffer.from(s) ]);
+  } else {
+    return Buffer.concat([ Buffer.from([255]), packUInt16LE(s.length), Buffer.from(s) ]);
+  }
+}
+
+// An exact copy of python's range feature. Written by Tadeck:
+// http://stackoverflow.com/a/8273091
+function range(start, stop, step) {
+  if (typeof stop === 'undefined') {
+    stop = start;
+    start = 0;
+  }
+  if (typeof step === 'undefined') {
+    step = 1;
+  }
+  if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
+    return [];
+  }
+  let result = [];
+  for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
+    result.push(i);
+  }
+  return result;
+}
+
+function uint256BufferFromHash(hex) {
+  let fromHex = Buffer.from(hex, 'hex');
+  if (fromHex.length != 32) {
+    let empty = Buffer.alloc(32);
+    empty.fill(0);
+    fromHex.copy(empty);
+    fromHex = empty;
+  }
+  return reverseBuffer(fromHex);
+}
+
+function getTransactionBuffers(txs) {
+  let txHashes = txs.map(function(tx) {
+    if (tx.txid !== undefined) {
+      return uint256BufferFromHash(tx.txid);
+    }
+    return uint256BufferFromHash(tx.hash);
+  });
+  return [null].concat(txHashes);
+}
+
+function addressToScript(addr) {
+  const decoded = base58.decode(addr);
+  if (decoded.length != 25)  throw new Error('Invalid address length for ' + addr);
+  if (!decoded) throw new Error('Base58 decode failed for ' + addr);
+  const pubkey = decoded.slice(1, -4);
+  return Buffer.concat([Buffer.from([0x76, 0xa9, 0x14]), pubkey, Buffer.from([0x88, 0xac])]);
+}
+
+function createOutputTransaction(amount, payee, rewardToPool, reward, txOutputBuffers, payeeScript) {
+  const payeeReward = amount;
+  if (!payeeScript) payeeScript = addressToScript(payee);
+  txOutputBuffers.push(Buffer.concat([
+    packInt64LE(payeeReward),
+    varIntBuffer(payeeScript.length),
+    payeeScript
+  ]));
+  return { reward: reward - amount, rewardToPool: rewardToPool - amount };
+}
+
+function generateOutputTransactions(rpcData, poolAddress) {
+  let reward       = rpcData.coinbasevalue;
+  let rewardToPool = reward;
+  let txOutputBuffers = [];
+
+  if (rpcData.smartnode) {
+    if (rpcData.smartnode.payee) {
+      const rewards = createOutputTransaction(rpcData.smartnode.amount, rpcData.smartnode.payee, rewardToPool, reward, txOutputBuffers);
+      reward        = rewards.reward;
+      rewardToPool  = rewards.rewardToPool;
+    } else if (Array.isArray(rpcData.smartnode)) {
+      for (let i in rpcData.smartnode) {
+        const rewards = createOutputTransaction(rpcData.smartnode[i].amount, rpcData.smartnode[i].payee, rewardToPool, reward, txOutputBuffers);
+	reward        = rewards.reward;
+        rewardToPool  = rewards.rewardToPool;
+      }
+    } 
+  }
+
+  if (rpcData.superblock) {
+    for (let i in rpcData.superblock) {
+      const rewards = createOutputTransaction(rpcData.superblock[i].amount, rpcData.superblock[i].payee, rewardToPool, reward, txOutputBuffers);
+      reward        = rewards.reward;
+      rewardToPool  = rewards.rewardToPool;
+    }
+  }
+
+  if (rpcData.founder_payments_started && rpcData.founder) {
+    const founderReward = rpcData.founder.amount || 0;
+    const rewards = createOutputTransaction(founderReward, rpcData.founder.payee, rewardToPool, reward, txOutputBuffers);
+    reward        = rewards.reward;
+    rewardToPool  = rewards.rewardToPool;
+  }
+
+  createOutputTransaction(rewardToPool, null, rewardToPool, reward, txOutputBuffers, Buffer.from(addressToScript(poolAddress), "hex"));
+
+  if (rpcData.default_witness_commitment !== undefined) {
+    const witness_commitment = Buffer.from(rpcData.default_witness_commitment, 'hex');
+    txOutputBuffers.unshift(Buffer.concat([
+      packInt64LE(0),
+      varIntBuffer(witness_commitment.length),
+      witness_commitment
+    ]));
+  }
+
+  return Buffer.concat([ varIntBuffer(txOutputBuffers.length), Buffer.concat(txOutputBuffers)]);
+}
+
+module.exports.RtmBlockTemplate = function(rpcData, poolAddress) {
+  const extraNoncePlaceholderLength = 17;
+  const coinbaseVersion = Buffer.concat([packUInt16LE(3), packUInt16LE(5)]);
+
+  const scriptSigPart1 = Buffer.concat([
+    serializeNumber(rpcData.height),
+    Buffer.from(rpcData.coinbaseaux.flags, 'hex'),
+    serializeNumber(Date.now() / 1000 | 0),
+    Buffer.from([extraNoncePlaceholderLength])
+  ]);
+
+  const scriptSigPart2 = serializeString('/nodeStratum/');
+
+  const blob1 = Buffer.concat([
+    coinbaseVersion,
+    // transaction input
+    varIntBuffer(1), // txInputsCount
+    uint256BufferFromHash(""), // txInPrevOutHash
+    packUInt32LE(Math.pow(2, 32) - 1), // txInPrevOutIndex
+    varIntBuffer(scriptSigPart1.length + extraNoncePlaceholderLength + scriptSigPart2.length),
+    scriptSigPart1
+  ]);
+
+  let blob2 = Buffer.concat([
+    scriptSigPart2,
+    packUInt32LE(0), // txInSequence
+    // end transaction input
+    // transaction output
+    generateOutputTransactions(rpcData, poolAddress),
+    // end transaction ouput
+    packUInt32LE(0), // txLockTime
+    varIntBuffer(rpcData.coinbase_payload.length / 2),
+    Buffer.from(rpcData.coinbase_payload, 'hex')
+  ]);
+
+  const prev_hash = reverseBuffer(Buffer.from(rpcData.previousblockhash, 'hex')).toString('hex');
+  const version = packInt32LE(rpcData.version).toString('hex');
+  const curtime = packUInt32LE(rpcData.curtime).toString('hex');
+  let bits = Buffer.from(rpcData.bits, 'hex');
+  bits.writeUInt32LE(bits.readUInt32BE());
+  let txs = [];
+  // skip version 1 transaction because they contain some OP_RETURN(0x6A) opcode in the beginning of
+  // tx input scripts instead of size of script part so not sure how to parse them
+  // just drop them for now
+  // example: https://explorer.raptoreum.com/tx/1461d70fa8362b0896e2e9be6312521f2684f22c9b0f9152695f33f67d9f9d3f
+  rpcData.transactions.forEach(function(tx, i) {
+    if (tx.version != 1) {
+      try {
+        bitcoin.Transaction.fromBuffer(Buffer.from(tx.data, 'hex'), true, i == 0);
+      } catch(err) {
+        console.error("Skip RTM tx due to parse error: " + tx.data);
+        return; // skip transaction if it is not parsed OK (varint coding seems to be different for RTM)
+      }
+      tx.push(tx);
+    } else {
+      console.error("Skip RTM v1 tx: " + tx.data);
+    }
+  });
+  const txn = varIntBuffer(txs.length + 1);
+
+  return {
+    difficulty:         parseFloat((diff1 / bignum(rpcData.target, 16).toNumber()).toFixed(9)),
+    height:             rpcData.height,
+    prev_hash:          prev_hash,
+    blocktemplate_blob: version + prev_hash + Buffer.alloc(32, 0).toString('hex') + curtime + bits.toString('hex') + Buffer.alloc(4, 0).toString('hex') +
+                        txn.toString('hex') + blob1.toString('hex') + Buffer.alloc(extraNoncePlaceholderLength, 0xCC).toString('hex') + blob2.toString('hex')  +
+                        Buffer.concat(txs.map(function(tx) { return Buffer.from(tx.data, 'hex'); })).toString('hex'),
+    reserved_offset:    80 + txn.length + blob1.length
+  }
+}

src/cryptonote_config.h

@@ -1,10 +1,21 @@
 #pragma once
 
 #define CURRENT_TRANSACTION_VERSION  1
+#define POU_TRANSACTION_VERSION      6
 #define OFFSHORE_TRANSACTION_VERSION 3
 #define HF_VERSION_XASSET_FEES_V2    17
 #define HF_VERSION_HAVEN2            18
 
+// UNLOCK TIMES
+#define TX_V6_OFFSHORE_UNLOCK_BLOCKS                    21*720  // 21 day unlock time
+#define TX_V6_ONSHORE_UNLOCK_BLOCKS                     360     // 12 hour unlock time
+#define TX_V6_XASSET_UNLOCK_BLOCKS                      1440    // 2 day unlock time
+#define TX_V6_OFFSHORE_UNLOCK_BLOCKS_TESTNET            60     // 2 hour unlock time - FOR TESTING ONLY
+#define TX_V6_ONSHORE_UNLOCK_BLOCKS_TESTNET             30     // 1 hour unlock time - FOR TESTING ONLY
+#define TX_V6_XASSET_UNLOCK_BLOCKS_TESTNET              60     // 2 hour unlock time - FOR TESTING ONLY
+
+#define PRICING_RECORD_VALID_TIME_DIFF_FROM_BLOCK       120  // seconds
+
 enum BLOB_TYPE {
   BLOB_TYPE_CRYPTONOTE        = 0,
   BLOB_TYPE_FORKNOTE1         = 1,

src/cryptonote_core/cryptonote_basic.h

@@ -258,7 +258,8 @@ namespace cryptonote
         if (version == loki_version_3_per_output_unlock_times)
           FIELD(is_deregister)
       }
-      VARINT_FIELD(unlock_time)
+      if (blob_type != BLOB_TYPE_CRYPTONOTE_XHV || version < POU_TRANSACTION_VERSION)
+        VARINT_FIELD(unlock_time)
       FIELD(vin)
       FIELD(vout)
       if (blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC)
@@ -275,6 +276,11 @@ namespace cryptonote
         VARINT_FIELD(pricing_record_height)
         if (version < 5)
           FIELD(offshore_data)
+        if (version >= POU_TRANSACTION_VERSION)
+        {
+          FIELD(output_unlock_times)
+        }
+        if (version >= POU_TRANSACTION_VERSION && vout.size() != output_unlock_times.size()) return false;
         VARINT_FIELD(amount_burnt)
         VARINT_FIELD(amount_minted)
       }
@@ -389,6 +395,7 @@ namespace cryptonote
     offshore_data.clear();
     amount_burnt = 0;
     amount_minted = 0;
+    output_unlock_times.clear();
   }
 
   inline

src/cryptonote_core/cryptonote_format_utils.cpp

@@ -89,6 +89,7 @@ namespace cryptonote
     {
       // This is the correct way to get the fee for Haven, because outs may be in different currencies to ins
       switch (tx.version) {
+      case 6:
       case 5:
         fee = tx.rct_signatures.txnFee + tx.rct_signatures.txnOffshoreFee;
         break;
@@ -282,6 +283,10 @@ namespace cryptonote
   //-----------------------------------------------------------------------------------------------
   bool check_outs_valid(const transaction& tx)
   {
+    if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV && tx.version >= POU_TRANSACTION_VERSION)
+    {
+      CHECK_AND_ASSERT_MES(tx.vout.size() == tx.output_unlock_times.size(), false, "tx version 6+ must have equal number of output unlock times and outputs");
+    }
     BOOST_FOREACH(const tx_out& out, tx.vout)
     {
       if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {

src/offshore/pricing_record.cpp

@@ -33,10 +33,6 @@
 #include "storages/portable_storage.h"
 
 #include "string_tools.h"
-
-#define PRICING_RECORD_VALID_BLOCKS                     10
-#define PRICING_RECORD_VALID_TIME_DIFF_FROM_BLOCK       120  // seconds
-
 namespace offshore
 {
 
@@ -262,27 +258,8 @@ namespace offshore
     return (*this).equal(empty_pr);
   }
 
-  bool pricing_record::verifySignature() const 
+  bool pricing_record::verifySignature(const std::string& public_key) const 
   {
-    // Oracle public keys
-    std::string const mainnet_public_key = "-----BEGIN PUBLIC KEY-----\n"
-      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5YBxWx1AZCA9jTUk8Pr2uZ9jpfRt\n"
-      "KWv3Vo1/Gny+1vfaxsXhBQiG1KlHkafNGarzoL0WHW4ocqaaqF5iv8i35A==\n"
-      "-----END PUBLIC KEY-----\n";
-    std::string const testnet_public_key = "-----BEGIN PUBLIC KEY-----\n"
-      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtWqvQh7OdXrdgXcDeBMRVfLWTW3F\n"
-      "wByeoVJFBfZymScJIJl46j66xG6ngnyj4ai4/QPFnSZ1I9jjMRlTWC4EPA==\n"
-      "-----END PUBLIC KEY-----\n";
-    std::string const stagenet_public_key = "-----BEGIN PUBLIC KEY-----\n"
-      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtWqvQh7OdXrdgXcDeBMRVfLWTW3F\n"
-      "wByeoVJFBfZymScJIJl46j66xG6ngnyj4ai4/QPFnSZ1I9jjMRlTWC4EPA==\n"
-      "-----END PUBLIC KEY-----\n";
-
-    // Comment out all but 1 of the following lines to select the correct Oracle PK
-    std::string const public_key = mainnet_public_key;
-    //std::string const public_key = testnet_public_key;
-    //std::string const public_key = stagenet_public_key;
-    
     CHECK_AND_ASSERT_THROW_MES(!public_key.empty(), "Pricing record verification failed. NULL public key. PK Size: " << public_key.size()); // TODO: is this necessary or the one below already covers this case, meannin it will produce empty pubkey?
     
     // extract the key
@@ -432,8 +409,27 @@ namespace offshore
       }
     }
 
+    // Oracle public keys
+    std::string const mainnet_public_key = "-----BEGIN PUBLIC KEY-----\n"
+      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5YBxWx1AZCA9jTUk8Pr2uZ9jpfRt\n"
+      "KWv3Vo1/Gny+1vfaxsXhBQiG1KlHkafNGarzoL0WHW4ocqaaqF5iv8i35A==\n"
+      "-----END PUBLIC KEY-----\n";
+    std::string const testnet_public_key = "-----BEGIN PUBLIC KEY-----\n"
+      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtWqvQh7OdXrdgXcDeBMRVfLWTW3F\n"
+      "wByeoVJFBfZymScJIJl46j66xG6ngnyj4ai4/QPFnSZ1I9jjMRlTWC4EPA==\n"
+      "-----END PUBLIC KEY-----\n";
+    std::string const stagenet_public_key = "-----BEGIN PUBLIC KEY-----\n"
+      "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEtWqvQh7OdXrdgXcDeBMRVfLWTW3F\n"
+      "wByeoVJFBfZymScJIJl46j66xG6ngnyj4ai4/QPFnSZ1I9jjMRlTWC4EPA==\n"
+      "-----END PUBLIC KEY-----\n";
+    
+    // Comment out all but 1 of the following lines to select the correct Oracle PK
+    std::string const public_key = mainnet_public_key;
+    //std::string const public_key = testnet_public_key;
+    //std::string const public_key = stagenet_public_key;
+
     // verify the signature
-    if (!verifySignature()) {
+    if (!verifySignature(public_key)) {
       LOG_ERROR("Invalid pricing record signature.");
       return false;
     }
@@ -453,4 +449,4 @@ namespace offshore
     return true;
   }
 
-}
+}

src/offshore/pricing_record.h

@@ -116,7 +116,7 @@ namespace offshore
       void set_for_height_821428();
       bool equal(const pricing_record& other) const noexcept;
       bool empty() const noexcept;
-      bool verifySignature() const;
+      bool verifySignature(const std::string& public_key) const;
       bool valid(uint32_t hf_version, uint64_t bl_timestamp, uint64_t last_bl_timestamp) const;
 
       pricing_record& operator=(const pricing_record& orig) noexcept;