Updated for Ubuntu 24.04

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

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

package.json

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

rtm.js

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

src/contrib/epee/include/serialization/keyvalue_serialization_overloads.h

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

src/crypto/crypto.cpp

@@ -50,279 +50,8 @@ namespace crypto {
     return &reinterpret_cast<const unsigned char &>(scalar);
   }
 
-  static inline void random_scalar(ec_scalar &res) {
-    unsigned char tmp[64];
-    generate_random_bytes(64, tmp);
-    sc_reduce(tmp);
-    memcpy(&res, tmp, 32);
-  }
-
-  static inline void hash_to_scalar(const void *data, size_t length, ec_scalar &res) {
-    cn_fast_hash(data, length, reinterpret_cast<hash &>(res));
-    sc_reduce32(&res);
-  }
-
-  void crypto_ops::generate_keys(public_key &pub, secret_key &sec) {
-    lock_guard<mutex> lock(random_lock);
-    ge_p3 point;
-    random_scalar(sec);
-    ge_scalarmult_base(&point, &sec);
-    ge_p3_tobytes(&pub, &point);
-  }
-
   bool crypto_ops::check_key(const public_key &key) {
     ge_p3 point;
     return ge_frombytes_vartime(&point, &key) == 0;
   }
-
-  bool crypto_ops::secret_key_to_public_key(const secret_key &sec, public_key &pub) {
-    ge_p3 point;
-    if (sc_check(&sec) != 0) {
-      return false;
-    }
-    ge_scalarmult_base(&point, &sec);
-    ge_p3_tobytes(&pub, &point);
-    return true;
-  }
-
-  bool crypto_ops::generate_key_derivation(const public_key &key1, const secret_key &key2, key_derivation &derivation) {
-    ge_p3 point;
-    ge_p2 point2;
-    ge_p1p1 point3;
-    assert(sc_check(&key2) == 0);
-    if (ge_frombytes_vartime(&point, &key1) != 0) {
-      return false;
-    }
-    ge_scalarmult(&point2, &key2, &point);
-    ge_mul8(&point3, &point2);
-    ge_p1p1_to_p2(&point2, &point3);
-    ge_tobytes(&derivation, &point2);
-    return true;
-  }
-
-  static void derivation_to_scalar(const key_derivation &derivation, size_t output_index, ec_scalar &res) {
-    struct {
-      key_derivation derivation;
-      char output_index[(sizeof(size_t) * 8 + 6) / 7];
-    } buf;
-    char *end = buf.output_index;
-    buf.derivation = derivation;
-    tools::write_varint(end, output_index);
-    assert(end <= buf.output_index + sizeof buf.output_index);
-    hash_to_scalar(&buf, end - reinterpret_cast<char *>(&buf), res);
-  }
-
-  bool crypto_ops::derive_public_key(const key_derivation &derivation, size_t output_index,
-    const public_key &base, public_key &derived_key) {
-    ec_scalar scalar;
-    ge_p3 point1;
-    ge_p3 point2;
-    ge_cached point3;
-    ge_p1p1 point4;
-    ge_p2 point5;
-    if (ge_frombytes_vartime(&point1, &base) != 0) {
-      return false;
-    }
-    derivation_to_scalar(derivation, output_index, scalar);
-    ge_scalarmult_base(&point2, &scalar);
-    ge_p3_to_cached(&point3, &point2);
-    ge_add(&point4, &point1, &point3);
-    ge_p1p1_to_p2(&point5, &point4);
-    ge_tobytes(&derived_key, &point5);
-    return true;
-  }
-
-  void crypto_ops::derive_secret_key(const key_derivation &derivation, size_t output_index,
-    const secret_key &base, secret_key &derived_key) {
-    ec_scalar scalar;
-    assert(sc_check(&base) == 0);
-    derivation_to_scalar(derivation, output_index, scalar);
-    sc_add(&derived_key, &base, &scalar);
-  }
-
-  struct s_comm {
-    hash h;
-    ec_point key;
-    ec_point comm;
-  };
-
-  void crypto_ops::generate_signature(const hash &prefix_hash, const public_key &pub, const secret_key &sec, signature &sig) {
-    lock_guard<mutex> lock(random_lock);
-    ge_p3 tmp3;
-    ec_scalar k;
-    s_comm buf;
-#if !defined(NDEBUG)
-    {
-      ge_p3 t;
-      public_key t2;
-      assert(sc_check(&sec) == 0);
-      ge_scalarmult_base(&t, &sec);
-      ge_p3_tobytes(&t2, &t);
-      assert(pub == t2);
-    }
-#endif
-    buf.h = prefix_hash;
-    buf.key = pub;
-    random_scalar(k);
-    ge_scalarmult_base(&tmp3, &k);
-    ge_p3_tobytes(&buf.comm, &tmp3);
-    hash_to_scalar(&buf, sizeof(s_comm), sig.c);
-    sc_mulsub(&sig.r, &sig.c, &sec, &k);
-  }
-
-  bool crypto_ops::check_signature(const hash &prefix_hash, const public_key &pub, const signature &sig) {
-    ge_p2 tmp2;
-    ge_p3 tmp3;
-    ec_scalar c;
-    s_comm buf;
-    assert(check_key(pub));
-    buf.h = prefix_hash;
-    buf.key = pub;
-    if (ge_frombytes_vartime(&tmp3, &pub) != 0) {
-      abort();
-    }
-    if (sc_check(&sig.c) != 0 || sc_check(&sig.r) != 0) {
-      return false;
-    }
-    ge_double_scalarmult_base_vartime(&tmp2, &sig.c, &tmp3, &sig.r);
-    ge_tobytes(&buf.comm, &tmp2);
-    hash_to_scalar(&buf, sizeof(s_comm), c);
-    sc_sub(&c, &c, &sig.c);
-    return sc_isnonzero(&c) == 0;
-  }
-
-  static void hash_to_ec(const public_key &key, ge_p3 &res) {
-    hash h;
-    ge_p2 point;
-    ge_p1p1 point2;
-    cn_fast_hash(std::addressof(key), sizeof(public_key), h);
-    ge_fromfe_frombytes_vartime(&point, reinterpret_cast<const unsigned char *>(&h));
-    ge_mul8(&point2, &point);
-    ge_p1p1_to_p3(&res, &point2);
-  }
-
-  void crypto_ops::generate_key_image(const public_key &pub, const secret_key &sec, key_image &image) {
-    ge_p3 point;
-    ge_p2 point2;
-    assert(sc_check(&sec) == 0);
-    hash_to_ec(pub, point);
-    ge_scalarmult(&point2, &sec, &point);
-    ge_tobytes(&image, &point2);
-  }
-
-PUSH_WARNINGS
-DISABLE_VS_WARNINGS(4200)
-  struct rs_comm {
-    hash h;
-    struct {
-      ec_point a, b;
-    } ab[];
-  } rcs;
-POP_WARNINGS
-
-  static inline size_t rs_comm_size(size_t pubs_count) {
-    return sizeof(rs_comm) + pubs_count * sizeof(rcs.ab[0]);
-  }
-
-  void crypto_ops::generate_ring_signature(const hash &prefix_hash, const key_image &image,
-    const public_key *const *pubs, size_t pubs_count,
-    const secret_key &sec, size_t sec_index,
-    signature *sig) {
-    lock_guard<mutex> lock(random_lock);
-    size_t i;
-    ge_p3 image_unp;
-    ge_dsmp image_pre;
-    ec_scalar sum, k, h;
-    rs_comm *const buf = reinterpret_cast<rs_comm *>(alloca(rs_comm_size(pubs_count)));
-    assert(sec_index < pubs_count);
-#if !defined(NDEBUG)
-    {
-      ge_p3 t;
-      public_key t2;
-      key_image t3;
-      assert(sc_check(&sec) == 0);
-      ge_scalarmult_base(&t, &sec);
-      ge_p3_tobytes(&t2, &t);
-      assert(*pubs[sec_index] == t2);
-      generate_key_image(*pubs[sec_index], sec, t3);
-      assert(image == t3);
-      for (i = 0; i < pubs_count; i++) {
-        assert(check_key(*pubs[i]));
-      }
-    }
-#endif
-    if (ge_frombytes_vartime(&image_unp, &image) != 0) {
-      abort();
-    }
-    ge_dsm_precomp(image_pre, &image_unp);
-    sc_0(&sum);
-    buf->h = prefix_hash;
-    for (i = 0; i < pubs_count; i++) {
-      ge_p2 tmp2;
-      ge_p3 tmp3;
-      if (i == sec_index) {
-        random_scalar(k);
-        ge_scalarmult_base(&tmp3, &k);
-        ge_p3_tobytes(&buf->ab[i].a, &tmp3);
-        hash_to_ec(*pubs[i], tmp3);
-        ge_scalarmult(&tmp2, &k, &tmp3);
-        ge_tobytes(&buf->ab[i].b, &tmp2);
-      } else {
-        random_scalar(sig[i].c);
-        random_scalar(sig[i].r);
-        if (ge_frombytes_vartime(&tmp3, &*pubs[i]) != 0) {
-          abort();
-        }
-        ge_double_scalarmult_base_vartime(&tmp2, &sig[i].c, &tmp3, &sig[i].r);
-        ge_tobytes(&buf->ab[i].a, &tmp2);
-        hash_to_ec(*pubs[i], tmp3);
-        ge_double_scalarmult_precomp_vartime(&tmp2, &sig[i].r, &tmp3, &sig[i].c, image_pre);
-        ge_tobytes(&buf->ab[i].b, &tmp2);
-        sc_add(&sum, &sum, &sig[i].c);
-      }
-    }
-    hash_to_scalar(buf, rs_comm_size(pubs_count), h);
-    sc_sub(&sig[sec_index].c, &h, &sum);
-    sc_mulsub(&sig[sec_index].r, &sig[sec_index].c, &sec, &k);
-  }
-
-  bool crypto_ops::check_ring_signature(const hash &prefix_hash, const key_image &image,
-    const public_key *const *pubs, size_t pubs_count,
-    const signature *sig) {
-    size_t i;
-    ge_p3 image_unp;
-    ge_dsmp image_pre;
-    ec_scalar sum, h;
-    rs_comm *const buf = reinterpret_cast<rs_comm *>(alloca(rs_comm_size(pubs_count)));
-#if !defined(NDEBUG)
-    for (i = 0; i < pubs_count; i++) {
-      assert(check_key(*pubs[i]));
-    }
-#endif
-    if (ge_frombytes_vartime(&image_unp, &image) != 0) {
-      return false;
-    }
-    ge_dsm_precomp(image_pre, &image_unp);
-    sc_0(&sum);
-    buf->h = prefix_hash;
-    for (i = 0; i < pubs_count; i++) {
-      ge_p2 tmp2;
-      ge_p3 tmp3;
-      if (sc_check(&sig[i].c) != 0 || sc_check(&sig[i].r) != 0) {
-        return false;
-      }
-      if (ge_frombytes_vartime(&tmp3, &*pubs[i]) != 0) {
-        abort();
-      }
-      ge_double_scalarmult_base_vartime(&tmp2, &sig[i].c, &tmp3, &sig[i].r);
-      ge_tobytes(&buf->ab[i].a, &tmp2);
-      hash_to_ec(*pubs[i], tmp3);
-      ge_double_scalarmult_precomp_vartime(&tmp2, &sig[i].r, &tmp3, &sig[i].c, image_pre);
-      ge_tobytes(&buf->ab[i].b, &tmp2);
-      sc_add(&sum, &sum, &sig[i].c);
-    }
-    hash_to_scalar(buf, rs_comm_size(pubs_count), h);
-    sc_sub(&h, &h, &sum);
-    return sc_isnonzero(&h) == 0;
-  }
 }

