Added SAL support

binding.gyp

@@ -6,6 +6,7 @@
                 "src/main.cc",
                 "src/cryptonote_core/cryptonote_format_utils.cpp",
                 "src/offshore/pricing_record.cpp",
+                "src/zephyr_oracle/pricing_record.cpp",
                 "src/crypto/tree-hash.c",
                 "src/crypto/crypto.cpp",
                 "src/crypto/crypto-ops.c",
@@ -30,7 +31,7 @@
                 "-fno-exceptions -std=gnu11 -march=native -fPIC -DNDEBUG -Ofast -funroll-loops -fvariable-expansion-in-unroller -ftree-loop-if-convert-stores -fmerge-all-constants -fbranch-target-load-optimize2"
             ],
             "cflags_cc": [
-                "-fexceptions -frtti -std=gnu++11 -march=native -fPIC -DNDEBUG -Ofast -s -funroll-loops -fvariable-expansion-in-unroller -ftree-loop-if-convert-stores -fmerge-all-constants -fbranch-target-load-optimize2"
+                "-fexceptions -frtti -std=c++17 -march=native -fPIC -DNDEBUG -Ofast -s -funroll-loops -fvariable-expansion-in-unroller -ftree-loop-if-convert-stores -fmerge-all-constants -fbranch-target-load-optimize2"
             ],
             "xcode_settings": {
                 "OTHER_CFLAGS": [ "-fexceptions -frtti" ]

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;
 }
