Added ZEPH update support

index.js

@@ -46,10 +46,28 @@ function hash256(buffer) {
   return sha256(sha256(buffer));
 };
 
-function getMerkleRoot(transactions) {
+function sha256_3(buffer) {
+  return crypto.createHash('sha3-256').update(buffer).digest();
+};
+
+function hash256_3(buffer) {
+  return sha256_3(sha256_3(buffer));
+};
+
+function transaction_hash(transaction, forWitness) {
+  if (forWitness && transaction.isCoinbase()) return Buffer.alloc(32, 0);
+  return hash256(transaction.__toBuffer(undefined, undefined, forWitness));
+}
+
+function transaction_hash3(transaction, forWitness) {
+  if (forWitness && transaction.isCoinbase()) return Buffer.alloc(32, 0);
+  return hash256_3(transaction.__toBuffer(undefined, undefined, forWitness));
+}
+
+function getMerkleRoot(transactions, transaction_hash_func, detectWitness) {
   if (transactions.length === 0) return Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
-  const forWitness = txesHaveWitnessCommit(transactions);
-  const hashes = transactions.map(transaction => transaction.getHash(forWitness));
+  const forWitness = detectWitness ? txesHaveWitnessCommit(transactions) : false;
+  const hashes = transactions.map(transaction => transaction_hash_func(transaction, forWitness));
   const rootHash = fastMerkleRoot(hashes, hash256);
   return forWitness ? hash256(Buffer.concat([rootHash, transactions[0].ins[0].witness[0]])) : rootHash;
 }
@@ -157,7 +175,7 @@ module.exports.RavenBlockTemplate = function(rpcData, poolAddress) {
   };
 };
 