src/crypto/crypto.h

@@ -49,12 +49,16 @@ namespace crypto {
     ec_scalar c, r;
     friend class crypto_ops;
   };
+
+  POD_CLASS view_tag {
+    char data;
+  };
 #pragma pack(pop)
 
   static_assert(sizeof(ec_point) == 32 && sizeof(ec_scalar) == 32 &&
     sizeof(public_key) == 32 && sizeof(secret_key) == 32 &&
     sizeof(key_derivation) == 32 && sizeof(key_image) == 32 &&
-    sizeof(signature) == 64, "Invalid structure size");
+    sizeof(signature) == 64 && sizeof(view_tag) == 1, "Invalid structure size");
 
   class crypto_ops {
     crypto_ops();
@@ -62,32 +66,8 @@ namespace crypto {
     void operator=(const crypto_ops &);
     ~crypto_ops();
 
-    static void generate_keys(public_key &, secret_key &);
-    friend void generate_keys(public_key &, secret_key &);
     static bool check_key(const public_key &);
     friend bool check_key(const public_key &);
-    static bool secret_key_to_public_key(const secret_key &, public_key &);
-    friend bool secret_key_to_public_key(const secret_key &, public_key &);
-    static bool generate_key_derivation(const public_key &, const secret_key &, key_derivation &);
-    friend bool generate_key_derivation(const public_key &, const secret_key &, key_derivation &);
-    static bool derive_public_key(const key_derivation &, std::size_t, const public_key &, public_key &);
-    friend bool derive_public_key(const key_derivation &, std::size_t, const public_key &, public_key &);
-    static void derive_secret_key(const key_derivation &, std::size_t, const secret_key &, secret_key &);
-    friend void derive_secret_key(const key_derivation &, std::size_t, const secret_key &, secret_key &);
-    static void generate_signature(const hash &, const public_key &, const secret_key &, signature &);
-    friend void generate_signature(const hash &, const public_key &, const secret_key &, signature &);
-    static bool check_signature(const hash &, const public_key &, const signature &);
-    friend bool check_signature(const hash &, const public_key &, const signature &);
-    static void generate_key_image(const public_key &, const secret_key &, key_image &);
-    friend void generate_key_image(const public_key &, const secret_key &, key_image &);
-    static void generate_ring_signature(const hash &, const key_image &,
-      const public_key *const *, std::size_t, const secret_key &, std::size_t, signature *);
-    friend void generate_ring_signature(const hash &, const key_image &,
-      const public_key *const *, std::size_t, const secret_key &, std::size_t, signature *);
-    static bool check_ring_signature(const hash &, const key_image &,
-      const public_key *const *, std::size_t, const signature *);
-    friend bool check_ring_signature(const hash &, const key_image &,
-      const public_key *const *, std::size_t, const signature *);
   };
 
   /* Generate a value filled with random bytes.
@@ -100,87 +80,14 @@ namespace crypto {
     return res;
   }
 
-  /* Generate a new key pair
-   */
-  inline void generate_keys(public_key &pub, secret_key &sec) {
-    crypto_ops::generate_keys(pub, sec);
-  }
-
   /* Check a public key. Returns true if it is valid, false otherwise.
    */
   inline bool check_key(const public_key &key) {
     return crypto_ops::check_key(key);
   }
-
-  /* Checks a private key and computes the corresponding public key.
-   */
-  inline bool secret_key_to_public_key(const secret_key &sec, public_key &pub) {
-    return crypto_ops::secret_key_to_public_key(sec, pub);
-  }
-
-  /* To generate an ephemeral key used to send money to:
-   * * The sender generates a new key pair, which becomes the transaction key. The public transaction key is included in "extra" field.
-   * * Both the sender and the receiver generate key derivation from the transaction key, the receivers' "view" key and the output index.
-   * * The sender uses key derivation and the receivers' "spend" key to derive an ephemeral public key.
-   * * The receiver can either derive the public key (to check that the transaction is addressed to him) or the private key (to spend the money).
-   */
-  inline bool generate_key_derivation(const public_key &key1, const secret_key &key2, key_derivation &derivation) {
-    return crypto_ops::generate_key_derivation(key1, key2, derivation);
-  }
-  inline bool derive_public_key(const key_derivation &derivation, std::size_t output_index,
-    const public_key &base, public_key &derived_key) {
-    return crypto_ops::derive_public_key(derivation, output_index, base, derived_key);
-  }
-  inline void derive_secret_key(const key_derivation &derivation, std::size_t output_index,
-    const secret_key &base, secret_key &derived_key) {
-    crypto_ops::derive_secret_key(derivation, output_index, base, derived_key);
-  }
-
-  /* Generation and checking of a standard signature.
-   */
-  inline void generate_signature(const hash &prefix_hash, const public_key &pub, const secret_key &sec, signature &sig) {
-    crypto_ops::generate_signature(prefix_hash, pub, sec, sig);
-  }
-  inline bool check_signature(const hash &prefix_hash, const public_key &pub, const signature &sig) {
-    return crypto_ops::check_signature(prefix_hash, pub, sig);
-  }
-
-  /* To send money to a key:
-   * * The sender generates an ephemeral key and includes it in transaction output.
-   * * To spend the money, the receiver generates a key image from it.
-   * * Then he selects a bunch of outputs, including the one he spends, and uses them to generate a ring signature.
-   * To check the signature, it is necessary to collect all the keys that were used to generate it. To detect double spends, it is necessary to check that each key image is used at most once.
-   */
-  inline void generate_key_image(const public_key &pub, const secret_key &sec, key_image &image) {
-    crypto_ops::generate_key_image(pub, sec, image);
-  }
-  inline void generate_ring_signature(const hash &prefix_hash, const key_image &image,
-    const public_key *const *pubs, std::size_t pubs_count,
-    const secret_key &sec, std::size_t sec_index,
-    signature *sig) {
-    crypto_ops::generate_ring_signature(prefix_hash, image, pubs, pubs_count, sec, sec_index, sig);
-  }
-  inline bool check_ring_signature(const hash &prefix_hash, const key_image &image,
-    const public_key *const *pubs, std::size_t pubs_count,
-    const signature *sig) {
-    return crypto_ops::check_ring_signature(prefix_hash, image, pubs, pubs_count, sig);
-  }
-
-  /* Variants with vector<const public_key *> parameters.
-   */
-  inline void generate_ring_signature(const hash &prefix_hash, const key_image &image,
-    const std::vector<const public_key *> &pubs,
-    const secret_key &sec, std::size_t sec_index,
-    signature *sig) {
-    generate_ring_signature(prefix_hash, image, pubs.data(), pubs.size(), sec, sec_index, sig);
-  }
-  inline bool check_ring_signature(const hash &prefix_hash, const key_image &image,
-    const std::vector<const public_key *> &pubs,
-    const signature *sig) {
-    return check_ring_signature(prefix_hash, image, pubs.data(), pubs.size(), sig);
-  }
 }
 
 CRYPTO_MAKE_COMPARABLE(public_key)
 CRYPTO_MAKE_HASHABLE(key_image)
 CRYPTO_MAKE_COMPARABLE(signature)