@@ -92,6 +110,11 @@ module.exports.RavenBlockTemplate = function(rpcData, poolAddress) {
 
     txCoinbase.addOutput(scriptCompile(poolAddrHash), Math.floor(rpcData.coinbasevalue));
 
+    // For CLORE
+    if (rpcData.CommunityAutonomousAddress && rpcData.CommunityAutonomousValue) {
+      txCoinbase.addOutput(scriptCompile(bitcoin.address.fromBase58Check(rpcData.CommunityAutonomousAddress).hash), Math.floor(rpcData.CommunityAutonomousValue));
+    }
+
     if (rpcData.default_witness_commitment) {
       txCoinbase.addOutput(Buffer.from(rpcData.default_witness_commitment, 'hex'), 0);
     }
@@ -152,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 = [];
@@ -161,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;
@@ -212,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": "13.0.1",
-  "main": "cryptoforknote-util",
+  "version": "15.5.2",
   "author": {
     "name": "LucasJones",
     "email": "lucasjonesdev@hotmail.co.uk"
@@ -11,15 +10,16 @@
     "url": "https://github.com/haven-protocol-org/node-cryptoforknote-util.git"
   },
   "dependencies": {
-    "promise": "*",
-    "bindings": "*",
-    "nan": "^2.14.2",
-    "bignum": "^0.13.1",
-    "sha3": "*",
     "base58-native": "*",
-    "varuint-bitcoin": "^1.0.4",
+    "bech32": "*",
+    "bignum": "^0.13.1",
+    "bindings": "*",
+    "bitcoinjs-lib": "git+https://github.com/MoneroOcean/bitcoinjs-lib.git",
     "merkle-lib": "^2.0.10",
-    "bitcoinjs-lib": "git+https://github.com/MoneroOcean/bitcoinjs-lib.git"
+    "nan": "^2.20.0",
+    "promise": "*",
+    "sha3": "*",
+    "varuint-bitcoin": "^1.0.4"
   },
   "keywords": [
     "cryptonight",

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/contrib/epee/include/serialization/keyvalue_serialization_overloads.h

@@ -26,6 +26,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <set>
 #include <list>
 #include <vector>

src/cryptonote_config.h

@@ -1,12 +1,13 @@
 #pragma once
 
-#define CURRENT_TRANSACTION_VERSION  1
-#define POU_TRANSACTION_VERSION      6
-#define COLLATERAL_TRANSACTION_VERSION 7
-#define OFFSHORE_TRANSACTION_VERSION 3
-#define HF_VERSION_XASSET_FEES_V2    17
-#define HF_VERSION_HAVEN2            18
-#define HF_VERSION_USE_COLLATERAL      20
+#define CURRENT_TRANSACTION_VERSION      1
+#define POU_TRANSACTION_VERSION          6
+#define COLLATERAL_TRANSACTION_VERSION   7
+#define HAVEN_TYPES_TRANSACTION_VERSION  8
+#define OFFSHORE_TRANSACTION_VERSION     3
+#define HF_VERSION_XASSET_FEES_V2       17
+#define HF_VERSION_HAVEN2               18
+#define HF_VERSION_USE_COLLATERAL       20
 
 // UNLOCK TIMES
 #define TX_V6_OFFSHORE_UNLOCK_BLOCKS                    21*720  // 21 day unlock time
@@ -33,4 +34,7 @@ enum BLOB_TYPE {
   BLOB_TYPE_CRYPTONOTE_TUBE   = 10, // TUBE
   BLOB_TYPE_CRYPTONOTE_XHV    = 11, // Haven
   BLOB_TYPE_CRYPTONOTE_XTA    = 12, // ITALO
+  BLOB_TYPE_CRYPTONOTE_ZEPHYR = 13, // ZEPHYR
+  BLOB_TYPE_CRYPTONOTE_XLA    = 14, // XLA
+  BLOB_TYPE_CRYPTONOTE_SALVIUM= 15, // Salvium
 };

src/cryptonote_core/cryptonote_basic.h

@@ -16,6 +16,7 @@
 #include "serialization/binary_archive.h"
 #include "serialization/crypto.h"
 #include "serialization/pricing_record.h"
+#include "serialization/zephyr_pricing_record.h"
 #include "serialization/keyvalue_serialization.h" // eepe named serialization
 #include "string_tools.h"
 #include "cryptonote_config.h"
@@ -26,6 +27,7 @@
 #include "ringct/rctTypes.h"
 #include "cryptonote_protocol/blobdatatype.h"
 #include "offshore/pricing_record.h"
+#include "zephyr_oracle/pricing_record.h"
 
 
 namespace cryptonote
@@ -46,7 +48,19 @@ namespace cryptonote
 
   typedef std::vector<crypto::signature> ring_signature;
 
-
+  enum salvium_transaction_type
+  {
+    UNSET = 0,
+    MINER = 1,
+    PROTOCOL = 2,
+    TRANSFER = 3,
+    CONVERT = 4,
+    BURN = 5,
+    STAKE = 6,
+    RETURN = 7,
+    MAX = 7
+  };
+  
   /* outputs */
 
   struct txout_to_script
@@ -87,6 +101,48 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  // outputs <= HF_VERSION_VIEW_TAGS
+  struct txout_haven_key
+  {
+    txout_haven_key() { }
+    txout_haven_key(const crypto::public_key &_key, const std::string &_asset_type, const uint64_t &_unlock_time, const bool &_is_collateral, const bool &_is_collateral_change) : key(_key), asset_type(_asset_type), unlock_time(_unlock_time), is_collateral(_is_collateral), is_collateral_change(_is_collateral_change) { }
+    crypto::public_key key;
+    std::string asset_type;
+    uint64_t unlock_time;
+    bool is_collateral;
+    bool is_collateral_change;
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(key)
+      FIELD(asset_type)
+      VARINT_FIELD(unlock_time)
+      FIELD(is_collateral)
+      FIELD(is_collateral_change)
+    END_SERIALIZE()
+  };
+
+  // outputs >= HF_VERSION_VIEW_TAGS
+  struct txout_haven_tagged_key
+  {
+    txout_haven_tagged_key() { }
+    txout_haven_tagged_key(const crypto::public_key &_key, const std::string &_asset_type, const uint64_t &_unlock_time, const bool &_is_collateral, const bool &_is_collateral_change, const crypto::view_tag &_view_tag) : key(_key), asset_type(_asset_type), unlock_time(_unlock_time), is_collateral(_is_collateral), is_collateral_change(_is_collateral_change), view_tag(_view_tag) { }
+    crypto::public_key key;
+    std::string asset_type;
+    uint64_t unlock_time;
+    bool is_collateral;
+    bool is_collateral_change;
+    crypto::view_tag view_tag; // optimization to reduce scanning time
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(key)
+      FIELD(asset_type)
+      VARINT_FIELD(unlock_time)
+      FIELD(is_collateral)
+      FIELD(is_collateral_change)
+      FIELD(view_tag)
+    END_SERIALIZE()
+  };
+
   struct txout_offshore
   {
     txout_offshore() { }
@@ -107,6 +163,57 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  // ZEPHYR
+  struct txout_zephyr_tagged_key
+  {
+    txout_zephyr_tagged_key() { }
+    txout_zephyr_tagged_key(const crypto::public_key &_key, const std::string &_asset_type, const crypto::view_tag &_view_tag) : key(_key), asset_type(_asset_type), view_tag(_view_tag) { }
+    crypto::public_key key;
+    std::string asset_type;
+    crypto::view_tag view_tag; // optimization to reduce scanning time
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(key)
+      FIELD(asset_type)
+      FIELD(view_tag)
+    END_SERIALIZE()
+  };
+
+  // SALVIUM
+  struct txout_salvium_key
+  {
+    txout_salvium_key() { }
+    txout_salvium_key(const crypto::public_key &_key, const std::string &_asset_type, const uint64_t &_unlock_time) :
+      key(_key), asset_type(_asset_type), unlock_time(_unlock_time) { }
+    crypto::public_key key;
+    std::string asset_type;
+    uint64_t unlock_time;
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(key)
+      FIELD(asset_type)
+      VARINT_FIELD(unlock_time)
+    END_SERIALIZE()
+  };
+
+  struct txout_salvium_tagged_key
+  {
+    txout_salvium_tagged_key() { }
+    txout_salvium_tagged_key(const crypto::public_key &_key, const std::string &_asset_type, const uint64_t &_unlock_time, const crypto::view_tag &_view_tag) :
+      key(_key), asset_type(_asset_type), unlock_time(_unlock_time), view_tag(_view_tag) { }
+    crypto::public_key key;
+    std::string asset_type;
+    uint64_t unlock_time;
+    crypto::view_tag view_tag; // optimization to reduce scanning time
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(key)
+      FIELD(asset_type)
+      VARINT_FIELD(unlock_time)
+      FIELD(view_tag)
+    END_SERIALIZE()
+  };
+
   /* inputs */
 
   struct txin_gen
@@ -185,6 +292,21 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct txin_haven_key
+  {
+    uint64_t amount;
+    std::string asset_type;
+    std::vector<uint64_t> key_offsets;
+    crypto::key_image k_image;      // double spending protection
+
+    BEGIN_SERIALIZE_OBJECT()
+    VARINT_FIELD(amount)
+    FIELD(asset_type)
+    FIELD(key_offsets)
+    FIELD(k_image)
+    END_SERIALIZE()
+  };
+
   struct txin_xasset
   {
     uint64_t amount;
@@ -199,11 +321,46 @@ namespace cryptonote
     FIELD(k_image)
     END_SERIALIZE()
   };
+
+  struct txin_zephyr_key
+  {
+    uint64_t amount;
+    std::string asset_type;
+    std::vector<uint64_t> key_offsets;
+    crypto::key_image k_image;      // double spending protection
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(amount)
+      FIELD(asset_type)
+      FIELD(key_offsets)
+      FIELD(k_image)
+    END_SERIALIZE()
+  };
   
-  typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_to_key, txin_offshore, txin_onshore, txin_xasset> txin_v;
+  struct txin_salvium_key
+  {
+    uint64_t amount;
+    std::string asset_type;
+    std::vector<uint64_t> key_offsets;
+    crypto::key_image k_image;      // double spending protection
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(amount)
+      FIELD(asset_type)
+      FIELD(key_offsets)
+      FIELD(k_image)
+    END_SERIALIZE()
+  };
+  
+  typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_to_key, txin_offshore, txin_onshore, txin_xasset, txin_haven_key> txin_v;
+  typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_zephyr_key> txin_zephyr_v;
+  typedef boost::variant<txin_gen, txin_to_script, txin_to_scripthash, txin_salvium_key> txin_salvium_v;
 
   typedef boost::variant<txout_to_script, txout_to_scripthash, txout_to_key, txout_to_tagged_key> txout_target_v;
-  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_to_key, txout_offshore, txout_xasset> txout_xhv_target_v;
+  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_to_key, txout_offshore, txout_xasset, txout_haven_key, txout_haven_tagged_key> txout_xhv_target_v;
+  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_salvium_key, txout_salvium_tagged_key> txout_salvium_target_v;
+
+  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_zephyr_tagged_key> txout_stablero_target_v;
 
   struct tx_out
   {
@@ -227,6 +384,28 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct tx_out_zephyr
+  {
+    uint64_t amount;
+    txout_stablero_target_v target;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(amount)
+      FIELD(target)
+    END_SERIALIZE()
+  };
+
+  struct tx_out_salvium
+  {
+    uint64_t amount;
+    txout_salvium_target_v target;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(amount)
+      FIELD(target)
+    END_SERIALIZE()
+  };
+
 
   enum loki_version
   {
@@ -247,8 +426,12 @@ namespace cryptonote
     uint64_t unlock_time;  //number of block (or time), used as a limitation like: spend this tx not early then block/time
 
     std::vector<txin_v> vin;
+    std::vector<txin_zephyr_v> vin_zephyr;
+    std::vector<txin_salvium_v> vin_salvium;
     std::vector<tx_out> vout;
     std::vector<tx_out_xhv> vout_xhv;
+    std::vector<tx_out_zephyr> vout_zephyr;
+    std::vector<tx_out_salvium> vout_salvium;
     //extra
     std::vector<uint8_t> extra;
     // Block height to use PR from
@@ -258,7 +441,24 @@ namespace cryptonote
     uint64_t amount_burnt;
     uint64_t amount_minted;
     std::vector<uint64_t> output_unlock_times;
-    size_t collateral_index; // index to the outputs vector that denotes the collateral output.
+    std::vector<uint32_t> collateral_indices;
+
+    // SALVIUM-SPECIFIC FIELDS
+    // TX type
+    cryptonote::salvium_transaction_type tx_type;
+    // Return address
+    crypto::public_key return_address;
+    // Return TX public key
+    crypto::public_key return_pubkey;
+    // Source asset type
+    std::string source_asset_type;
+    // Destination asset type (this is only necessary for CONVERT transactions)
+    std::string destination_asset_type;
+    // Circulating supply information - already provided by Haven
+    //uint64_t amount_burnt;
+    // Slippage limit
+    uint64_t amount_slippage_limit;
+
 
     //
     // NOTE: Loki specific
@@ -278,45 +478,308 @@ namespace cryptonote
     };
 
     BEGIN_SERIALIZE()
-      VARINT_FIELD(version)
-      if (version > loki_version_2 && (blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC))
-      {
-        FIELD(output_unlock_times)
-        if (version == loki_version_3_per_output_unlock_times)
-          FIELD(is_deregister)
-      }
-      if (blob_type != BLOB_TYPE_CRYPTONOTE_XHV || version < POU_TRANSACTION_VERSION)
-        VARINT_FIELD(unlock_time)
-      FIELD(vin)
-      if (blob_type != BLOB_TYPE_CRYPTONOTE_XHV)
-        FIELD(vout)
-      else
-        FIELD(vout_xhv)
-      if (blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC)
-      {
-        if (version >= loki_version_3_per_output_unlock_times && vout.size() != output_unlock_times.size()) return false;
-      }
-      FIELD(extra)
-      if ((blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC) && version >= loki_version_4_tx_types)
-      {
-        VARINT_FIELD(type)
-        if (static_cast<uint16_t>(type) >= loki_type_count) return false;
-      }
-      if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV && version >= OFFSHORE_TRANSACTION_VERSION) {
-        VARINT_FIELD(pricing_record_height)
-        if (version < 5)
-          FIELD(offshore_data)
-        if (version >= POU_TRANSACTION_VERSION)
-        {
-          FIELD(output_unlock_times)
+      if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV) {
+        VARINT_FIELD(version)
+          //if(version == 0 || CURRENT_TRANSACTION_VERSION < version) return false;
+      
+        // Only transactions prior to HAVEN_TYPES_TRANSACTION_VERSION are permitted to be anything other than HAVEN_TYPES and need translation
+        if (version < HAVEN_TYPES_TRANSACTION_VERSION) {
+  
+          if (version < POU_TRANSACTION_VERSION) {
+            VARINT_FIELD(unlock_time)
+          }
+          if (!typename Archive<W>::is_saving()) {
+            FIELD(vin)
+            FIELD(vout_xhv)
+            FIELD(extra)
+            if(version >= OFFSHORE_TRANSACTION_VERSION) {
+              VARINT_FIELD(pricing_record_height)
+              if (version < 5)
+                FIELD(offshore_data)
+              if (version >= POU_TRANSACTION_VERSION) {
+                FIELD(output_unlock_times)
+                if (vout_xhv.size() != output_unlock_times.size()) {
+                  return false;
+                }
+              }
+              VARINT_FIELD(amount_burnt)
+              VARINT_FIELD(amount_minted)
+              if (version >= COLLATERAL_TRANSACTION_VERSION && amount_burnt) {
+                FIELD(collateral_indices)
+                if (collateral_indices.size() != 2) {
+                  return false;
+                }
+                for (const auto vout_idx: collateral_indices) {
+                  if (vout_idx >= vout_xhv.size())
+                    return false;
+                }
+              }
+            }
+            std::vector<txin_v> vin_tmp(vin);
+            bool is_conversion_tx = (amount_burnt != 0);
+            bool is_offshore_tx = is_conversion_tx;
+            bool is_onshore_tx = false;
+            vin.clear();
+            for (auto &vin_entry: vin_tmp) {
+              if (vin_entry.type() == typeid(txin_gen)) {
+                vin.push_back(vin_entry);
+                continue;
+              }
+              txin_haven_key in;
+              if (vin_entry.type() == typeid(txin_to_key)) {
+                in.asset_type = "XHV";
+                in.amount = boost::get<txin_to_key>(vin_entry).amount;
+                in.key_offsets = boost::get<txin_to_key>(vin_entry).key_offsets;
+                in.k_image = boost::get<txin_to_key>(vin_entry).k_image;
+              } else if (vin_entry.type() == typeid(txin_offshore)) {
+                is_offshore_tx = false;
+                is_onshore_tx = false;
+                in.asset_type = "XUSD";
+                in.amount = boost::get<txin_offshore>(vin_entry).amount;
+                in.key_offsets = boost::get<txin_offshore>(vin_entry).key_offsets;
+                in.k_image = boost::get<txin_offshore>(vin_entry).k_image;
+              } else if (vin_entry.type() == typeid(txin_onshore)) {
+                is_offshore_tx = false;
+                is_onshore_tx = true;
+                in.asset_type = "XUSD";
+                in.amount = boost::get<txin_onshore>(vin_entry).amount;
+                in.key_offsets = boost::get<txin_onshore>(vin_entry).key_offsets;
+                in.k_image = boost::get<txin_onshore>(vin_entry).k_image;
+              } else if (vin_entry.type() == typeid(txin_xasset)) {
+                is_offshore_tx = false;
+                is_onshore_tx = false;
+                in.amount = boost::get<txin_xasset>(vin_entry).amount;
+                in.key_offsets = boost::get<txin_xasset>(vin_entry).key_offsets;
+                in.k_image = boost::get<txin_xasset>(vin_entry).k_image;
+                in.asset_type = boost::get<txin_xasset>(vin_entry).asset_type;
+              } else {
+                return false;
+              }
+              vin.push_back(in);
+            }
+            std::vector<tx_out_xhv> vout_tmp(vout_xhv);
+            vout_xhv.clear();
+            for (size_t i=0; i<vout_tmp.size(); i++) {
+              txout_haven_key out;
+              if (vout_tmp[i].target.type() == typeid(txout_to_key)) {
+                out.asset_type = "XHV";
+                out.key = boost::get<txout_to_key>(vout_tmp[i].target).key;
+              } else if (vout_tmp[i].target.type() == typeid(txout_offshore)) {
+                out.asset_type = "XUSD";
+                out.key = boost::get<txout_offshore>(vout_tmp[i].target).key;
+              } else if (vout_tmp[i].target.type() == typeid(txout_xasset)) {
+                out.asset_type = boost::get<txout_xasset>(vout_tmp[i].target).asset_type;
+                out.key = boost::get<txout_xasset>(vout_tmp[i].target).key;
+              } else {
+                return false;
+              }
+              out.unlock_time = (version >= POU_TRANSACTION_VERSION) ? output_unlock_times[i] : unlock_time;
+              out.is_collateral = false;
+              out.is_collateral_change = false;
+              if (version >= COLLATERAL_TRANSACTION_VERSION && amount_burnt) {
+                if (((is_onshore_tx) &&
+                     (collateral_indices[0] == i)) ||
+                    ((!is_onshore_tx) &&
+                     (is_offshore_tx) &&
+                     (collateral_indices[0] == i && collateral_indices[1] == 0))) {
+                    out.is_collateral = true;
+                }
+                if (is_onshore_tx && collateral_indices[1] == i) {
+                  out.is_collateral_change = true;
+                }
+              }
+              tx_out_xhv foo;
+              foo.amount = vout_tmp[i].amount;
+              foo.target = out;
+              vout_xhv.push_back(foo);
+            }
+            return true;
+          }
+          bool is_offshore_tx = (amount_burnt != 0);
+          bool is_onshore_tx = false;
+          std::vector<txin_v> vin_tmp;
+          vin_tmp.reserve(vin.size());
+          for (auto &vin_entry_v: vin) {
+            if (vin_entry_v.type() == typeid(txin_gen)) {
+              vin_tmp.push_back(vin_entry_v);
+              continue;
+            }
+            txin_haven_key vin_entry = boost::get<txin_haven_key>(vin_entry_v);
+            if (vin_entry.asset_type == "XHV") {
+              txin_to_key in;
+              in.amount = vin_entry.amount;
+              in.key_offsets = vin_entry.key_offsets;
+              in.k_image = vin_entry.k_image;
+              vin_tmp.push_back(in);
+            } else if (vin_entry.asset_type == "XUSD") {
+              is_offshore_tx = false;
+              int xhv_outputs = std::count_if(vout_xhv.begin(), vout_xhv.end(), [](tx_out_xhv &foo_v) {
+                if (foo_v.target.type() == typeid(txout_haven_key)) {
+                  txout_haven_key out = boost::get<txout_haven_key>(foo_v.target);
+                  return out.asset_type == "XHV";
+                } else if (foo_v.target.type() == typeid(txout_haven_tagged_key)) {
+                  txout_haven_tagged_key out = boost::get<txout_haven_tagged_key>(foo_v.target);
+                  return out.asset_type == "XHV";
+                } else {
+                  return false;
+                }
+              });
+              if (xhv_outputs) {
+                is_onshore_tx = true;
+                txin_onshore in;
+                in.amount = vin_entry.amount;
+                in.key_offsets = vin_entry.key_offsets;
+                in.k_image = vin_entry.k_image;
+                vin_tmp.push_back(in);
+              } else {
+                txin_offshore in;
+                in.amount = vin_entry.amount;
+                in.key_offsets = vin_entry.key_offsets;
+                in.k_image = vin_entry.k_image;
+                vin_tmp.push_back(in);
+              }
+            } else {
+              is_offshore_tx = false;
+              txin_xasset in;
+              in.amount = vin_entry.amount;
+              in.asset_type = vin_entry.asset_type;
+              in.key_offsets = vin_entry.key_offsets;
+              in.k_image = vin_entry.k_image;
+              vin_tmp.push_back(in);
+            }
+          }
+          std::vector<tx_out_xhv> vout_tmp;
+          vout_tmp.reserve(vout_xhv.size());
+          output_unlock_times.resize(vout_xhv.size());
+          std::vector<uint32_t> collateral_indices_temp;
+          collateral_indices_temp.resize(2);
+          for (size_t i=0; i<vout_xhv.size(); i++) {
+            txout_haven_key outhk = boost::get<txout_haven_key>(vout_xhv[i].target);
+            tx_out_xhv foo;
+            foo.amount = vout_xhv[i].amount;
+            if (outhk.asset_type == "XHV") {
+              txout_to_key out;
+              out.key = outhk.key;
+              foo.target = out;
+            } else if (outhk.asset_type == "XUSD") {
+              txout_offshore out;
+              out.key = outhk.key;
+              foo.target = out;
+            } else {
+              txout_xasset out;
+              out.asset_type = outhk.asset_type;
+              out.key = outhk.key;
+              foo.target = out;
+            }
+            output_unlock_times[i] = outhk.unlock_time;
+            if (outhk.is_collateral) {
+              collateral_indices_temp[0] = i;
+            } else if (outhk.is_collateral_change) {
+              collateral_indices_temp[1] = i;
+            }
+            vout_tmp.push_back(foo);
+          }
+          FIELD_N("vin", vin_tmp)
+          FIELD_N("vout", vout_tmp)
+          FIELD(extra)
+          if(version >= OFFSHORE_TRANSACTION_VERSION) {
+            VARINT_FIELD(pricing_record_height)
+            if (version < 5)
+              FIELD(offshore_data)
+            if (version >= POU_TRANSACTION_VERSION) {
+              FIELD(output_unlock_times)
+              if (vout_xhv.size() != output_unlock_times.size()) {
+                return false;
+              }
+            }
+            VARINT_FIELD(amount_burnt)
+            VARINT_FIELD(amount_minted)
+            if (version >= COLLATERAL_TRANSACTION_VERSION && amount_burnt) {
+              if (collateral_indices.size() != 2) {
+                if ((is_offshore_tx || is_onshore_tx) && collateral_indices_temp.size() != 2) {
+                  return false;
+                }
+                if (is_offshore_tx || is_onshore_tx) {
+                  collateral_indices = collateral_indices_temp;
+                } else {
+                  collateral_indices.clear();
+                  collateral_indices.push_back(0);
+                  collateral_indices.push_back(0);
+                }
+              }
+              FIELD(collateral_indices)
+              for (const auto vout_idx: collateral_indices) {
+                if (vout_idx >= vout_xhv.size())
+                  return false;
+              }
+            }
+          }
+          return true;
         }
-        if (version >= POU_TRANSACTION_VERSION && vout_xhv.size() != output_unlock_times.size()) return false;
+  
+        FIELD(vin)
+        FIELD(vout_xhv)
+        FIELD(extra)
+        VARINT_FIELD(pricing_record_height)
         VARINT_FIELD(amount_burnt)
         VARINT_FIELD(amount_minted)
-        if (version >= COLLATERAL_TRANSACTION_VERSION) {
-          VARINT_FIELD(collateral_index)
-          if (collateral_index >= vout.size())
-            return false;
+
+      } else if (blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM) {
+
+        VARINT_FIELD(version)
+        //if(version == 0 || CURRENT_TRANSACTION_VERSION < version) return false;
+        VARINT_FIELD(unlock_time)
+        FIELD(vin_salvium)
+        FIELD(vout_salvium)
+        FIELD(extra)
+        VARINT_FIELD(tx_type)
+        if (tx_type != cryptonote::salvium_transaction_type::PROTOCOL) {
+          VARINT_FIELD(amount_burnt)
+          if (tx_type != cryptonote::salvium_transaction_type::MINER) {
+            FIELD(return_address)
+            FIELD(return_pubkey)
+            FIELD(source_asset_type)
+            FIELD(destination_asset_type)
+            VARINT_FIELD(amount_slippage_limit)
+          }
+        }
+        
+      } else {
+  
+        VARINT_FIELD(version)
+        if (version > loki_version_2 && (blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC))
+        {
+          FIELD(output_unlock_times)
+          if (version == loki_version_3_per_output_unlock_times)
+            FIELD(is_deregister)
+        }
+  
+        VARINT_FIELD(unlock_time)
+  
+        if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR)
+          FIELD(vin_zephyr)
+        else 
+          FIELD(vin)
+  
+        if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR)
+          FIELD(vout_zephyr)
+        else
+          FIELD(vout)
+  
+        if (blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC)
+        {
+          if (version >= loki_version_3_per_output_unlock_times && vout.size() != output_unlock_times.size()) return false;
+        }
+        FIELD(extra)
+        if ((blob_type == BLOB_TYPE_CRYPTONOTE_LOKI || blob_type == BLOB_TYPE_CRYPTONOTE_XTNC) && version >= loki_version_4_tx_types)
+        {
+          VARINT_FIELD(type)
+          if (static_cast<uint16_t>(type) >= loki_type_count) return false;
+        }
+        if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR) {
+          VARINT_FIELD(pricing_record_height)
+          VARINT_FIELD(amount_burnt)
+          VARINT_FIELD(amount_minted)
         }
       }
     END_SERIALIZE()
@@ -373,26 +836,42 @@ namespace cryptonote
       else
       {
         ar.tag("rct_signatures");
-        if (!vin.empty())
+        if (blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM ? !vin_salvium.empty() : (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? !vin_zephyr.empty() : !vin.empty()))
         {
           ar.begin_object();
-          bool r = rct_signatures.serialize_rctsig_base(ar, vin.size(), blob_type != BLOB_TYPE_CRYPTONOTE_XHV ? vout.size() : vout_xhv.size());
+          bool r;
+          if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV)
+            r = rct_signatures.serialize_rctsig_base(ar, vin.size(), vout_xhv.size());
+          else if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR)
+            r = rct_signatures.serialize_rctsig_base(ar, vin_zephyr.size(), vout_zephyr.size());
+          else if (blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM)
+            r = rct_signatures.serialize_rctsig_base(ar, vin_salvium.size(), vout_salvium.size());
+          else
+            r = rct_signatures.serialize_rctsig_base(ar, vin.size(), vout.size());
           if (!r || !ar.stream().good()) return false;
           ar.end_object();
           if (rct_signatures.type != rct::RCTTypeNull)
           {
             ar.tag("rctsig_prunable");
             ar.begin_object();
-            if (blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
-              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
-                  vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 : 0);
-            } else {
+            if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR) {
+              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin_zephyr.size(), vout_zephyr.size(),
+                  vin_zephyr[0].type() == typeid(txin_zephyr_key) ? boost::get<txin_zephyr_key>(vin_zephyr[0]).key_offsets.size() - 1 : 0);
+            } else if (blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM) {
+              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin_salvium.size(), vout_salvium.size(),
+                  vin_salvium[0].type() == typeid(txin_salvium_key) ? boost::get<txin_salvium_key>(vin_salvium[0]).key_offsets.size() - 1 : 0);
+            } else if (blob_type == BLOB_TYPE_CRYPTONOTE_XHV) {
               r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout_xhv.size(),
                   vin.size() > 0 && vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 :
                   vin.size() > 0 && vin[0].type() == typeid(txin_offshore) ? boost::get<txin_offshore>(vin[0]).key_offsets.size() - 1 :
                   vin.size() > 0 && vin[0].type() == typeid(txin_onshore) ? boost::get<txin_onshore>(vin[0]).key_offsets.size() - 1 :
                   vin.size() > 0 && vin[0].type() == typeid(txin_xasset) ? boost::get<txin_xasset>(vin[0]).key_offsets.size() - 1 :
-         	  0);
+                  vin.size() > 0 && vin[0].type() == typeid(txin_haven_key) ? boost::get<txin_haven_key>(vin[0]).key_offsets.size() - 1 :
+                  0
+              );
+            } else {
+              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
+                  vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 : 0);
             }
             if (!r || !ar.stream().good()) return false;
             ar.end_object();
