Added CPourTx verification and construction routines.

src/primitives/transaction.cpp

@@ -9,6 +9,87 @@
 #include "tinyformat.h"
 #include "utilstrencodings.h"
 
+#include "libzerocash/PourProver.h"
+#include "libzerocash/PourTransaction.h"
+
+template<std::size_t N>
+boost::array<std::vector<unsigned char>, N> uint256_to_array(const boost::array<uint256, N>& in) {
+    boost::array<std::vector<unsigned char>, N> result;
+    for (size_t i = 0; i < N; i++) {
+        result[i] = std::vector<unsigned char>(in[i].begin(), in[i].end());
+    }
+
+    return result;
+}
+
+template<std::size_t N>
+boost::array<uint256, N> unsigned_char_vector_array_to_uint256_array(const boost::array<std::vector<unsigned char>, N>& in) {
+    boost::array<uint256, N> result;
+    for (size_t i = 0; i < N; i++) {
+        result[i] = uint256(in[i]);
+    }
+
+    return result;
+}
+
+CPourTx::CPourTx(ZerocashParams& params,
+            const CScript& scriptPubKey,
+            const uint256& anchor,
+            const boost::array<PourInput, NUM_POUR_INPUTS>& inputs,
+            const boost::array<PourOutput, NUM_POUR_OUTPUTS>& outputs,
+            CAmount vpub_old,
+            CAmount vpub_new) : scriptSig(), scriptPubKey(scriptPubKey), vpub_old(vpub_old), vpub_new(vpub_new), anchor(anchor)
+{
+    uint256 scriptPubKeyHash;
+    {
+        CHashWriter ss(SER_GETHASH, 0);
+        ss << scriptPubKey;
+        scriptPubKeyHash = ss.GetHash();
+    }
+
+    PourTransaction pourtx(params,
+                           std::vector<unsigned char>(scriptPubKeyHash.begin(), scriptPubKeyHash.end()),
+                           std::vector<unsigned char>(anchor.begin(), anchor.end()),
+                           std::vector<PourInput>(inputs.begin(), inputs.end()),
+                           std::vector<PourOutput>(outputs.begin(), outputs.end()),
+                           vpub_old,
+                           vpub_new);
+
+    boost::array<std::vector<unsigned char>, NUM_POUR_INPUTS> serials_bv;
+    boost::array<std::vector<unsigned char>, NUM_POUR_OUTPUTS> commitments_bv;
+    boost::array<std::vector<unsigned char>, NUM_POUR_INPUTS> macs_bv;
+    boost::array<std::string, NUM_POUR_OUTPUTS> ciphertexts_bv;
+
+    proof = pourtx.unpack(serials_bv, commitments_bv, macs_bv, ciphertexts_bv);
+    serials = unsigned_char_vector_array_to_uint256_array(serials_bv);
+    commitments = unsigned_char_vector_array_to_uint256_array(commitments_bv);
+    macs = unsigned_char_vector_array_to_uint256_array(macs_bv);
+
+    ciphertexts = ciphertexts_bv;
+}
+
+bool CPourTx::Verify(ZerocashParams& params) const {
+    // Compute the hash of the scriptPubKey.
+    uint256 scriptPubKeyHash;
+    {
+        CHashWriter ss(SER_GETHASH, 0);
+        ss << scriptPubKey;
+        scriptPubKeyHash = ss.GetHash();
+    }
+
+    return PourProver::VerifyProof(
+        params,
+        std::vector<unsigned char>(scriptPubKeyHash.begin(), scriptPubKeyHash.end()),
+        std::vector<unsigned char>(anchor.begin(), anchor.end()),
+        vpub_old,
+        vpub_new,
+        uint256_to_array<NUM_POUR_INPUTS>(serials),
+        uint256_to_array<NUM_POUR_OUTPUTS>(commitments),
+        uint256_to_array<NUM_POUR_INPUTS>(macs),
+        proof
+    );
+}
+
 std::string COutPoint::ToString() const
 {
     return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10), n);

src/primitives/transaction.h

@@ -13,6 +13,15 @@
 
 #include <boost/array.hpp>
 
+#include "libzerocash/ZerocashParams.h"
+#include "libzerocash/PourInput.h"
+#include "libzerocash/PourOutput.h"
+
+using namespace libzerocash;
+
+static const unsigned int NUM_POUR_INPUTS = 2;
+static const unsigned int NUM_POUR_OUTPUTS = 2;
+
 class CPourTx
 {
 public:
@@ -39,25 +48,25 @@ public:
     // are derived from the secrets placed in the bucket
     // and the secret spend-authority key known by the
     // spender.
-    boost::array<uint256, 2> serials;
+    boost::array<uint256, NUM_POUR_INPUTS> serials;
 
     // Bucket commitments are introduced into the commitment
     // tree, blinding the public about the values and
     // destinations involved in the Pour. The presence of a
     // commitment in the bucket commitment tree is required
     // to spend it.
-    boost::array<uint256, 2> commitments;
+    boost::array<uint256, NUM_POUR_OUTPUTS> commitments;
 
     // Ciphertexts
     // These are encrypted using ECIES. They are used to
     // transfer metadata and seeds to generate trapdoors
     // for the recipient to spend the value.
-    boost::array<std::vector<unsigned char>, 2> ciphertexts;
+    boost::array<std::string, NUM_POUR_OUTPUTS> ciphertexts;
 
     // MACs
     // The verification of the pour requires these MACs
     // to be provided as an input.
-    boost::array<uint256, 2> macs;
+    boost::array<uint256, NUM_POUR_INPUTS> macs;
 
     // Pour proof
     // This is a zk-SNARK which ensures that this pour is valid.
@@ -67,6 +76,18 @@ public:
         
     }
 
+    CPourTx(ZerocashParams& params,
+            const CScript& scriptPubKey,
+            const uint256& rt,
+            const boost::array<PourInput, NUM_POUR_INPUTS>& inputs,
+            const boost::array<PourOutput, NUM_POUR_OUTPUTS>& outputs,
+            CAmount vpub_old,
+            CAmount vpub_new
+    );
+
+    // Verifies that the pour proof is correct.
+    bool Verify(ZerocashParams& params) const;
+
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>