+CRYPTO_MAKE_COMPARABLE(view_tag)

src/cryptonote_config.h

@@ -1,9 +1,24 @@
 #pragma once
 
-#define CURRENT_TRANSACTION_VERSION  1
-#define OFFSHORE_TRANSACTION_VERSION 3
-#define HF_VERSION_XASSET_FEES_V2    17
-#define HF_VERSION_HAVEN2            18
+#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
+#define TX_V6_ONSHORE_UNLOCK_BLOCKS                     360     // 12 hour unlock time
+#define TX_V7_ONSHORE_UNLOCK_BLOCKS                     21*720 // 21 day unlock time
+#define TX_V6_XASSET_UNLOCK_BLOCKS                      1440    // 2 day unlock time
+#define TX_V6_OFFSHORE_UNLOCK_BLOCKS_TESTNET            60     // 2 hour unlock time - FOR TESTING ONLY
+#define TX_V6_ONSHORE_UNLOCK_BLOCKS_TESTNET             30     // 1 hour unlock time - FOR TESTING ONLY
+#define TX_V6_XASSET_UNLOCK_BLOCKS_TESTNET              60     // 2 hour unlock time - FOR TESTING ONLY
+
+#define PRICING_RECORD_VALID_TIME_DIFF_FROM_BLOCK       120  // seconds
 
 enum BLOB_TYPE {
   BLOB_TYPE_CRYPTONOTE        = 0,
@@ -19,4 +34,6 @@ 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
 };

src/cryptonote_core/cryptonote_basic.h

@@ -14,10 +14,9 @@
 #include "serialization/variant.h"
 #include "serialization/vector.h"
 #include "serialization/binary_archive.h"
-#include "serialization/json_archive.h"
-#include "serialization/debug_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"
@@ -28,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
@@ -67,6 +67,7 @@ namespace cryptonote
     crypto::hash hash;
   };
 
+  // outputs <= HF_VERSION_VIEW_TAGS
   struct txout_to_key
   {
     txout_to_key() { }
@@ -74,6 +75,62 @@ namespace cryptonote
     crypto::public_key key;
   };
 