@@ -423,8 +902,10 @@ namespace cryptonote
     version = 0;
     unlock_time = 0;
     vin.clear();
+    vin_zephyr.clear();
     vout.clear();
     vout_xhv.clear();
+    vout_zephyr.clear();
     extra.clear();
     signatures.clear();
     pricing_record_height = 0;
@@ -432,7 +913,7 @@ namespace cryptonote
     amount_burnt = 0;
     amount_minted = 0;
     output_unlock_times.clear();
-    collateral_index = 0;
+    collateral_indices.clear();
   }
 
   inline
@@ -447,6 +928,8 @@ namespace cryptonote
       size_t operator()(const txin_offshore& txin) const {return txin.key_offsets.size();}
       size_t operator()(const txin_onshore& txin) const {return txin.key_offsets.size();}
       size_t operator()(const txin_xasset& txin) const {return txin.key_offsets.size();}
+      size_t operator()(const txin_haven_key& txin) const {return txin.key_offsets.size();}
+      size_t operator()(const txin_zephyr_key& txin) const {return txin.key_offsets.size();}
     };
 
     return boost::apply_visitor(txin_signature_size_visitor(), tx_in);
@@ -567,9 +1050,11 @@ namespace cryptonote
     uint64_t nonce;
     uint64_t nonce8;
     offshore::pricing_record pricing_record;