-function update_merkle_root_hash(offset, payload, blob_in, blob_out) {
+function update_merkle_root_hash(offset, payload, blob_in, blob_out, transaction_hash_func, detectWitness) {
   const nTransactions = varuint.decode(blob_in, offset);
   offset += varuint.decode.bytes;
   let transactions = [];
@@ -166,21 +184,25 @@ function update_merkle_root_hash(offset, payload, blob_in, blob_out) {
     transactions.push(tx);
     offset += tx.byteLength();
   }
-  getMerkleRoot(transactions).copy(blob_out, 4 + 32);
+  getMerkleRoot(transactions, transaction_hash_func, detectWitness).copy(blob_out, 4 + 32);
 };
 
 module.exports.blockHashBuff = function(blobBuffer) {
   return reverseBuffer(hash256(blobBuffer));
 };
 
+module.exports.blockHashBuff3 = function(blobBuffer) {
+  return reverseBuffer(hash256_3(blobBuffer));
+};
+
 module.exports.convertRavenBlob = function(blobBuffer) {
   let header = blobBuffer.slice(0, 80);
-  update_merkle_root_hash(80 + 8 + 32, false, blobBuffer, header);
+  update_merkle_root_hash(80 + 8 + 32, false, blobBuffer, header, transaction_hash, true);
   return module.exports.blockHashBuff(header);
 };
 
 module.exports.constructNewRavenBlob = function(blockTemplate, nonceBuff, mixhashBuff) {
-  update_merkle_root_hash(80 + 8 + 32, false, blockTemplate, blockTemplate);
+  update_merkle_root_hash(80 + 8 + 32, false, blockTemplate, blockTemplate, transaction_hash, true);
   nonceBuff.copy  (blockTemplate, 80, 0, 8);
   mixhashBuff.copy(blockTemplate, 88, 0, 32);
   return blockTemplate;
@@ -217,12 +239,24 @@ module.exports.RtmBlockTemplate = function(rpcData, poolAddress) {
 
 module.exports.convertRtmBlob = function(blobBuffer) {
   let header = blobBuffer.slice(0, 80);
-  update_merkle_root_hash(80, true, blobBuffer, header);
+  update_merkle_root_hash(80, true, blobBuffer, header, transaction_hash, true);
+  return header;
+};
+
+module.exports.convertKcnBlob = function(blobBuffer) {
+  let header = blobBuffer.slice(0, 80);
+  update_merkle_root_hash(80, false, blobBuffer, header, transaction_hash3, false);
   return header;
 };
 
 module.exports.constructNewRtmBlob = function(blockTemplate, nonceBuff) {
-  update_merkle_root_hash(80, true, blockTemplate, blockTemplate);
+  update_merkle_root_hash(80, true, blockTemplate, blockTemplate, transaction_hash, true);
+  nonceBuff.copy(blockTemplate, 76, 0, 4);
+  return blockTemplate;
+};
+
+module.exports.constructNewKcnBlob = function(blockTemplate, nonceBuff) {
+  update_merkle_root_hash(80, false, blockTemplate, blockTemplate, transaction_hash3, false);
   nonceBuff.copy(blockTemplate, 76, 0, 4);
   return blockTemplate;
 };

package.json

@@ -1,7 +1,6 @@
 {
   "name": "cryptoforknote-util",
-  "version": "15.2.1",
-  "main": "cryptoforknote-util",
+  "version": "15.4.0",
   "author": {
     "name": "LucasJones",
     "email": "lucasjonesdev@hotmail.co.uk"
@@ -17,6 +16,7 @@
     "bignum": "^0.13.1",
     "sha3": "*",
     "base58-native": "*",
+    "bech32": "*",
     "varuint-bitcoin": "^1.0.4",
     "merkle-lib": "^2.0.10",
     "bitcoinjs-lib": "git+https://github.com/MoneroOcean/bitcoinjs-lib.git"

rtm.js

@@ -1,5 +1,6 @@
 const bignum  = require('bignum');
 const base58  = require('base58-native');
+const bech32  = require('bech32');
 const bitcoin = require('bitcoinjs-lib');
 
 const diff1 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
@@ -148,14 +149,20 @@ function getTransactionBuffers(txs) {
 }
 
 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);
+  let decoded;
+  try {
+    decoded = base58.decode(addr);
+  } catch(err) {}
+  if (!decoded || decoded.length != 25) {
+    const decoded2 = Buffer.from(bech32.bech32.fromWords(bech32.bech32.decode(addr).words.slice(1)));
+    if (decoded2.length != 20) throw new Error('Invalid address ' + addr);
+    return Buffer.concat([Buffer.from([0x0, 0x14]), decoded2]);
+  }
   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) {
+function createTransactionOutput(amount, payee, rewardToPool, reward, txOutputBuffers, payeeScript) {
   const payeeReward = amount;
   if (!payeeScript) payeeScript = addressToScript(payee);
   txOutputBuffers.push(Buffer.concat([
@@ -166,19 +173,25 @@ function createOutputTransaction(amount, payee, rewardToPool, reward, txOutputBu
   return { reward: reward - amount, rewardToPool: rewardToPool - amount };
 }
 
-function generateOutputTransactions(rpcData, poolAddress) {
-  let reward       = rpcData.coinbasevalue;
+function generateTransactionOutputs(rpcData, poolAddress) {
+  let reward       = rpcData.coinbasevalue + (rpcData.coinbasedevreward ? rpcData.coinbasedevreward.value : 0);
   let rewardToPool = reward;
   let txOutputBuffers = [];
 
+  if (rpcData.coinbasedevreward) {
+    const rewards = createTransactionOutput(rpcData.coinbasedevreward.value, null, rewardToPool, reward, txOutputBuffers, Buffer.from(rpcData.coinbasedevreward.scriptpubkey, 'hex'));
+    reward        = rewards.reward;
+    rewardToPool  = rewards.rewardToPool;
+  }
+
   if (rpcData.smartnode) {
     if (rpcData.smartnode.payee) {
-      const rewards = createOutputTransaction(rpcData.smartnode.amount, rpcData.smartnode.payee, rewardToPool, reward, txOutputBuffers);
+      const rewards = createTransactionOutput(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);
+        const rewards = createTransactionOutput(rpcData.smartnode[i].amount, rpcData.smartnode[i].payee, rewardToPool, reward, txOutputBuffers);
 	reward        = rewards.reward;
         rewardToPool  = rewards.rewardToPool;
       }
@@ -187,7 +200,7 @@ function generateOutputTransactions(rpcData, poolAddress) {
 
   if (rpcData.superblock) {
     for (let i in rpcData.superblock) {
-      const rewards = createOutputTransaction(rpcData.superblock[i].amount, rpcData.superblock[i].payee, rewardToPool, reward, txOutputBuffers);
+      const rewards = createTransactionOutput(rpcData.superblock[i].amount, rpcData.superblock[i].payee, rewardToPool, reward, txOutputBuffers);
       reward        = rewards.reward;
       rewardToPool  = rewards.rewardToPool;
     }
@@ -195,41 +208,44 @@ function generateOutputTransactions(rpcData, poolAddress) {
 
   if (rpcData.founder_payments_started && rpcData.founder) {
     const founderReward = rpcData.founder.amount || 0;
-    const rewards = createOutputTransaction(founderReward, rpcData.founder.payee, rewardToPool, reward, txOutputBuffers);
+    const rewards = createTransactionOutput(founderReward, rpcData.founder.payee, rewardToPool, reward, txOutputBuffers);
     reward        = rewards.reward;
     rewardToPool  = rewards.rewardToPool;
   }
 
-  createOutputTransaction(rewardToPool, null, rewardToPool, reward, txOutputBuffers, Buffer.from(addressToScript(poolAddress), "hex"));
+  createTransactionOutput(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
+  if (rpcData.default_witness_commitment) {
+    createTransactionOutput(0, null, rewardToPool, reward, txOutputBuffers, Buffer.from(rpcData.default_witness_commitment, 'hex'));
+    txOutputBuffers.push(Buffer.concat([
+      varIntBuffer(1),
+      varIntBuffer(32),
+      Buffer.alloc(32, 0)
     ]));
   }
 
-  return Buffer.concat([ varIntBuffer(txOutputBuffers.length), Buffer.concat(txOutputBuffers)]);
+  return Buffer.concat([ varIntBuffer(rpcData.default_witness_commitment ? txOutputBuffers.length - 1 : txOutputBuffers.length), Buffer.concat(txOutputBuffers)]);
 }
 
 module.exports.RtmBlockTemplate = function(rpcData, poolAddress) {
   const extraNoncePlaceholderLength = 17;
-  const coinbaseVersion = Buffer.concat([packUInt16LE(3), packUInt16LE(5)]);
+  const coinbaseVersion = rpcData.coinbasedevreward ? Buffer.concat([packUInt16LE(1), packUInt16LE(0)]) : Buffer.concat([packUInt16LE(3), packUInt16LE(5)]);
 
   const scriptSigPart1 = Buffer.concat([
     serializeNumber(rpcData.height),
-    Buffer.from(rpcData.coinbaseaux.flags, 'hex'),
+    Buffer.from(rpcData.coinbaseaux.flags ? rpcData.coinbaseaux.flags : "", 'hex'),
     serializeNumber(Date.now() / 1000 | 0),
     Buffer.from([extraNoncePlaceholderLength])
   ]);
 
   const scriptSigPart2 = serializeString('/nodeStratum/');
 
+  const is_witness = rpcData.default_witness_commitment !== undefined;
+
   const blob1 = Buffer.concat([
     coinbaseVersion,
     // transaction input
+    Buffer.from(is_witness ? "0001" : "", 'hex'),
     varIntBuffer(1), // txInputsCount
     uint256BufferFromHash(""), // txInPrevOutHash
     packUInt32LE(Math.pow(2, 32) - 1), // txInPrevOutIndex
@@ -242,13 +258,19 @@ module.exports.RtmBlockTemplate = function(rpcData, poolAddress) {
     packUInt32LE(0), // txInSequence
     // end transaction input
     // transaction output
-    generateOutputTransactions(rpcData, poolAddress),
+    generateTransactionOutputs(rpcData, poolAddress, is_witness),
     // end transaction ouput
-    packUInt32LE(0), // txLockTime
-    varIntBuffer(rpcData.coinbase_payload.length / 2),
-    Buffer.from(rpcData.coinbase_payload, 'hex')
+    packUInt32LE(0) // txLockTime
   ]);
 
+  if (rpcData.coinbase_payload) {
+     blob2 = Buffer.concat([
+       blob2,
+       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');

src/cryptonote_core/cryptonote_basic.h

@@ -958,10 +958,24 @@ namespace cryptonote
       if (blob_type == BLOB_TYPE_CRYPTONOTE_XTA) FIELD(cycle48)
       if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV) FIELD(pricing_record)
       if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR) {
-        if (major_version >= 3)
+        if (major_version >= 4)
         {
           FIELD_N("pricing_record", zephyr_pricing_record)
         }
+        else if (major_version >= 3)
+        {
+          zephyr_oracle::pricing_record_v2 pr_v2;
+          if (!typename Archive<W>::is_saving())
+          {
+            FIELD(pr_v2)
+            pr_v2.write_to_pr(zephyr_pricing_record);
+          }
+          else
+          {
+            pr_v2.read_from_pr(zephyr_pricing_record);
+            FIELD(pr_v2)
+          }
+        }
         else
         {
           zephyr_oracle::pricing_record_v1 pr_v1;

src/serialization/zephyr_pricing_record.h

@@ -40,7 +40,33 @@
 template <template <bool> class Archive>
 bool do_serialize(Archive<false> &ar, zephyr_oracle::pricing_record &pr, uint8_t version)
 {
-  if (version < 3)
+  if (version >= 4)
+  {
+    // very basic sanity check
+    if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record)) {
+      return false;
+    }
+
+    ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record), "");
+    if (!ar.good())
+      return false;
+  }
+  else if (version >= 3)
+  {
+    // very basic sanity check
+    if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record_v2)) {
+      return false;
+    }
+
+    zephyr_oracle::pricing_record_v2 pr_v2;
+    ar.serialize_blob(&pr_v2, sizeof(zephyr_oracle::pricing_record_v2), "");
+    if (!ar.good())
+      return false;
+
+    if (!pr_v2.write_to_pr(pr))
+      return false;
+  }
+  else
   {
     // very basic sanity check
     if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record_v1)) {
@@ -55,17 +81,6 @@ bool do_serialize(Archive<false> &ar, zephyr_oracle::pricing_record &pr, uint8_t
     if (!pr_v1.write_to_pr(pr))
       return false;
   }
-  else
-  {
-    // very basic sanity check
-    if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record)) {
-      return false;
-    }
-
-    ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record), "");
-    if (!ar.good())
-      return false;
-  }
 
   return true;
 }
@@ -76,17 +91,24 @@ bool do_serialize(Archive<true> &ar, zephyr_oracle::pricing_record &pr, uint8_t
 {
   ar.begin_string();
 
-  if (version < 3)
+  if (version >= 4)
+  {
+    ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record), "");
+  }
+  else if (version >= 3)
+  {
+    zephyr_oracle::pricing_record_v2 pr_v2;
+    if (!pr_v2.read_from_pr(pr))
+      return false;
+    ar.serialize_blob(&pr_v2, sizeof(zephyr_oracle::pricing_record_v2), "");
+  }
+  else
   {
     zephyr_oracle::pricing_record_v1 pr_v1;
     if (!pr_v1.read_from_pr(pr))
       return false;
     ar.serialize_blob(&pr_v1, sizeof(zephyr_oracle::pricing_record_v1), "");
   }
-  else
-  {
-    ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record), "");
-  }
 
   if (!ar.good())
     return false;
@@ -122,5 +144,34 @@ bool do_serialize(Archive<true> &ar, zephyr_oracle::pricing_record_v1 &pr, uint8
   return true;
 }
 
+// read
+template <template <bool> class Archive>
+bool do_serialize(Archive<false> &ar, zephyr_oracle::pricing_record_v2 &pr, uint8_t version)
+{
+  // very basic sanity check
+  if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record_v2)) {
+    return false;
+  }
+
+  ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record_v2), "");
+  if (!ar.good())
+    return false;
+
+  return true;
+}
+
+// write
+template <template <bool> class Archive>
+bool do_serialize(Archive<true> &ar, zephyr_oracle::pricing_record_v2 &pr, uint8_t version)
+{
+  ar.begin_string();
+  ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record_v2), "");
+  if (!ar.good())
+    return false;
+  ar.end_string();
+  return true;
+}
+
 BLOB_SERIALIZER(zephyr_oracle::pricing_record);
 BLOB_SERIALIZER(zephyr_oracle::pricing_record_v1);
+BLOB_SERIALIZER(zephyr_oracle::pricing_record_v2);

src/zephyr_oracle/pricing_record.cpp

@@ -46,6 +46,8 @@ namespace zephyr_oracle
       uint64_t stable_ma;
       uint64_t reserve;
       uint64_t reserve_ma;
+      uint64_t reserve_ratio;
+      uint64_t reserve_ratio_ma;
       uint64_t timestamp;
       std::string signature;
 
@@ -56,6 +58,8 @@ namespace zephyr_oracle
         KV_SERIALIZE(stable_ma)
         KV_SERIALIZE(reserve)
         KV_SERIALIZE(reserve_ma)
+        KV_SERIALIZE(reserve_ratio)
+        KV_SERIALIZE(reserve_ratio_ma)
         KV_SERIALIZE(timestamp)
         KV_SERIALIZE(signature)
       END_KV_SERIALIZE_MAP()
@@ -69,6 +73,8 @@ namespace zephyr_oracle
     , stable_ma(0)
     , reserve(0)
     , reserve_ma(0)
+    , reserve_ratio(0)
+    , reserve_ratio_ma(0)
     , timestamp(0)
   {
     std::memset(signature, 0, sizeof(signature));
@@ -86,6 +92,8 @@ namespace zephyr_oracle
       stable_ma = in.stable_ma;
       reserve = in.reserve;
       reserve_ma = in.reserve_ma;
+      reserve_ratio = in.reserve_ratio;
+      reserve_ratio_ma = in.reserve_ratio_ma;
       timestamp = in.timestamp;
       for (unsigned int i = 0; i < in.signature.length(); i += 2) {
         std::string byteString = in.signature.substr(i, 2);
@@ -106,7 +114,7 @@ namespace zephyr_oracle
       ss << std::hex << std::setw(2) << std::setfill('0') << (0xff & signature[i]);
       sig_hex += ss.str();
     }
-    const pr_serialized out{spot,moving_average,stable,stable_ma,reserve,reserve_ma,timestamp,sig_hex};
+    const pr_serialized out{spot,moving_average,stable,stable_ma,reserve,reserve_ma,reserve_ratio,reserve_ratio_ma,timestamp,sig_hex};
     return out.store(dest, hparent);
   }
 
@@ -117,6 +125,8 @@ namespace zephyr_oracle
     , stable_ma(orig.stable_ma)
     , reserve(orig.reserve)
     , reserve_ma(orig.reserve_ma)
+    , reserve_ratio(orig.reserve_ratio)
+    , reserve_ratio_ma(orig.reserve_ratio_ma)
     , timestamp(orig.timestamp)
   {
     std::memcpy(signature, orig.signature, sizeof(signature));
@@ -130,6 +140,8 @@ namespace zephyr_oracle
     stable_ma = orig.stable_ma;
     reserve = orig.reserve;
     reserve_ma = orig.reserve_ma;
+    reserve_ratio = orig.reserve_ratio;
+    reserve_ratio_ma = orig.reserve_ratio_ma;
     timestamp = orig.timestamp;
     ::memcpy(signature, orig.signature, sizeof(signature));
     return *this;
@@ -143,6 +155,8 @@ namespace zephyr_oracle
       (stable_ma == other.stable_ma) &&
       (reserve == other.reserve) &&
       (reserve_ma == other.reserve_ma) &&
+      (reserve_ratio == other.reserve_ratio) &&
+      (reserve_ratio_ma == other.reserve_ratio_ma) &&
 	    (timestamp == other.timestamp) &&
       !::memcmp(signature, other.signature, sizeof(signature)));
   }