+  // outputs >= HF_VERSION_VIEW_TAGS
+  struct txout_to_tagged_key
+  {
+    txout_to_tagged_key() { }
+    txout_to_tagged_key(const crypto::public_key &_key, const crypto::view_tag &_view_tag) : key(_key), view_tag(_view_tag) { }
+    crypto::public_key key;
+    crypto::view_tag view_tag; // optimization to reduce scanning time
+
+    BEGIN_SERIALIZE_OBJECT()
+      FIELD(key)
+      FIELD(view_tag)
+    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() { }
@@ -94,6 +151,22 @@ 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()
+  };
+
   /* inputs */
 
   struct txin_gen
@@ -172,6 +245,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;
@@ -186,12 +274,30 @@ 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;
+  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<txout_to_script, txout_to_scripthash, txout_to_key, txout_offshore, txout_xasset> txout_target_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_haven_key, txout_haven_tagged_key> txout_xhv_target_v;
+
+  typedef boost::variant<txout_to_script, txout_to_scripthash, txout_zephyr_tagged_key> txout_stablero_target_v;
 
-  //typedef std::pair<uint64_t, txout> out_t;
   struct tx_out
   {
     uint64_t amount;
@@ -203,6 +309,29 @@ namespace cryptonote
     END_SERIALIZE()
   };
 
+  struct tx_out_xhv
+  {
+    uint64_t amount;
+    txout_xhv_target_v target;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(amount)
+      FIELD(target)
+    END_SERIALIZE()
+  };
+
+  struct tx_out_zephyr
+  {
+    uint64_t amount;
+    txout_stablero_target_v target;
+
+    BEGIN_SERIALIZE_OBJECT()
+      VARINT_FIELD(amount)
+      FIELD(target)
+    END_SERIALIZE()
+  };
+
+
   enum loki_version
   {
     loki_version_0 = 0,
@@ -222,7 +351,10 @@ 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<tx_out> vout;
+    std::vector<tx_out_xhv> vout_xhv;
+    std::vector<tx_out_zephyr> vout_zephyr;
     //extra
     std::vector<uint8_t> extra;
     // Block height to use PR from
@@ -231,11 +363,12 @@ namespace cryptonote
     std::vector<uint8_t> offshore_data;
     uint64_t amount_burnt;
     uint64_t amount_minted;
+    std::vector<uint64_t> output_unlock_times;
+    std::vector<uint32_t> collateral_indices;
 
     //
     // NOTE: Loki specific
     //
-    std::vector<uint64_t> output_unlock_times;
     enum loki_type_t
     {
       loki_type_standard,
@@ -251,32 +384,289 @@ 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)
-      }
-      VARINT_FIELD(unlock_time)
-      FIELD(vin)
-      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_XHV && version >= OFFSHORE_TRANSACTION_VERSION) {
+      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;
+        }
+  
+        FIELD(vin)
+        FIELD(vout_xhv)
+        FIELD(extra)
         VARINT_FIELD(pricing_record_height)
-        if (version < 5)
-          FIELD(offshore_data)
         VARINT_FIELD(amount_burnt)
         VARINT_FIELD(amount_minted)
+  
+      } 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()
 
@@ -332,26 +722,37 @@ namespace cryptonote
       else
       {
         ar.tag("rct_signatures");
-        if (!vin.empty())
+        if (blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? !vin_zephyr.empty() : !vin.empty())
         {
           ar.begin_object();
-          bool r = rct_signatures.serialize_rctsig_base(ar, vin.size(), vout.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
+            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 {
-              r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
+            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_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();
@@ -382,13 +783,18 @@ 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;
     offshore_data.clear();
     amount_burnt = 0;
     amount_minted = 0;
+    output_unlock_times.clear();
+    collateral_indices.clear();
   }
 
   inline
@@ -403,6 +809,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);
@@ -523,9 +931,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)
@@ -547,6 +957,27 @@ namespace cryptonote
       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_ZEPHYR) {
+        if (major_version >= 3)
+        {
+          FIELD_N("pricing_record", zephyr_pricing_record)
+        }
+        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()
   };
@@ -616,19 +1047,6 @@ namespace cryptonote
     KV_SERIALIZE(payment_id)
     END_KV_SERIALIZE_MAP()
   };
-
-  struct keypair
-  {
-    crypto::public_key pub;
-    crypto::secret_key sec;
-
-    static inline keypair generate()
-    {
-      keypair k;
-      generate_keys(k.pub, k.sec);
-      return k;
-    }
-  };
   //---------------------------------------------------------------
 
 }
@@ -641,43 +1059,19 @@ 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_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_zephyr_tagged_key, 0x2);
+VARIANT_TAG(binary_archive, cryptonote::txout_to_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);
-
-VARIANT_TAG(json_archive, cryptonote::txin_gen, "gen");
-VARIANT_TAG(json_archive, cryptonote::txin_to_script, "script");
-VARIANT_TAG(json_archive, cryptonote::txin_to_scripthash, "scripthash");
-VARIANT_TAG(json_archive, cryptonote::txin_to_key, "key");
-VARIANT_TAG(json_archive, cryptonote::txin_offshore, "offshore");
-VARIANT_TAG(json_archive, cryptonote::txin_onshore, "onshore");
-VARIANT_TAG(json_archive, cryptonote::txin_xasset, "xasset");
-VARIANT_TAG(json_archive, cryptonote::txout_to_script, "script");
-VARIANT_TAG(json_archive, cryptonote::txout_to_scripthash, "scripthash");
-VARIANT_TAG(json_archive, cryptonote::txout_to_key, "key");
-VARIANT_TAG(json_archive, cryptonote::txout_offshore, "offshore");
-VARIANT_TAG(json_archive, cryptonote::txout_xasset, "xasset");
-VARIANT_TAG(json_archive, cryptonote::transaction, "tx");
-VARIANT_TAG(json_archive, cryptonote::block, "block");
-
-VARIANT_TAG(debug_archive, cryptonote::txin_gen, "gen");
-VARIANT_TAG(debug_archive, cryptonote::txin_to_script, "script");
-VARIANT_TAG(debug_archive, cryptonote::txin_to_scripthash, "scripthash");
-VARIANT_TAG(debug_archive, cryptonote::txin_to_key, "key");
-VARIANT_TAG(debug_archive, cryptonote::txin_offshore, "offshore");
-VARIANT_TAG(debug_archive, cryptonote::txin_onshore, "onshore");
-VARIANT_TAG(debug_archive, cryptonote::txin_xasset, "xasset");
-VARIANT_TAG(debug_archive, cryptonote::txout_to_script, "script");
-VARIANT_TAG(debug_archive, cryptonote::txout_to_scripthash, "scripthash");
-VARIANT_TAG(debug_archive, cryptonote::txout_to_key, "key");
-VARIANT_TAG(debug_archive, cryptonote::txout_offshore, "offshore");
-VARIANT_TAG(debug_archive, cryptonote::txout_xasset, "xasset");
-VARIANT_TAG(debug_archive, cryptonote::transaction, "tx");
-VARIANT_TAG(debug_archive, cryptonote::block, "block");

src/cryptonote_core/cryptonote_format_utils.cpp

@@ -56,85 +56,6 @@ namespace cryptonote
     return true;
   }
   //---------------------------------------------------------------