+    zephyr_oracle::pricing_record zephyr_pricing_record;
     crypto::cycle cycle;
     crypto::cycle40 cycle40;
     crypto::cycle48 cycle48;
+    crypto::signature signature;
 
     BEGIN_SERIALIZE()
       VARINT_FIELD(major_version)
@@ -590,7 +1075,42 @@ namespace cryptonote
       if (blob_type == BLOB_TYPE_CRYPTONOTE_XTNC || blob_type == BLOB_TYPE_CRYPTONOTE_CUCKOO) FIELD(cycle)
       if (blob_type == BLOB_TYPE_CRYPTONOTE_TUBE) FIELD(cycle40)
       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_XHV || blob_type == BLOB_TYPE_CRYPTONOTE_SAL) FIELD(pricing_record)
+      if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR) {
+        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;
+          if (!typename Archive<W>::is_saving())
+          {
+            FIELD(pr_v1)
+            pr_v1.write_to_pr(zephyr_pricing_record);
+          }
+          else
+          {
+            pr_v1.read_from_pr(zephyr_pricing_record);
+            FIELD(pr_v1)
+          }
+        }
+      }
+      if (blob_type == BLOB_TYPE_CRYPTONOTE_XLA && major_version >= 13) FIELD(signature)
 
     END_SERIALIZE()
   };
@@ -600,10 +1120,11 @@ namespace cryptonote
     bytecoin_block parent_block;
 
     transaction miner_tx;
+    transaction protocol_tx;
     std::vector<crypto::hash> tx_hashes;
     mutable crypto::hash uncle = cryptonote::null_hash;
 
-    void set_blob_type(enum BLOB_TYPE bt) { miner_tx.blob_type = blob_type = bt; }
+    void set_blob_type(enum BLOB_TYPE bt) { miner_tx.blob_type = protocol_tx.blob_type = blob_type = bt; }
 
     BEGIN_SERIALIZE_OBJECT()
       FIELDS(*static_cast<block_header *>(this))
@@ -613,6 +1134,10 @@ namespace cryptonote
         FIELD_N("parent_block", sbb);
       }
       FIELD(miner_tx)
+      if (blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM)
+      {
+        FIELD(protocol_tx)
+      }
       FIELD(tx_hashes)
       if (blob_type == BLOB_TYPE_CRYPTONOTE3)
       {
@@ -660,12 +1185,6 @@ namespace cryptonote
     KV_SERIALIZE(payment_id)
     END_KV_SERIALIZE_MAP()
   };
-
-  struct keypair
-  {
-    crypto::public_key pub;
-    crypto::secret_key sec;
-  };
   //---------------------------------------------------------------
 
 }
@@ -678,14 +1197,22 @@ VARIANT_TAG(binary_archive, cryptonote::txin_gen, 0xff);
 VARIANT_TAG(binary_archive, cryptonote::txin_to_script, 0x0);
 VARIANT_TAG(binary_archive, cryptonote::txin_to_scripthash, 0x1);
 VARIANT_TAG(binary_archive, cryptonote::txin_to_key, 0x2);
+VARIANT_TAG(binary_archive, cryptonote::txin_zephyr_key, 0x2);
 VARIANT_TAG(binary_archive, cryptonote::txin_offshore, 0x3);