@@ -153,7 +167,7 @@ namespace zephyr_oracle
     return (*this).equal(empty_pr);
   }
 
-  bool pricing_record::verifySignature(const std::string& public_key) const
+  bool pricing_record::verifySignature(const std::string& public_key, const uint8_t hf_version) const
   {
     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?
 
@@ -178,7 +192,9 @@ namespace zephyr_oracle
     // Build the JSON string, so that we can verify the signature
     std::ostringstream oss;
     oss << "{\"spot\":" << spot;
-    oss << ",\"moving_average\":" << moving_average;
+    if (hf_version <= 4) {
+      oss << ",\"moving_average\":" << moving_average;
+    }
     oss << ",\"timestamp\":" << timestamp;
     oss << "}";
     std::string message = oss.str();
@@ -210,9 +226,24 @@ namespace zephyr_oracle
     return false;
   }
 
-  bool pricing_record::has_missing_rates() const noexcept
+  bool pricing_record::has_missing_rates(const uint8_t hf_version) const noexcept
   {
-    return (spot == 0) || (moving_average == 0) || (stable == 0) || (stable_ma == 0) || (reserve == 0) || (reserve_ma == 0);
+    bool missing_rates = (spot == 0) || (moving_average == 0) || (stable == 0) || (stable_ma == 0) || (reserve == 0) || (reserve_ma == 0);
+    if (hf_version <= 3) {
+      return missing_rates;
+    } else if (hf_version <= 4) {
+      return missing_rates || (reserve_ratio == 0);
+    }
+    return missing_rates || (reserve_ratio == 0) || (reserve_ratio_ma == 0);
+  }
+
+  bool pricing_record::has_essential_rates(const uint8_t hf_version) const noexcept
+  {
+    bool essential_rates = (spot != 0) && (stable != 0) && (reserve != 0);
+    if (hf_version <= 3) {
+      return essential_rates;
+    }
+    return essential_rates && (reserve_ratio != 0);
   }
 
   // overload for pr validation for block