-  bool generate_key_image_helper(const account_keys& ack, const crypto::public_key& tx_public_key, size_t real_output_index, keypair& in_ephemeral, crypto::key_image& ki)
-  {
-    crypto::key_derivation recv_derivation = AUTO_VAL_INIT(recv_derivation);
-    bool r = crypto::generate_key_derivation(tx_public_key, ack.m_view_secret_key, recv_derivation);
-    CHECK_AND_ASSERT_MES(r, false, "key image helper: failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
-
-    r = crypto::derive_public_key(recv_derivation, real_output_index, ack.m_account_address.m_spend_public_key, in_ephemeral.pub);
-    CHECK_AND_ASSERT_MES(r, false, "key image helper: failed to derive_public_key(" << recv_derivation << ", " << real_output_index <<  ", " << ack.m_account_address.m_spend_public_key << ")");
-
-    crypto::derive_secret_key(recv_derivation, real_output_index, ack.m_spend_secret_key, in_ephemeral.sec);
-
-    crypto::generate_key_image(in_ephemeral.pub, in_ephemeral.sec, ki);
-    return true;
-  }
-  //---------------------------------------------------------------
-  uint64_t power_integral(uint64_t a, uint64_t b)
-  {
-    if(b == 0)
-      return 1;
-    uint64_t total = a;
-    for(uint64_t i = 1; i != b; i++)
-      total *= a;
-    return total;
-  }
-  //---------------------------------------------------------------
-  bool get_tx_fee(const transaction& tx, uint64_t & fee)
-  {
-    uint64_t amount_in = 0;
-    uint64_t amount_out = 0;
-    if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV)
-    {
-      // This is the correct way to get the fee for Haven, because outs may be in different currencies to ins
-      switch (tx.version) {
-      case 5:
-        fee = tx.rct_signatures.txnFee + tx.rct_signatures.txnOffshoreFee;
-        break;
-      case 4:
-      case 3:
-        if (tx.vin[0].type() == typeid(txin_to_key)) {
-          fee = tx.rct_signatures.txnFee + tx.rct_signatures.txnOffshoreFee;
-        } else if (tx.vin[0].type() == typeid(txin_offshore)) {
-          fee = tx.rct_signatures.txnFee_usd + tx.rct_signatures.txnOffshoreFee_usd;
-        } else if (tx.vin[0].type() == typeid(txin_onshore)) {
-          fee = tx.rct_signatures.txnFee_usd + tx.rct_signatures.txnOffshoreFee_usd;
-        } else if (tx.vin[0].type() == typeid(txin_xasset)) {
-          fee = tx.rct_signatures.txnFee_xasset + tx.rct_signatures.txnOffshoreFee_xasset;
-        } else {
-          CHECK_AND_ASSERT_MES(false, false, "unexpected type id in transaction");
-          return false;
-        }
-        break;
-      case 2:
-      case 1:
-        fee = tx.rct_signatures.txnFee;
-        break;
-      }
-      return true;
-    }
-    BOOST_FOREACH(auto& in, tx.vin)
-    {
-      CHECK_AND_ASSERT_MES(in.type() == typeid(txin_to_key), 0, "unexpected type id in transaction");
-      amount_in += boost::get<txin_to_key>(in).amount;
-    }
-    BOOST_FOREACH(auto& o, tx.vout)
-      amount_out += o.amount;
-
-    CHECK_AND_ASSERT_MES(amount_in >= amount_out, false, "transaction spend (" <<amount_in << ") more than it has (" << amount_out << ")");
-    fee = amount_in - amount_out;
-    return true;
-  }
-  //---------------------------------------------------------------
-  uint64_t get_tx_fee(const transaction& tx)
-  {
-    uint64_t r = 0;
-    if(!get_tx_fee(tx, r))
-      return 0;
-    return r;
-  }
-  //---------------------------------------------------------------
   bool parse_tx_extra(const std::vector<uint8_t>& tx_extra, std::vector<tx_extra_field>& tx_extra_fields)
   {
     tx_extra_fields.clear();
@@ -242,155 +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;
-  }
-  //-----------------------------------------------------------------------------------------------
-  bool check_outs_valid(const transaction& tx)
-  {
-    BOOST_FOREACH(const tx_out& out, tx.vout)
-    {
-      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
-        CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key), false, "wrong variant type: "
-          << out.target.type().name() << ", expected " << typeid(txout_to_key).name()
-          << ", in transaction id=" << get_transaction_hash(tx));
-      } else {
-	CHECK_AND_ASSERT_MES(out.target.type() == typeid(txout_to_key) ||
-			     out.target.type() == typeid(txout_offshore) ||
-			     out.target.type() == typeid(txout_xasset), false, "wrong variant type: "
-			     << out.target.type().name() << ", expected " << typeid(txout_to_key).name()
-			     << "or " << typeid(txout_offshore).name()
-			     << "or " << typeid(txout_xasset).name()
-			     << ", in transaction id=" << get_transaction_hash(tx));
-      }
-
-      if (tx.version == 1)
-      {
-        CHECK_AND_NO_ASSERT_MES(0 < out.amount, false, "zero amount ouput in transaction id=" << get_transaction_hash(tx));
-      }
-
-      if (tx.blob_type != BLOB_TYPE_CRYPTONOTE_XHV) {
-        if(!check_key(boost::get<txout_to_key>(out.target).key))
-          return false;
-      } else {
-	if(!check_key(out.target.type() == typeid(txout_to_key) ? boost::get<txout_to_key>(out.target).key :
-		      out.target.type() == typeid(txout_offshore) ? boost::get<txout_offshore>(out.target).key :
-		      boost::get<txout_xasset>(out.target).key))
-          return false;
-      }
-    }
-    return true;
-  }
-  //-----------------------------------------------------------------------------------------------
-  bool check_money_overflow(const transaction& tx)
-  {
-    return check_inputs_overflow(tx) && check_outs_overflow(tx);
-  }
-  //---------------------------------------------------------------
-  bool check_inputs_overflow(const transaction& tx)
-  {
-    uint64_t money = 0;
-    BOOST_FOREACH(const auto& in, tx.vin)
-    {
-      if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV && tx.vin[0].type() == typeid(txin_xasset)) {
-        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_xasset, tokey_in, false);
-        if(money > tokey_in.amount + money)
-          return false;
-        money += tokey_in.amount;
-      } else if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV && tx.vin[0].type() == typeid(txin_offshore)) {
-        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_offshore, tokey_in, false);
-        if(money > tokey_in.amount + money)
-          return false;
-        money += tokey_in.amount;
-      } else if (tx.blob_type == BLOB_TYPE_CRYPTONOTE_XHV && tx.vin[0].type() == typeid(txin_onshore)) {
-        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_onshore, tokey_in, false);
-        if(money > tokey_in.amount + money)
-          return false;
-        money += tokey_in.amount;
-      } else {
-        CHECKED_GET_SPECIFIC_VARIANT(in, const txin_to_key, tokey_in, false);
-        if(money > tokey_in.amount + money)
-          return false;
-        money += tokey_in.amount;
-      }
-    }
-    return true;
-  }
-  //---------------------------------------------------------------
-  bool check_outs_overflow(const transaction& tx)
-  {
-    uint64_t money = 0;
-    BOOST_FOREACH(const auto& o, tx.vout)
-    {
-      if(money > o.amount + money)
-        return false;
-      money += o.amount;
-    }
-    return true;
-  }
-  /*
-  //---------------------------------------------------------------
-  uint64_t get_outs_money_amount(const transaction& tx)
-  {
-    uint64_t outputs_amount = 0;
-    BOOST_FOREACH(const auto& o, tx.vout)
-      outputs_amount += o.amount;
-    return outputs_amount;
-  }
-  */
-  //---------------------------------------------------------------
-  std::map<std::string, uint64_t> get_outs_money_amount(const transaction& tx)
-  {
-    std::map<std::string, uint64_t> outputs_amount;
-    for(const auto& o: tx.vout) {
-      std::string asset_type;
-      if (o.target.type() == typeid(txout_offshore)) {
-        asset_type = "XUSD";
-      } else if (o.target.type() == typeid(txout_xasset)) {;
-        asset_type = boost::get<txout_xasset>(o.target).asset_type;
-      } else {
-        // this close covers miner tx and normal XHV ouputs.
-        asset_type = "XHV";
-      }
-      outputs_amount[asset_type] += o.amount;
-    }
-    return outputs_amount;
-  }
-  //---------------------------------------------------------------
   std::string short_hash_str(const crypto::hash& h)
   {
     std::string res = string_tools::pod_to_hex(h);
@@ -400,40 +172,6 @@ namespace cryptonote
     return res;
   }
   //---------------------------------------------------------------