+VARIANT_TAG(binary_archive, cryptonote::txin_salvium_key, 0x2);
 VARIANT_TAG(binary_archive, cryptonote::txin_onshore, 0x4);
 VARIANT_TAG(binary_archive, cryptonote::txin_xasset, 0x5);
+VARIANT_TAG(binary_archive, cryptonote::txin_haven_key, 0x6);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_script, 0x0);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_scripthash, 0x1);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_key, 0x2);
+VARIANT_TAG(binary_archive, cryptonote::txout_salvium_key, 0x2);
+VARIANT_TAG(binary_archive, cryptonote::txout_zephyr_tagged_key, 0x2);
 VARIANT_TAG(binary_archive, cryptonote::txout_to_tagged_key, 0x3);
+VARIANT_TAG(binary_archive, cryptonote::txout_salvium_tagged_key, 0x3);
 VARIANT_TAG(binary_archive, cryptonote::txout_offshore, 0x3);
 VARIANT_TAG(binary_archive, cryptonote::txout_xasset, 0x5);
+VARIANT_TAG(binary_archive, cryptonote::txout_haven_key, 0x6);
+VARIANT_TAG(binary_archive, cryptonote::txout_haven_tagged_key, 0x7);
 VARIANT_TAG(binary_archive, cryptonote::transaction, 0xcc);
 VARIANT_TAG(binary_archive, cryptonote::block, 0xbb);

src/cryptonote_core/cryptonote_format_utils.cpp

@@ -163,44 +163,6 @@ namespace cryptonote
     return true;
   }
   //---------------------------------------------------------------