@@ -226,9 +257,11 @@ namespace zephyr_oracle
     if (this->empty())
         return true;
 
-    if (this->has_missing_rates()) {
-      LOG_ERROR("Pricing record has missing rates.");
-      return false;
+    if (this->has_missing_rates(hf_version)) {
+      if (hf_version < 4 || !this->has_essential_rates(hf_version)) {
+        LOG_ERROR("Pricing record has missing rates.");
+        return false;
+      }
     }
 
     std::string const MAINNET_ORACLE_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\n"
@@ -236,7 +269,7 @@ namespace zephyr_oracle
     "edsUmhQeYwBkelAaFyxhX4ZotP+b/cFr2mX5iuND1znEnMZkyg+YmtkCAwEAAQ==\n"
     "-----END PUBLIC KEY-----\n";
 
-    if (!verifySignature(MAINNET_ORACLE_PUBLIC_KEY)) {
+    if (!verifySignature(MAINNET_ORACLE_PUBLIC_KEY, hf_version)) {
       LOG_ERROR("Invalid pricing record signature.");
       return false;
     }

src/zephyr_oracle/pricing_record.h

@@ -63,6 +63,16 @@ namespace zephyr_oracle
     uint64_t zEPHRSV;
     uint64_t timestamp;
   };
+  POD_CLASS pricing_record_pre_v2 {
+    uint64_t spot;
+    uint64_t moving_average;
+    uint64_t stable;
+    uint64_t stable_ma;
+    uint64_t reserve;
+    uint64_t reserve_ma;
+    uint64_t timestamp;
+    unsigned char signature[64];
+  };
   #pragma pack(pop)
   class pricing_record
   {
@@ -76,6 +86,8 @@ namespace zephyr_oracle
       uint64_t stable_ma;
       uint64_t reserve;
       uint64_t reserve_ma;
+      uint64_t reserve_ratio;
+      uint64_t reserve_ratio_ma;
       uint64_t timestamp;
       unsigned char signature[64];
 
@@ -89,8 +101,9 @@ namespace zephyr_oracle
       ~pricing_record() = default;
       bool equal(const pricing_record& other) const noexcept;
       bool empty() const noexcept;
-      bool verifySignature(const std::string& public_key) const;
-      bool has_missing_rates() const noexcept;
+      bool verifySignature(const std::string& public_key, const uint8_t hf_version) const;
+      bool has_missing_rates(const uint8_t hf_version) const noexcept;
+      bool has_essential_rates(const uint8_t hf_version) const noexcept;
       bool valid(uint32_t hf_version, uint64_t bl_timestamp, uint64_t last_bl_timestamp) const;
 
       pricing_record& operator=(const pricing_record& orig) noexcept;
@@ -137,4 +150,46 @@ namespace zephyr_oracle
     };
   };
 