-  bool is_out_to_acc(const account_keys& acc, const txout_to_key& out_key, const crypto::public_key& tx_pub_key, size_t output_index)
-  {
-    crypto::key_derivation derivation;
-    generate_key_derivation(tx_pub_key, acc.m_view_secret_key, derivation);
-    crypto::public_key pk;
-    derive_public_key(derivation, output_index, acc.m_account_address.m_spend_public_key, pk);
-    return pk == out_key.key;
-  }
-  //---------------------------------------------------------------
-  bool lookup_acc_outs(const account_keys& acc, const transaction& tx, std::vector<size_t>& outs, uint64_t& money_transfered)
-  {
-    crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
-    if(null_pkey == tx_pub_key)
-      return false;
-    return lookup_acc_outs(acc, tx, tx_pub_key, outs, money_transfered);
-  }
-  //---------------------------------------------------------------
-  bool lookup_acc_outs(const account_keys& acc, const transaction& tx, const crypto::public_key& tx_pub_key, std::vector<size_t>& outs, uint64_t& money_transfered)
-  {
-    money_transfered = 0;
-    size_t i = 0;
-    BOOST_FOREACH(const tx_out& o,  tx.vout)
-    {
-      CHECK_AND_ASSERT_MES(o.target.type() ==  typeid(txout_to_key), false, "wrong type id in transaction out" );
-      if(is_out_to_acc(acc, boost::get<txout_to_key>(o.target), tx_pub_key, i))
-      {
-        outs.push_back(i);
-        money_transfered += o.amount;
-      }
-      i++;
-    }
-    return true;
-  }
-  //---------------------------------------------------------------
   void get_blob_hash(const blobdata& blob, crypto::hash& res)
   {
     cn_fast_hash(blob.data(), blob.size(), res);
@@ -482,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.vout.size();
+      const size_t inputs = t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? t.vin_zephyr.size() : t.vin.size();
+      const size_t outputs = 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]);
@@ -498,18 +236,21 @@ namespace cryptonote
     {
       std::stringstream ss;
       binary_archive<true> ba(ss);
-      const size_t inputs = t.vin.size();
-      const size_t outputs = t.vout.size();
+      const size_t inputs = t.blob_type == BLOB_TYPE_CRYPTONOTE_ZEPHYR ? t.vin_zephyr.size() : t.vin.size();
+      const size_t outputs = 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_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");
@@ -630,7 +371,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;
   }
   //---------------------------------------------------------------

src/cryptonote_core/cryptonote_format_utils.h

@@ -63,12 +63,6 @@ namespace cryptonote
   bool get_payment_id_from_tx_extra_nonce(const blobdata& extra_nonce, crypto::hash& payment_id);
   bool append_mm_tag_to_extra(std::vector<uint8_t>& tx_extra, const tx_extra_merge_mining_tag& mm_tag);
   bool get_mm_tag_from_extra(const std::vector<uint8_t>& tx_extra, tx_extra_merge_mining_tag& mm_tag);
-  bool is_out_to_acc(const account_keys& acc, const txout_to_key& out_key, const crypto::public_key& tx_pub_key, size_t output_index);
-  bool lookup_acc_outs(const account_keys& acc, const transaction& tx, const crypto::public_key& tx_pub_key, std::vector<size_t>& outs, uint64_t& money_transfered);
-  bool lookup_acc_outs(const account_keys& acc, const transaction& tx, std::vector<size_t>& outs, uint64_t& money_transfered);
-  bool get_tx_fee(const transaction& tx, uint64_t & fee);
-  uint64_t get_tx_fee(const transaction& tx);
-  bool generate_key_image_helper(const account_keys& ack, const crypto::public_key& tx_public_key, size_t real_output_index, keypair& in_ephemeral, crypto::key_image& ki);
   void get_blob_hash(const blobdata& blob, crypto::hash& res);
   crypto::hash get_blob_hash(const blobdata& blob);
   std::string short_hash_str(const crypto::hash& h);
@@ -84,16 +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);
-  //uint64_t get_outs_money_amount(const transaction& tx);
   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);
 
-  bool check_money_overflow(const transaction& tx);
-  bool check_outs_overflow(const transaction& tx);
-  bool check_inputs_overflow(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);
   //---------------------------------------------------------------
@@ -138,16 +125,6 @@ namespace cryptonote
     return true;
   }
   //---------------------------------------------------------------
-  template <typename T>
-  std::string obj_to_json_str(T& obj)
-  {
-    std::stringstream ss;
-    json_archive<true> ar(ss, true);
-    bool r = ::serialization::serialize(ar, obj);
-    CHECK_AND_ASSERT_MES(r, "", "obj_to_json_str failed: serialization::serialize returned false");
-    return ss.str();
-  }
-  //---------------------------------------------------------------
   // 62387455827 -> 455827 + 7000000 + 80000000 + 300000000 + 2000000000 + 60000000000, where 455827 <= dust_threshold
   template<typename chunk_handler_t, typename dust_handler_t>
   void decompose_amount_into_digits(uint64_t amount, uint64_t dust_threshold, const chunk_handler_t& chunk_handler, const dust_handler_t& dust_handler)

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/offshore/pricing_record.cpp

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

src/offshore/pricing_record.h

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

src/ringct/rctTypes.h