-  bool get_inputs_money_amount(const transaction& tx, uint64_t& money)
-  {
-    money = 0;
-    BOOST_FOREACH(const auto& in, tx.vin)
-    {
-      CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
-      money += tokey_in.amount;
-    }
-    return true;
-  }
-  //---------------------------------------------------------------
-  uint64_t get_block_height(const block& b)
-  {
-    CHECK_AND_ASSERT_MES(b.miner_tx.vin.size() == 1, 0, "wrong miner tx in block: " << get_block_hash(b) << ", b.miner_tx.vin.size() != 1");
-    CHECKED_GET_SPECIFIC_VARIANT(b.miner_tx.vin[0], const txin_gen, coinbase_in, 0);
-    return coinbase_in.height;
-  }
-  //---------------------------------------------------------------
-  bool check_inputs_types_supported(const transaction& tx)
-  {
-    BOOST_FOREACH(const auto& in, tx.vin)
-    {
-      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
-        CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), false, "wrong variant type: "
-          << in.type().name() << ", expected " << typeid(txin_to_key).name()
-          << ", in transaction id=" << get_transaction_hash(tx));
-      } else {
-	CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key) || in.type() == typeid(txin_offshore) || in.type() == typeid(txin_onshore) || in.type() == typeid(txin_xasset), false, "wrong variant type: "
-			     << in.type().name() << ", expected " << typeid(txin_to_key).name()
-			     << "or " << typeid(txin_offshore).name()
-			     << "or " << typeid(txin_onshore).name()
-			     << "or " << typeid(txin_xasset).name()
-			     << ", in transaction id=" << get_transaction_hash(tx));
-      }
-    }
-    return true;
-  }
-  //---------------------------------------------------------------
   std::string short_hash_str(const crypto::hash& h)
   {
     std::string res = string_tools::pod_to_hex(h);
@@ -258,8 +220,8 @@ namespace cryptonote
     {
       std::stringstream ss;
       binary_archive<true> ba(ss);
-      const size_t inputs = t.vin.size();
-      const size_t outputs = t.blob_type != BLOB_TYPE_CRYPTONOTE_XHV ? t.vout.size() : t.vout_xhv.size();
+      const size_t inputs  = t.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM ? t.vin_salvium.size()  : (t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? t.vin_zephyr.size() : t.vin.size());
+      const size_t outputs = t.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM ? t.vout_salvium.size() : (t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? t.vout_zephyr.size() : (t.blob_type != BLOB_TYPE_CRYPTONOTE_XHV ? t.vout.size() : t.vout_xhv.size()));
       bool r = tt.rct_signatures.serialize_rctsig_base(ba, inputs, outputs);
       CHECK_AND_ASSERT_MES(r, false, "Failed to serialize rct signatures base");
       cryptonote::get_blob_hash(ss.str(), hashes[1]);
@@ -274,18 +236,23 @@ namespace cryptonote
     {
       std::stringstream ss;
       binary_archive<true> ba(ss);
-      const size_t inputs = t.vin.size();
-      const size_t outputs = t.blob_type != BLOB_TYPE_CRYPTONOTE_XHV ? t.vout.size() : t.vout_xhv.size();
+      const size_t inputs  = t.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM ? t.vin_salvium.size()  : (t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? t.vin_zephyr.size() : t.vin.size());
+      const size_t outputs = t.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM ? t.vout_salvium.size() : (t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? t.vout_zephyr.size() : (t.blob_type != BLOB_TYPE_CRYPTONOTE_XHV ? t.vout.size() : t.vout_xhv.size()));
       size_t mixin;
-      if (t.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
-        mixin = t.vin.empty() ? 0 : t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 : 0;
-      } else {
+      if (t.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM) {
+        mixin = t.vin_salvium.empty() ? 0 : t.vin_salvium[0].type() == typeid(txin_salvium_key) ? boost::get<txin_salvium_key>(t.vin_salvium[0]).key_offsets.size() - 1 : 0;
+      } else if (t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR) {
+        mixin = t.vin_zephyr.empty() ? 0 : t.vin_zephyr[0].type() == typeid(txin_zephyr_key) ? boost::get<txin_zephyr_key>(t.vin_zephyr[0]).key_offsets.size() - 1 : 0;
+      } else if (t.blob_type == BLOB_TYPE_CRYPTONOTE_XHV) {
         mixin = t.vin.empty() ? 0 :
-	t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 :
-	t.vin[0].type() == typeid(txin_offshore) ? boost::get<txin_offshore>(t.vin[0]).key_offsets.size() - 1 :
-	t.vin[0].type() == typeid(txin_onshore) ? boost::get<txin_onshore>(t.vin[0]).key_offsets.size() - 1 :
-	t.vin[0].type() == typeid(txin_xasset) ? boost::get<txin_xasset>(t.vin[0]).key_offsets.size() - 1 :
-	0;
+          t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 :
+          t.vin[0].type() == typeid(txin_offshore) ? boost::get<txin_offshore>(t.vin[0]).key_offsets.size() - 1 :
+          t.vin[0].type() == typeid(txin_onshore) ? boost::get<txin_onshore>(t.vin[0]).key_offsets.size() - 1 :
+          t.vin[0].type() == typeid(txin_xasset) ? boost::get<txin_xasset>(t.vin[0]).key_offsets.size() - 1 :
+          t.vin[0].type() == typeid(txin_haven_key) ? boost::get<txin_haven_key>(t.vin[0]).key_offsets.size() - 1 :
+          0;
+      } else {
+        mixin = t.vin.empty() ? 0 : t.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(t.vin[0]).key_offsets.size() - 1 : 0;
       }
       bool r = tt.rct_signatures.p.serialize_rctsig_prunable(ba, t.rct_signatures.type, inputs, outputs, mixin);
       CHECK_AND_ASSERT_MES(r, false, "Failed to serialize rct signatures prunable");
@@ -320,7 +287,11 @@ namespace cryptonote
     }
     crypto::hash tree_root_hash = get_tx_tree_hash(b);
     blob.append(reinterpret_cast<const char*>(&tree_root_hash), sizeof(tree_root_hash));
-    blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
+    if (b.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM) {
+      blob.append(tools::get_varint_data(b.tx_hashes.size()+2));
+    } else {
+      blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
+    }
     if (b.blob_type == BLOB_TYPE_CRYPTONOTE3) {
       blob.append(reinterpret_cast<const char*>(&b.uncle), sizeof(b.uncle));
     }
@@ -406,7 +377,7 @@ namespace cryptonote
     ss << b_blob;
     binary_archive<false> ba(ss);
     bool r = ::serialization::serialize(ba, b);
-    CHECK_AND_ASSERT_MES(r, false, "Failed to parse block from blob");
+    CHECK_AND_ASSERT_MES(r, false, "Failed to parse block from blob 1");
     return true;
   }
   //---------------------------------------------------------------
@@ -448,6 +419,12 @@ namespace cryptonote
     crypto::hash h = null_hash;
     size_t bl_sz = 0;
     get_transaction_hash(b.miner_tx, h, bl_sz);
+    if (b.blob_type == BLOB_TYPE_CRYPTONOTE_SALVIUM) {
+      txs_ids.push_back(h);
+      h = null_hash;
+      bl_sz = 0;
+      get_transaction_hash(b.protocol_tx, h, bl_sz);
+    }
     txs_ids.push_back(h);
     BOOST_FOREACH(auto& th, b.tx_hashes)
       txs_ids.push_back(th);

src/cryptonote_core/cryptonote_format_utils.h

@@ -78,12 +78,9 @@ namespace cryptonote
   bool get_block_header_hash(const block& b, crypto::hash& res);
   bool get_bytecoin_block_longhash(const block& blk, crypto::hash& res);
   bool parse_and_validate_block_from_blob(const blobdata& b_blob, block& b);
-  bool get_inputs_money_amount(const transaction& tx, uint64_t& money);
   std::map<std::string, uint64_t> get_outs_money_amount(const transaction& tx);
-  bool check_inputs_types_supported(const transaction& tx);
   bool check_outs_valid(const transaction& tx);
 
-  uint64_t get_block_height(const block& b);
   std::vector<uint64_t> relative_output_offsets_to_absolute(const std::vector<uint64_t>& off);
   std::vector<uint64_t> absolute_output_offsets_to_relative(const std::vector<uint64_t>& off);
   //---------------------------------------------------------------

src/main.cc

@@ -145,7 +145,7 @@ NAN_METHOD(convert_blob) { // (parentBlockBuffer, cnBlobType)
 
     block b = AUTO_VAL_INIT(b);
     b.set_blob_type(blob_type);
-    if (!parse_and_validate_block_from_blob(input, b)) return THROW_ERROR_EXCEPTION("Failed to parse block");
+    if (!parse_and_validate_block_from_blob(input, b)) return THROW_ERROR_EXCEPTION("Failed to parse block 2");
 
     if (blob_type == BLOB_TYPE_FORKNOTE2) {
         block parent_block;

src/ringct/rctTypes.h

@@ -87,6 +87,8 @@ namespace rct {
     typedef std::vector<key> keyV; //vector of keys
     typedef std::vector<keyV> keyM; //matrix of keys (indexed by column first)
 
+  static key null_key = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+  
     //containers For CT operations
     //if it's  representing a private ctkey then "dest" contains the secret key of the address
     // while "mask" contains a where C = aG + bH is CT pedersen commitment and b is the amount
@@ -236,11 +238,48 @@ namespace rct {
       END_SERIALIZE()
     };
 
+    struct BulletproofPlus
+    {
+      rct::keyV V;
+      rct::key A, A1, B;
+      rct::key r1, s1, d1;
+      rct::keyV L, R;
+
+      BulletproofPlus() {}
+      BulletproofPlus(const rct::key &V, const rct::key &A, const rct::key &A1, const rct::key &B, const rct::key &r1, const rct::key &s1, const rct::key &d1, const rct::keyV &L, const rct::keyV &R):
+        V({V}), A(A), A1(A1), B(B), r1(r1), s1(s1), d1(d1), L(L), R(R) {}
+      BulletproofPlus(const rct::keyV &V, const rct::key &A, const rct::key &A1, const rct::key &B, const rct::key &r1, const rct::key &s1, const rct::key &d1, const rct::keyV &L, const rct::keyV &R):
+        V(V), A(A), A1(A1), B(B), r1(r1), s1(s1), d1(d1), L(L), R(R) {}
+
+      bool operator==(const BulletproofPlus &other) const { return V == other.V && A == other.A && A1 == other.A1 && B == other.B && r1 == other.r1 && s1 == other.s1 && d1 == other.d1 && L == other.L && R == other.R; }
+
+      BEGIN_SERIALIZE_OBJECT()
+        // Commitments aren't saved, they're restored via outPk
+        // FIELD(V)
+        FIELD(A)
+        FIELD(A1)
+        FIELD(B)
+        FIELD(r1)
+        FIELD(s1)
+        FIELD(d1)
+        FIELD(L)
+        FIELD(R)
+
+        if (L.empty() || L.size() != R.size())
+          return false;
+      END_SERIALIZE()
+    };
+
     size_t n_bulletproof_amounts(const Bulletproof &proof);
     size_t n_bulletproof_max_amounts(const Bulletproof &proof);
     size_t n_bulletproof_amounts(const std::vector<Bulletproof> &proofs);
     size_t n_bulletproof_max_amounts(const std::vector<Bulletproof> &proofs);
 
+    size_t n_bulletproof_plus_amounts(const BulletproofPlus &proof);
+    size_t n_bulletproof_plus_max_amounts(const BulletproofPlus &proof);
+    size_t n_bulletproof_plus_amounts(const std::vector<BulletproofPlus> &proofs);
+    size_t n_bulletproof_plus_max_amounts(const std::vector<BulletproofPlus> &proofs);
+
     //A container to hold all signatures necessary for RingCT
     // rangeSigs holds all the rangeproof data of a transaction
     // MG holds the MLSAG signature of a transaction
@@ -258,11 +297,18 @@ namespace rct {
       RCTTypeCLSAGN = 6,
       RCTTypeHaven2 = 7, // Add public mask sum terms, remove extraneous fields (txnFee_usd,txnFee_xasset,txnOffshoreFee_usd,txnOffshoreFee_xasset)
       RCTTypeHaven3 = 8, // Add public mask sum term for collateral
+      RCTTypeBulletproofPlus = 9,
     };
     enum RangeProofType { RangeProofBorromean, RangeProofBulletproof, RangeProofMultiOutputBulletproof, RangeProofPaddedBulletproof };
     struct RCTConfig {
       RangeProofType range_proof_type;
       int bp_version;
+
+      BEGIN_SERIALIZE_OBJECT()
+        VERSION_FIELD(0)
+        VARINT_FIELD(range_proof_type)
+        VARINT_FIELD(bp_version)
+      END_SERIALIZE()
     };
     struct rctSigBase {
       uint8_t type;
@@ -281,6 +327,7 @@ namespace rct {
       xmr_amount txnOffshoreFee_usd = 0;
       xmr_amount txnOffshoreFee_xasset = 0;
       keyV maskSums; // contains 2 or 3 elements. 1. is the sum of masks of inputs. 2. is the sum of masks of change outputs. 3. mask of the col output.
+      key p_r;
 
       template<bool W, template <bool> class Archive>
       bool serialize_rctsig_base(Archive<W> &ar, size_t inputs, size_t outputs)
@@ -288,6 +335,66 @@ namespace rct {
         FIELD(type)
         if (type == RCTTypeNull)
           return ar.stream().good();
+        if (type != RCTTypeBulletproofPlus)
+          return serialize_rctsig_base_old(ar, inputs, outputs);
+        VARINT_FIELD(txnFee)
+        VARINT_FIELD(txnOffshoreFee)
+        // inputs/outputs not saved, only here for serialization help
+        // FIELD(message) - not serialized, it can be reconstructed
+        // FIELD(mixRing) - not serialized, it can be reconstructed
+        ar.tag("ecdhInfo");
+        ar.begin_array();
+        PREPARE_CUSTOM_VECTOR_SERIALIZATION(outputs, ecdhInfo);
+        if (ecdhInfo.size() != outputs)
+          return false;
+        for (size_t i = 0; i < outputs; ++i)
+        {
+          ar.begin_object();
+          if (!typename Archive<W>::is_saving())
+            memset(ecdhInfo[i].amount.bytes, 0, sizeof(ecdhInfo[i].amount.bytes));
+          crypto::hash8 &amount = (crypto::hash8&)ecdhInfo[i].amount;
+          FIELD(amount);
+          ar.end_object();
+          if (outputs - i > 1)
+            ar.delimit_array();
+        }
+        ar.end_array();
+        
+        ar.tag("outPk");
+        ar.begin_array();
+        PREPARE_CUSTOM_VECTOR_SERIALIZATION(outputs, outPk);
+        if (outPk.size() != outputs)
+          return false;
+        for (size_t i = 0; i < outputs; ++i)
+        {
+          FIELDS(outPk[i].mask)
+          if (outputs - i > 1)
+            ar.delimit_array();
+        }
+        ar.end_array();
+
+        // if txnOffshoreFee is not 0, it is a conversion tx
+        if (txnOffshoreFee) {
+          ar.tag("maskSums");
+          ar.begin_array();
+          PREPARE_CUSTOM_VECTOR_SERIALIZATION(3, maskSums);
+          if (maskSums.size() != 3)
+            return false;
+          FIELDS(maskSums[0])
+            ar.delimit_array();
+          FIELDS(maskSums[1])
+            ar.delimit_array();
+          FIELDS(maskSums[2])
+            ar.end_array();
+        }
+        if (crypto_verify_32(p_r.bytes, null_key.bytes))
+          FIELD(p_r)
+        return ar.stream().good();
+      }
+
+      template<bool W, template <bool> class Archive>
+      bool serialize_rctsig_base_old(Archive<W> &ar, size_t inputs, size_t outputs)
+      {
         if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeCLSAG && type != RCTTypeCLSAGN && type != RCTTypeHaven2 && type != RCTTypeHaven3)
           return false;
         VARINT_FIELD(txnFee)
@@ -432,10 +539,23 @@ namespace rct {
         }
         return ar.stream().good();
       }
+
+        BEGIN_SERIALIZE_OBJECT()
+          FIELD(type)
+          FIELD(message)
+          FIELD(mixRing)
+          FIELD(pseudoOuts)
+          FIELD(ecdhInfo)
+          FIELD(outPk)
+          VARINT_FIELD(txnFee)
+          VARINT_FIELD(txnOffshoreFee)
+          FIELD(maskSums)
+        END_SERIALIZE()
     };
     struct rctSigPrunable {
         std::vector<rangeSig> rangeSigs;
         std::vector<Bulletproof> bulletproofs;
+        std::vector<BulletproofPlus> bulletproofs_plus;
         std::vector<mgSig> MGs; // simple rct has N, full has 1
         std::vector<clsag> CLSAGs;
         keyV pseudoOuts; //C - for simple rct
@@ -444,11 +564,36 @@ namespace rct {
         template<bool W, template <bool> class Archive>
         bool serialize_rctsig_prunable(Archive<W> &ar, uint8_t type, size_t inputs, size_t outputs, size_t mixin)
         {
+          if (inputs >= 0xffffffff)
+            return false;
+          if (outputs >= 0xffffffff)
+            return false;
+          if (mixin >= 0xffffffff)
+            return false;
           if (type == RCTTypeNull)
             return ar.stream().good();
-          if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeCLSAG && type != RCTTypeCLSAGN && type != RCTTypeHaven2 && type != RCTTypeHaven3)
+          if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeCLSAG && type != RCTTypeCLSAGN && type != RCTTypeHaven2 && type != RCTTypeHaven3 && type != RCTTypeBulletproofPlus)
             return false;
-          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3)
+          if (type == RCTTypeBulletproofPlus)
+          {
+            uint32_t nbp = bulletproofs_plus.size();
+            VARINT_FIELD(nbp)
+            ar.tag("bpp");
+            ar.begin_array();
+            if (nbp > outputs)
+              return false;
+            PREPARE_CUSTOM_VECTOR_SERIALIZATION(nbp, bulletproofs_plus);
+            for (size_t i = 0; i < nbp; ++i)
+            {
+              FIELDS(bulletproofs_plus[i])
+              if (nbp - i > 1)
+                ar.delimit_array();
+            }
+            if (n_bulletproof_plus_max_amounts(bulletproofs_plus) < outputs)
+              return false;
+            ar.end_array();
+          }
+          else if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3)
           {
             uint32_t nbp = bulletproofs.size();
            if (type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3)
@@ -486,7 +631,7 @@ namespace rct {
             ar.end_array();
           }
 
-          if ((type == RCTTypeCLSAG) || (type == RCTTypeCLSAGN) || (type == RCTTypeHaven2) || (type == RCTTypeHaven3))
+          if (type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 || type == RCTTypeBulletproofPlus)
           {
             ar.tag("CLSAGs");
             ar.begin_array();
@@ -577,7 +722,7 @@ namespace rct {
             }
             ar.end_array();
           }
-          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3)
+          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 || type == RCTTypeBulletproofPlus)
           {
             ar.tag("pseudoOuts");
             ar.begin_array();
@@ -595,19 +740,32 @@ namespace rct {
           return ar.stream().good();
         }
 
+        BEGIN_SERIALIZE_OBJECT()
+          FIELD(rangeSigs)
+          FIELD(bulletproofs)
+          FIELD(bulletproofs_plus)
+          FIELD(MGs)
+          FIELD(CLSAGs)
+          FIELD(pseudoOuts)
+        END_SERIALIZE()
     };
     struct rctSig: public rctSigBase {
         rctSigPrunable p;
 
         keyV& get_pseudo_outs()
         {
-          return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 ? p.pseudoOuts : pseudoOuts;
+          return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 || type == RCTTypeBulletproofPlus ? p.pseudoOuts : pseudoOuts;
         }
 
         keyV const& get_pseudo_outs() const
         {
-          return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 ? p.pseudoOuts : pseudoOuts;
+          return type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 || type == RCTTypeBulletproofPlus ? p.pseudoOuts : pseudoOuts;
         }
+
+        BEGIN_SERIALIZE_OBJECT()
+          FIELDS((rctSigBase&)*this)
+          FIELD(p)
+        END_SERIALIZE()
     };
 
     //other basepoint H = toPoint(cn_fast_hash(G)), G the basepoint
@@ -713,7 +871,9 @@ namespace rct {
 
     bool is_rct_simple(int type);
     bool is_rct_bulletproof(int type);
+    bool is_rct_bulletproof_plus(int type);
     bool is_rct_borromean(int type);
+    bool is_rct_clsag(int type);
 
     static inline const rct::key &pk2rct(const crypto::public_key &pk) { return (const rct::key&)pk; }
     static inline const rct::key &sk2rct(const crypto::secret_key &sk) { return (const rct::key&)sk; }
@@ -769,5 +929,6 @@ VARIANT_TAG(binary_archive, rct::Bulletproof, 0x9c);
 VARIANT_TAG(binary_archive, rct::multisig_kLRki, 0x9d);
 VARIANT_TAG(binary_archive, rct::multisig_out, 0x9e);
 VARIANT_TAG(binary_archive, rct::clsag, 0x9f);
+VARIANT_TAG(binary_archive, rct::BulletproofPlus, 0xa0);
 
 #endif  /* RCTTYPES_H */

src/serialization/binary_archive.h

@@ -48,7 +48,7 @@ template <>
 struct binary_archive<false> : public binary_archive_base<std::istream, false>
 {
   explicit binary_archive(stream_type &s) : base_type(s) {
-    stream_type::streampos pos = stream_.tellg();
+    auto pos = stream_.tellg();
     stream_.seekg(0, std::ios_base::end);
     eof_pos_ = stream_.tellg();
     stream_.seekg(pos);

src/serialization/serialization.h

@@ -109,6 +109,13 @@ inline bool do_serialize(Archive &ar, bool &v)
     ar.serialize_varint(f); \
     if (!ar.stream().good()) return false; \
   } while(0);
+#define VERSION_FIELD(v)                       \
+  uint32_t version = v;                                \
+  do {                                         \
+    ar.tag("version");                         \
+    ar.serialize_varint(version);              \
+    if (!ar.stream().good()) return false;             \
+  } while(0);
 
 namespace serialization {
   namespace detail

src/serialization/zephyr_pricing_record.h

@@ -0,0 +1,177 @@
+// Copyright (c) 2019, Haven Protocol
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+
+#include <vector>
+
+#include "serialization.h"
+#include "zephyr_oracle/pricing_record.h"
+#include "cryptonote_config.h"
+
+// read
+template <template <bool> class Archive>
+bool do_serialize(Archive<false> &ar, zephyr_oracle::pricing_record &pr, uint8_t version)
+{
+  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)) {
+      return false;
+    }
+
+    zephyr_oracle::pricing_record_v1 pr_v1;
+    ar.serialize_blob(&pr_v1, sizeof(zephyr_oracle::pricing_record_v1), "");
+    if (!ar.good())
+      return false;
+
+    if (!pr_v1.write_to_pr(pr))
+      return false;
+  }
+
+  return true;
+}
+
+// write
+template <template <bool> class Archive>
+bool do_serialize(Archive<true> &ar, zephyr_oracle::pricing_record &pr, uint8_t version)
+{
+  ar.begin_string();
+
+  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), "");
+  }
+
+  if (!ar.good())
+    return false;
+  ar.end_string();
+  return true;
+}
+
+// read
+template <template <bool> class Archive>
+bool do_serialize(Archive<false> &ar, zephyr_oracle::pricing_record_v1 &pr, uint8_t version)
+{
+  // very basic sanity check
+  if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record_v1)) {
+    return false;
+  }
+
+  ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record_v1), "");
+  if (!ar.good())
+    return false;
+
+  return true;
+}
+
+// write
+template <template <bool> class Archive>
+bool do_serialize(Archive<true> &ar, zephyr_oracle::pricing_record_v1 &pr, uint8_t version)
+{
+  ar.begin_string();
+  ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record_v1), "");
+  if (!ar.good())
+    return false;
+  ar.end_string();
+  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/asset_types.h