+  class pricing_record_v2
+  {
+
+  public:
+    uint64_t spot;
+    uint64_t moving_average;
+    uint64_t stable;
+    uint64_t stable_ma;
+    uint64_t reserve;
+    uint64_t reserve_ma;
+    uint64_t timestamp;
+    unsigned char signature[64];
+
+    bool write_to_pr(zephyr_oracle::pricing_record &pr)
+    {
+      pr.spot = spot;
+      pr.moving_average = moving_average;
+      pr.stable = stable;
+      pr.stable_ma = stable_ma;
+      pr.reserve = reserve;
+      pr.reserve_ma = reserve_ma;
+      pr.reserve_ratio = 0;
+      pr.reserve_ratio_ma = 0;
+      pr.timestamp = timestamp;
+      std::memcpy(pr.signature, signature, sizeof(pr.signature));
+      return true;
+    };
+
+    bool read_from_pr(zephyr_oracle::pricing_record &pr)
+    {
+      spot = pr.spot;
+      moving_average = pr.moving_average;
+      stable = pr.stable;
+      stable_ma = pr.stable_ma;
+      reserve = pr.reserve;
+      reserve_ma = pr.reserve_ma;
+      timestamp = pr.timestamp;
+      std::memcpy(signature, pr.signature, sizeof(signature));
+      return true;
+    };
+  };
+
 } // oracle