@@ -50,9 +50,7 @@ extern "C" {
 #include "span.h"
 #include "memwipe.h"
 #include "serialization/vector.h"
-#include "serialization/debug_archive.h"
 #include "serialization/binary_archive.h"
-#include "serialization/json_archive.h"
 
 
 //Define this flag when debugging to get additional info on the console
@@ -238,11 +236,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
@@ -259,11 +294,19 @@ namespace rct {
       RCTTypeCLSAG = 5,
       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,7 +324,7 @@ namespace rct {
       xmr_amount txnOffshoreFee = 0;
       xmr_amount txnOffshoreFee_usd = 0;
       xmr_amount txnOffshoreFee_xasset = 0;
-      keyV maskSums; // contains 2 elements. 1. is the sum of masks of inputs. 2. is the sum of masks of changes.
+      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.
 
       template<bool W, template <bool> class Archive>
       bool serialize_rctsig_base(Archive<W> &ar, size_t inputs, size_t outputs)
@@ -289,10 +332,68 @@ namespace rct {
         FIELD(type)
         if (type == RCTTypeNull)
           return ar.stream().good();
-        if (type != RCTTypeFull && type != RCTTypeSimple && type != RCTTypeBulletproof && type != RCTTypeBulletproof2 && type != RCTTypeCLSAG && type != RCTTypeCLSAGN && type != RCTTypeHaven2)
+        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();
+        }
+        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)
-        if (type == RCTTypeHaven2) {
+        if (type == RCTTypeHaven2 || type == RCTTypeHaven3) {
           // serialize offshore fee
           VARINT_FIELD(txnOffshoreFee)
         } else if (type == RCTTypeCLSAG || type == RCTTypeCLSAGN) {
@@ -340,7 +441,7 @@ namespace rct {
           return false;
         for (size_t i = 0; i < outputs; ++i)
         {
-          if (type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2)
+          if (type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3)
           {
             ar.begin_object();
             if (!typename Archive<W>::is_saving())
@@ -371,7 +472,22 @@ namespace rct {
         }
         ar.end_array();
         
-        if (type == RCTTypeHaven2) {
+        // if txnOffshoreFee is not 0, it is a conversion tx
+        if (type == RCTTypeHaven3 && 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();
+
+        } else if (type == RCTTypeHaven2) {
 
           ar.tag("maskSums");
           ar.begin_array();
@@ -418,10 +534,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
@@ -430,14 +559,39 @@ 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)
+          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)
+          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)
+           if (type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3)
               VARINT_FIELD(nbp)
             else
               FIELD(nbp)
@@ -472,7 +626,7 @@ namespace rct {
             ar.end_array();
           }
 
-          if ((type == RCTTypeCLSAG) || (type == RCTTypeCLSAGN) || (type == RCTTypeHaven2))
+          if (type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 || type == RCTTypeBulletproofPlus)
           {
             ar.tag("CLSAGs");
             ar.begin_array();
@@ -563,7 +717,7 @@ namespace rct {
             }
             ar.end_array();
           }
-          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2)
+          if (type == RCTTypeBulletproof || type == RCTTypeBulletproof2 || type == RCTTypeCLSAG || type == RCTTypeCLSAGN || type == RCTTypeHaven2 || type == RCTTypeHaven3 || type == RCTTypeBulletproofPlus)
           {
             ar.tag("pseudoOuts");
             ar.begin_array();
@@ -581,19 +735,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 ? 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 ? 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
@@ -699,7 +866,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; }
@@ -739,23 +908,6 @@ BLOB_SERIALIZER(rct::ctkey);
 BLOB_SERIALIZER(rct::multisig_kLRki);
 BLOB_SERIALIZER(rct::boroSig);
 
-VARIANT_TAG(debug_archive, rct::key, "rct::key");
-VARIANT_TAG(debug_archive, rct::key64, "rct::key64");
-VARIANT_TAG(debug_archive, rct::keyV, "rct::keyV");
-VARIANT_TAG(debug_archive, rct::keyM, "rct::keyM");
-VARIANT_TAG(debug_archive, rct::ctkey, "rct::ctkey");
-VARIANT_TAG(debug_archive, rct::ctkeyV, "rct::ctkeyV");
-VARIANT_TAG(debug_archive, rct::ctkeyM, "rct::ctkeyM");
-VARIANT_TAG(debug_archive, rct::ecdhTuple, "rct::ecdhTuple");
-VARIANT_TAG(debug_archive, rct::mgSig, "rct::mgSig");
-VARIANT_TAG(debug_archive, rct::rangeSig, "rct::rangeSig");
-VARIANT_TAG(debug_archive, rct::boroSig, "rct::boroSig");
-VARIANT_TAG(debug_archive, rct::rctSig, "rct::rctSig");
-VARIANT_TAG(debug_archive, rct::Bulletproof, "rct::bulletproof");
-VARIANT_TAG(debug_archive, rct::multisig_kLRki, "rct::multisig_kLRki");
-VARIANT_TAG(debug_archive, rct::multisig_out, "rct::multisig_out");
-VARIANT_TAG(debug_archive, rct::clsag, "rct::clsag");
-
 VARIANT_TAG(binary_archive, rct::key, 0x90);
 VARIANT_TAG(binary_archive, rct::key64, 0x91);
 VARIANT_TAG(binary_archive, rct::keyV, 0x92);
@@ -772,22 +924,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(json_archive, rct::key, "rct_key");
-VARIANT_TAG(json_archive, rct::key64, "rct_key64");
-VARIANT_TAG(json_archive, rct::keyV, "rct_keyV");
-VARIANT_TAG(json_archive, rct::keyM, "rct_keyM");
-VARIANT_TAG(json_archive, rct::ctkey, "rct_ctkey");
-VARIANT_TAG(json_archive, rct::ctkeyV, "rct_ctkeyV");
-VARIANT_TAG(json_archive, rct::ctkeyM, "rct_ctkeyM");
-VARIANT_TAG(json_archive, rct::ecdhTuple, "rct_ecdhTuple");
-VARIANT_TAG(json_archive, rct::mgSig, "rct_mgSig");
-VARIANT_TAG(json_archive, rct::rangeSig, "rct_rangeSig");
-VARIANT_TAG(json_archive, rct::boroSig, "rct_boroSig");
-VARIANT_TAG(json_archive, rct::rctSig, "rct_rctSig");
-VARIANT_TAG(json_archive, rct::Bulletproof, "rct_bulletproof");
-VARIANT_TAG(json_archive, rct::multisig_kLRki, "rct_multisig_kLR");
-VARIANT_TAG(json_archive, rct::multisig_out, "rct_multisig_out");
-VARIANT_TAG(json_archive, rct::clsag, "rct_clsag");
+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/crypto.h

@@ -7,7 +7,6 @@
 #include <vector>
 
 #include "serialization.h"
-#include "debug_archive.h"
 #include "crypto/chacha8.h"
 #include "crypto/crypto.h"
 #include "crypto/hash.h"
@@ -62,13 +61,4 @@ BLOB_SERIALIZER(crypto::secret_key);
 BLOB_SERIALIZER(crypto::key_derivation);
 BLOB_SERIALIZER(crypto::key_image);
 BLOB_SERIALIZER(crypto::signature);
-VARIANT_TAG(debug_archive, crypto::cycle, "cycle");
-VARIANT_TAG(debug_archive, crypto::cycle40, "cycle40");
-VARIANT_TAG(debug_archive, crypto::cycle48, "cycle48");
-VARIANT_TAG(debug_archive, crypto::hash, "hash");
-VARIANT_TAG(debug_archive, crypto::hash8, "hash8");
-VARIANT_TAG(debug_archive, crypto::public_key, "public_key");
-VARIANT_TAG(debug_archive, crypto::secret_key, "secret_key");
-VARIANT_TAG(debug_archive, crypto::key_derivation, "key_derivation");
-VARIANT_TAG(debug_archive, crypto::key_image, "key_image");
-VARIANT_TAG(debug_archive, crypto::signature, "signature");
+BLOB_SERIALIZER(crypto::view_tag);

src/serialization/debug_archive.h

@@ -1,28 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include "json_archive.h"
-#include "variant.h"
-
-template <bool W>
-struct debug_archive : public json_archive<W> {
-  typedef typename json_archive<W>::stream_type stream_type;
-
-  debug_archive(stream_type &s) : json_archive<W>(s) { }
-};
-
-template <class T>
-struct serializer<debug_archive<true>, T>
-{
-  static void serialize(debug_archive<true> &ar, T &v)
-  {
-    ar.begin_object();
-    ar.tag(variant_serialization_traits<debug_archive<true>, T>::get_tag());
-    serializer<json_archive<true>, T>::serialize(ar, v);
-    ar.end_object();
-    ar.stream() << std::endl;
-  }
-};

src/serialization/json_archive.h

@@ -1,145 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-/* json_archive.h
- *
- * JSON archive */
-
-#pragma once
-
-#include "serialization.h"
-#include <cassert>
-#include <iostream>
-#include <iomanip>
-
-template <class Stream, bool IsSaving>
-struct json_archive_base
-{
-  typedef Stream stream_type;
-  typedef json_archive_base<Stream, IsSaving> base_type;
-  typedef boost::mpl::bool_<IsSaving> is_saving;
-
-  typedef const char *variant_tag_type;
-
-  json_archive_base(stream_type &s, bool indent = false) : stream_(s), indent_(indent), object_begin(false), depth_(0) { }
-
-  void tag(const char *tag) {
-    if (!object_begin)
-      stream_ << ", ";
-    make_indent();
-    stream_ << '"' << tag << "\": ";
-    object_begin = false;
-  }
-
-  void begin_object()
-  {
-    stream_ << "{";
-    ++depth_;
-    object_begin = true;
-  }
-
-  void end_object()
-  {
-    --depth_;
-    make_indent();
-    stream_ << "}";
-  }
-
-  void begin_variant() { begin_object(); }
-  void end_variant() { end_object(); }
-  Stream &stream() { return stream_; }
-
-protected:
-  void make_indent()
-  {
-    if (indent_)
-    {
-      stream_ << '\n' << std::string(2 * depth_, ' ');
-    }
-  }
-
-protected:
-  stream_type &stream_;
-  bool indent_;
-  bool object_begin;
-  size_t depth_;
-};
-
-template <bool W>
-struct json_archive;
-
-template <>
-struct json_archive<true> : public json_archive_base<std::ostream, true>
-{
-  json_archive(stream_type &s, bool indent = false) : base_type(s, indent) { }
-
-  template<typename T>
-  static auto promote_to_printable_integer_type(T v) -> decltype(+v)
-  {
-    // Unary operator '+' performs integral promotion on type T [expr.unary.op].
-    // If T is signed or unsigned char, it's promoted to int and printed as number.
-    return +v;
-  }
-
-  template <class T>
-  void serialize_int(T v)
-  {
-    stream_ << std::dec << promote_to_printable_integer_type(v);
-  }
-
-  void serialize_blob(void *buf, size_t len, const char *delimiter="\"") {
-    begin_string(delimiter);
-    for (size_t i = 0; i < len; i++) {
-      unsigned char c = ((unsigned char *)buf)[i];
-      stream_ << std::hex << std::setw(2) << std::setfill('0') << (int)c;
-    }
-    end_string(delimiter);
-  }
-
-  template <class T>
-  void serialize_varint(T &v)
-  {
-    stream_ << std::dec << promote_to_printable_integer_type(v);
-  }
-
-  void begin_string(const char *delimiter="\"")
-  {
-    stream_ << delimiter;
-  }
-
-  void end_string(const char *delimiter="\"")
-  {
-    stream_ << delimiter;
-  }
-
-  void begin_array(size_t s=0)
-  {
-    inner_array_size_ = s;
-    ++depth_;
-    stream_ << "[ ";
-  }
-
-  void delimit_array()
-  {
-    stream_ << ", ";
-  }
-
-  void end_array()
-  {
-    --depth_;
-    if (0 < inner_array_size_)
-    {
-      make_indent();
-    }
-    stream_ << "]";
-  }
-
-  void write_variant_tag(const char *t)
-  {
-    tag(t);
-  }
-
-private:
-  size_t inner_array_size_;
-};

src/serialization/json_utils.h

@@ -1,21 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include <sstream>
-#include "json_archive.h"
-
-namespace serialization {
-
-template<class T>
-std::string dump_json(T &v)
-{
-  std::stringstream ostr;
-  json_archive<true> oar(ostr);
-  assert(serialization::serialize(oar, v));
-  return ostr.str();
-};
-
-} // namespace serialization

src/serialization/pricing_record.h

@@ -33,7 +33,6 @@
 #include <vector>
 
 #include "serialization.h"
-#include "debug_archive.h"
 #include "offshore/pricing_record.h"
 #include "cryptonote_config.h"
 

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,126 @@
+// 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 < 3)
+  {
+    // 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;
+  }
+  else
+  {
+    // very basic sanity check
+    if (ar.remaining_bytes() < sizeof(zephyr_oracle::pricing_record)) {
+      return false;
+    }
+
+    ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record), "");
+    if (!ar.good())
+      return false;
+  }
+
+  return true;
+}
+
+// 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 < 3)
+  {
+    zephyr_oracle::pricing_record_v1 pr_v1;
+    if (!pr_v1.read_from_pr(pr))
+      return false;
+    ar.serialize_blob(&pr_v1, sizeof(zephyr_oracle::pricing_record_v1), "");
+  }
+  else
+  {
+    ar.serialize_blob(&pr, sizeof(zephyr_oracle::pricing_record), "");
+  }
+
+  if (!ar.good())
+    return false;
+  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;
+}
+
+BLOB_SERIALIZER(zephyr_oracle::pricing_record);
+BLOB_SERIALIZER(zephyr_oracle::pricing_record_v1);

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,259 @@
+// 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 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(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)
+    , 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;
+      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,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)
+    , 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;
+    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) &&
+	    (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
+  {
+    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;
+    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 noexcept
+  {
+    return (spot == 0) || (moving_average == 0) || (stable == 0) || (stable_ma == 0) || (reserve == 0) || (reserve_ma == 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()) {
+      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)) {
+      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,140 @@
+// 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;
+  };
+  #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 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;
+      bool has_missing_rates() 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;
+    };
+  };
+
+} // oracle