@@ -0,0 +1,77 @@
+// Copyright (c) 2021, Haven Protocol
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+#include <string>
+#include <vector>
+
+namespace zephyr_oracle {
+
+  const std::vector<std::string> ASSET_TYPES = {"ZEPH", "ZEPHUSD", "ZEPHRSV"};
+
+  class asset_type_counts
+  {
+
+    public:
+
+      // Fields 
+      uint64_t ZEPH;
+      uint64_t ZEPHUSD;
+      uint64_t ZEPHRSV;
+
+      asset_type_counts() noexcept
+        : ZEPH(0)
+        , ZEPHUSD(0)
+        , ZEPHRSV(0)
+      {
+      }
+
+      uint64_t operator[](const std::string asset_type) const noexcept
+      {
+        if (asset_type == "ZEPH") {
+          return ZEPH;
+        } else if (asset_type == "ZEPHUSD") {
+          return ZEPHUSD;
+        } else if (asset_type == "ZEPHRSV") {
+          return ZEPHRSV;
+        }
+
+        return 0;
+      }
+
+      void add(const std::string asset_type, const uint64_t val)
+      {
+        if (asset_type == "ZEPH") {
+          ZEPH += val;
+        } else if (asset_type == "ZEPHUSD") {
+          ZEPHUSD += val;
+        } else if (asset_type == "ZEPHRSV") {
+          ZEPHRSV += val;
+        }
+      }
+  };
+}

src/zephyr_oracle/pricing_record.cpp

@@ -0,0 +1,292 @@
+// Copyright (c) 2019, Haven Protocol
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Portions of this code based upon code Copyright (c) 2019, The Monero Project
+
+#include "pricing_record.h"
+
+#include "serialization/keyvalue_serialization.h"
+#include "storages/portable_storage.h"
+
+#include "string_tools.h"
+namespace zephyr_oracle
+{
+
+  namespace
+  {
+    struct pr_serialized
+    {
+      uint64_t spot;
+      uint64_t moving_average;
+      uint64_t stable;
+      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;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(spot)
+        KV_SERIALIZE(moving_average)
+        KV_SERIALIZE(stable)
+        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()
+    };
+  }
+  
+  pricing_record::pricing_record() noexcept
+    : spot(0)
+    , moving_average(0)
+    , stable(0)
+    , stable_ma(0)
+    , reserve(0)
+    , reserve_ma(0)
+    , reserve_ratio(0)
+    , reserve_ratio_ma(0)
+    , timestamp(0)
+  {
+    std::memset(signature, 0, sizeof(signature));
+  }
+
+  bool pricing_record::_load(epee::serialization::portable_storage& src, epee::serialization::section* hparent)
+  {
+    pr_serialized in{};
+    if (in._load(src, hparent))
+    {
+      // Copy everything into the local instance
+      spot = in.spot;
+      moving_average = in.moving_average;
+      stable = in.stable;
+      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);
+        signature[i>>1] = (char) strtol(byteString.c_str(), NULL, 16);
+      }
+      return true;
+    }
+
+    // Report error here?
+    return false;
+  }
+
+  bool pricing_record::store(epee::serialization::portable_storage& dest, epee::serialization::section* hparent) const
+  {
+    std::string sig_hex;
+    for (unsigned int i=0; i<64; i++) {
+      std::stringstream ss;
+      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,reserve_ratio,reserve_ratio_ma,timestamp,sig_hex};
+    return out.store(dest, hparent);
+  }
+
+  pricing_record::pricing_record(const pricing_record& orig) noexcept
+    : spot(orig.spot)
+    , moving_average(orig.moving_average)
+    , stable(orig.stable)
+    , 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));
+  }
+
+  pricing_record& pricing_record::operator=(const pricing_record& orig) noexcept
+  {
+    spot = orig.spot;
+    moving_average = orig.moving_average;
+    stable = orig.stable;
+    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;
+  }
+  
+  bool pricing_record::equal(const pricing_record& other) const noexcept
+  {
+    return ((spot == other.spot) &&
+      (moving_average == other.moving_average) &&
+      (stable == other.stable) &&
+      (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)));
+  }
+
+  bool pricing_record::empty() const noexcept
+  {
+    const pricing_record empty_pr = zephyr_oracle::pricing_record();
+    return (*this).equal(empty_pr);
+  }
+
+  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?
+
+    // extract the key
+    EVP_PKEY* pubkey;
+    BIO* bio = BIO_new_mem_buf(public_key.c_str(), public_key.size());
+    if (!bio) {
+      return false;
+    }
+    pubkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
+    BIO_free(bio);
+    CHECK_AND_ASSERT_THROW_MES(pubkey != NULL, "Pricing record verification failed. NULL public key.");
+
+    // Convert our internal 64-byte binary representation into 128-byte hex string
+    std::string sig_hex;
+    for (unsigned int i=0; i<64; i++) {
+      std::stringstream ss;
+      ss << std::hex << std::setw(2) << std::setfill('0') << (0xff & signature[i]);
+      sig_hex += ss.str();
+    }
+
+    // Build the JSON string, so that we can verify the signature
+    std::ostringstream oss;
+    oss << "{\"spot\":" << spot;
+    if (hf_version <= 4) {
+      oss << ",\"moving_average\":" << moving_average;
+    }
+    oss << ",\"timestamp\":" << timestamp;
+    oss << "}";
+    std::string message = oss.str();
+
+    // Create a verify digest from the message
+    EVP_MD_CTX *ctx = EVP_MD_CTX_create();
+    int ret = 0;
+    if (ctx) {
+      ret = EVP_DigestVerifyInit(ctx, NULL, EVP_sha256(), NULL, pubkey);
+      if (ret == 1) {
+        ret = EVP_DigestVerifyUpdate(ctx, message.data(), message.length());
+        if (ret == 1) {
+          ret = EVP_DigestVerifyFinal(ctx, (const unsigned char *)signature, 64);
+        }
+      }
+    }
+
+    // Cleanup the context we created
+    EVP_MD_CTX_destroy(ctx);
+    // Cleanup the openssl stuff
+    EVP_PKEY_free(pubkey);
+
+    if (ret == 1)
+      return true;
+
+    // Get the errors from OpenSSL
+    // ERR_print_errors_fp (stderr);
+
+    return false;
+  }
+
+  bool pricing_record::has_missing_rates(const uint8_t hf_version) const noexcept
+  {
+    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
+  bool pricing_record::valid(uint32_t hf_version, uint64_t bl_timestamp, uint64_t last_bl_timestamp) const 
+  {
+    if (hf_version < 3) {
+      if (!this->empty())
+        return false;
+    }
+
+    if (this->empty())
+        return true;
+
+    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"
+    "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAO5hVuc6ylYMbj3WhqOMoAcJ0SD4e3zW\n"
+    "edsUmhQeYwBkelAaFyxhX4ZotP+b/cFr2mX5iuND1znEnMZkyg+YmtkCAwEAAQ==\n"
+    "-----END PUBLIC KEY-----\n";
+
+    if (!verifySignature(MAINNET_ORACLE_PUBLIC_KEY, hf_version)) {
+      LOG_ERROR("Invalid pricing record signature.");
+      return false;
+    }
+
+    // validate the timestmap
+    if (this->timestamp > bl_timestamp + PRICING_RECORD_VALID_TIME_DIFF_FROM_BLOCK) {
+      LOG_ERROR("Pricing record timestamp is too far in the future.");
+      return false;
+    }
+
+    if (this->timestamp <= last_bl_timestamp) {
+      LOG_ERROR("Pricing record timestamp: " << this->timestamp << ", block timestamp: " << bl_timestamp);
+      LOG_ERROR("Pricing record timestamp is too old.");
+      return false;
+    }
+
+    return true;
+  }
+}
+

src/zephyr_oracle/pricing_record.h

@@ -0,0 +1,195 @@
+// Copyright (c) 2019, Haven Protocol
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Portions of this code based upon code Copyright (c) 2019, The Monero Project
+
+#pragma once
+#include "common/pod-class.h"
+
+#include <openssl/bio.h>
+#include <openssl/crypto.h>
+#include <openssl/ecdsa.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/ssl.h>
+
+#include <cstdint>
+#include <string>
+#include <cstring>
+
+#include "cryptonote_config.h"
+#include "crypto/hash.h"
+
+namespace epee
+{
+  namespace serialization
+  {
+    class portable_storage;
+    struct section;
+  }
+}
+
+namespace zephyr_oracle
+{
+  #pragma pack(push, 1)
+  POD_CLASS pricing_record_pre {
+    uint64_t zEPHUSD;
+    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
+  {
+
+    public:
+
+      // Fields 
+      uint64_t spot;
+      uint64_t moving_average;
+      uint64_t stable;
+      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];
+
+      // Default c'tor
+      pricing_record() noexcept;
+      //! Load from epee p2p format
+      bool _load(epee::serialization::portable_storage& src, epee::serialization::section* hparent);
+      //! Store in epee p2p format
+      bool store(epee::serialization::portable_storage& dest, epee::serialization::section* hparent) const;
+      pricing_record(const pricing_record& orig) noexcept;
+      ~pricing_record() = default;
+      bool equal(const pricing_record& other) const noexcept;
+      bool empty() 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;
+      uint64_t operator[](const std::string& asset_type) const;
+  };
+
+  inline bool operator==(const pricing_record& a, const pricing_record& b) noexcept
+  {
+   return a.equal(b);
+  }
+  
+  inline bool operator!=(const pricing_record& a, const pricing_record& b) noexcept
+  {
+   return !a.equal(b);
+  }
+
+  class pricing_record_v1
+  {
+
+  public:
+    uint64_t zEPHUSD;
+    uint64_t zEPHRSV;
+    uint64_t timestamp;
+
+    bool write_to_pr(zephyr_oracle::pricing_record &pr)
+    {
+      pr.spot = 0;
+      pr.moving_average = 0;
+      pr.stable = 0;
+      pr.stable_ma = 0;
+      pr.reserve = 0;
+      pr.reserve_ma = 0;
+      pr.timestamp = 0;
+      std::memset(pr.signature, 0, sizeof(zephyr_oracle::pricing_record::signature));
+      return true;
+    };
+
+    bool read_from_pr(zephyr_oracle::pricing_record &pr)
+    {
+      zEPHUSD = 0;
+      zEPHRSV = 0;
+      timestamp = 0;
+      return true;
+    };
+  };
+
+  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