add transaction and crypto unit tests

coins/monero/Cargo.toml

@@ -32,6 +32,11 @@ monero-bulletproofs = { path = "ringct/bulletproofs", version = "0.1", default-f
 
 hex-literal = "0.4"
 
+[dev-dependencies]
+hex = { version = "0.4", default-features = false, features = ["std"] }
+serde = { version = "1", default-features = false, features = ["std", "derive"] }
+serde_json = { version = "1", default-features = false, features = ["std"] }
+
 [features]
 std = [
   "std-shims/std",

coins/monero/src/lib.rs

@@ -20,6 +20,9 @@ pub mod transaction;
 /// Block structs and functionality.
 pub mod block;
 
+#[cfg(test)]
+mod tests;
+
 /// The minimum amount of blocks an output is locked for.
 ///
 /// If Monero suffered a re-organization, any transactions which selected decoys belonging to

coins/monero/src/ring_signatures.rs

@@ -10,8 +10,14 @@ use curve25519_dalek::{EdwardsPoint, Scalar};
 use crate::{io::*, generators::hash_to_point, primitives::keccak256_to_scalar};
 
 #[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
-struct Signature {
+pub(crate) struct Signature {
+  #[cfg(test)]
+  pub(crate) c: Scalar,
+  #[cfg(test)]
+  pub(crate) s: Scalar,
+  #[cfg(not(test))]
   c: Scalar,
+  #[cfg(not(test))]
   s: Scalar,
 }
 
@@ -32,6 +38,9 @@ impl Signature {
 /// This was used by the original Cryptonote transaction protocol and was deprecated with RingCT.
 #[derive(Clone, PartialEq, Eq, Debug, Zeroize)]
 pub struct RingSignature {
+  #[cfg(test)]
+  pub(crate) sigs: Vec<Signature>,
+  #[cfg(not(test))]
   sigs: Vec<Signature>,
 }
 

coins/monero/src/tests/mod.rs

@@ -0,0 +1 @@
+mod transaction;

coins/monero/src/tests/transaction.rs

@@ -0,0 +1,287 @@
+use curve25519_dalek::{
+  edwards::{CompressedEdwardsY, EdwardsPoint},
+  scalar::Scalar,
+};
+
+use serde_json::Value;
+
+use crate::{
+  ringct::RctPrunable,
+  transaction::{NotPruned, Transaction, Timelock, Input},
+};
+
+const TRANSACTIONS: &str = include_str!("./vectors/transactions.json");
+const CLSAG_TX: &str = include_str!("./vectors/clsag_tx.json");
+const RING_DATA: &str = include_str!("./vectors/ring_data.json");
+
+#[derive(serde::Deserialize)]
+struct Vector {
+  id: String,
+  hex: String,
+  signature_hash: String,
+  tx: Value,
+}
+
+fn tx_vectors() -> Vec<Vector> {
+  serde_json::from_str(TRANSACTIONS).unwrap()
+}
+
+fn point(hex: &Value) -> EdwardsPoint {
+  CompressedEdwardsY(hex::decode(hex.as_str().unwrap()).unwrap().try_into().unwrap())
+    .decompress()
+    .unwrap()
+}
+
+fn scalar(hex: &Value) -> Scalar {
+  Scalar::from_canonical_bytes(hex::decode(hex.as_str().unwrap()).unwrap().try_into().unwrap())
+    .unwrap()
+}
+
+fn point_vector(val: &Value) -> Vec<EdwardsPoint> {
+  let mut v = vec![];
+  for hex in val.as_array().unwrap() {
+    v.push(point(hex));
+  }
+  v
+}
+
+fn scalar_vector(val: &Value) -> Vec<Scalar> {
+  let mut v = vec![];
+  for hex in val.as_array().unwrap() {
+    v.push(scalar(hex));
+  }
+  v
+}
+
+#[test]
+fn parse() {
+  for v in tx_vectors() {
+    let tx =
+      Transaction::<NotPruned>::read(&mut hex::decode(v.hex.clone()).unwrap().as_slice()).unwrap();
+
+    // check version
+    assert_eq!(tx.version(), v.tx["version"]);
+
+    // check unlock time
+    match tx.prefix().additional_timelock {
+      Timelock::None => assert_eq!(0, v.tx["unlock_time"]),
+      Timelock::Block(h) => assert_eq!(h, v.tx["unlock_time"]),
+      Timelock::Time(t) => assert_eq!(t, v.tx["unlock_time"]),
+    }
+
+    // check inputs
+    let inputs = v.tx["vin"].as_array().unwrap();
+    assert_eq!(tx.prefix().inputs.len(), inputs.len());
+    for (i, input) in tx.prefix().inputs.iter().enumerate() {
+      match input {
+        Input::Gen(h) => assert_eq!(*h, inputs[i]["gen"]["height"]),
+        Input::ToKey { amount, key_offsets, key_image } => {
+          let key = &inputs[i]["key"];
+          assert_eq!(amount.unwrap_or(0), key["amount"]);
+          assert_eq!(*key_image, point(&key["k_image"]));
+          assert_eq!(key_offsets, key["key_offsets"].as_array().unwrap());
+        }
+      }
+    }
+
+    // check outputs
+    let outputs = v.tx["vout"].as_array().unwrap();
+    assert_eq!(tx.prefix().outputs.len(), outputs.len());
+    for (i, output) in tx.prefix().outputs.iter().enumerate() {
+      assert_eq!(output.amount.unwrap_or(0), outputs[i]["amount"]);
+      if output.view_tag.is_some() {
+        assert_eq!(output.key, point(&outputs[i]["target"]["tagged_key"]["key"]).compress());
+        let view_tag =
+          hex::decode(outputs[i]["target"]["tagged_key"]["view_tag"].as_str().unwrap()).unwrap();
+        assert_eq!(view_tag.len(), 1);
+        assert_eq!(output.view_tag.unwrap(), view_tag[0]);
+      } else {
+        assert_eq!(output.key, point(&outputs[i]["target"]["key"]).compress());
+      }
+    }
+
+    // check extra
+    assert_eq!(tx.prefix().extra, v.tx["extra"].as_array().unwrap().as_slice());
+
+    match &tx {
+      Transaction::V1 { signatures, .. } => {
+        // check signatures for v1 txs
+        let sigs_array = v.tx["signatures"].as_array().unwrap();
+        for (i, sig) in signatures.iter().enumerate() {
+          let tx_sig = hex::decode(sigs_array[i].as_str().unwrap()).unwrap();
+          for (i, sig) in sig.sigs.iter().enumerate() {
+            let start = i * 64;
+            let c: [u8; 32] = tx_sig[start .. (start + 32)].try_into().unwrap();
+            let s: [u8; 32] = tx_sig[(start + 32) .. (start + 64)].try_into().unwrap();
+            assert_eq!(sig.c, Scalar::from_canonical_bytes(c).unwrap());
+            assert_eq!(sig.s, Scalar::from_canonical_bytes(s).unwrap());
+          }
+        }
+      }
+      Transaction::V2 { proofs: None, .. } => assert_eq!(v.tx["rct_signatures"]["type"], 0),
+      Transaction::V2 { proofs: Some(proofs), .. } => {
+        // check rct signatures
+        let rct = &v.tx["rct_signatures"];
+        assert_eq!(u8::from(proofs.rct_type()), rct["type"]);
+
+        assert_eq!(proofs.base.fee, rct["txnFee"]);
+        assert_eq!(proofs.base.commitments, point_vector(&rct["outPk"]));
+        let ecdh_info = rct["ecdhInfo"].as_array().unwrap();
+        assert_eq!(proofs.base.encrypted_amounts.len(), ecdh_info.len());
+        for (i, ecdh) in proofs.base.encrypted_amounts.iter().enumerate() {
+          let mut buf = vec![];
+          ecdh.write(&mut buf).unwrap();
+          assert_eq!(buf, hex::decode(ecdh_info[i]["amount"].as_str().unwrap()).unwrap());
+        }
+
+        // check ringct prunable
+        match &proofs.prunable {
+          RctPrunable::Clsag { bulletproof: _, clsags, pseudo_outs } => {
+            // check bulletproofs
+            /* TODO
+            for (i, bp) in bulletproofs.iter().enumerate() {
+              match bp {
+                Bulletproof::Original(o) => {
+                  let bps = v.tx["rctsig_prunable"]["bp"].as_array().unwrap();
+                  assert_eq!(bulletproofs.len(), bps.len());
+                  assert_eq!(o.A, point(&bps[i]["A"]));
+                  assert_eq!(o.S, point(&bps[i]["S"]));
+                  assert_eq!(o.T1, point(&bps[i]["T1"]));
+                  assert_eq!(o.T2, point(&bps[i]["T2"]));
+                  assert_eq!(o.taux, scalar(&bps[i]["taux"]));
+                  assert_eq!(o.mu, scalar(&bps[i]["mu"]));
+                  assert_eq!(o.L, point_vector(&bps[i]["L"]));
+                  assert_eq!(o.R, point_vector(&bps[i]["R"]));
+                  assert_eq!(o.a, scalar(&bps[i]["a"]));
+                  assert_eq!(o.b, scalar(&bps[i]["b"]));
+                  assert_eq!(o.t, scalar(&bps[i]["t"]));
+                }
+                Bulletproof::Plus(p) => {
+                  let bps = v.tx["rctsig_prunable"]["bpp"].as_array().unwrap();
+                  assert_eq!(bulletproofs.len(), bps.len());
+                  assert_eq!(p.A, point(&bps[i]["A"]));
+                  assert_eq!(p.A1, point(&bps[i]["A1"]));
+                  assert_eq!(p.B, point(&bps[i]["B"]));
+                  assert_eq!(p.r1, scalar(&bps[i]["r1"]));
+                  assert_eq!(p.s1, scalar(&bps[i]["s1"]));
+                  assert_eq!(p.d1, scalar(&bps[i]["d1"]));
+                  assert_eq!(p.L, point_vector(&bps[i]["L"]));
+                  assert_eq!(p.R, point_vector(&bps[i]["R"]));
+                }
+              }
+            }
+            */
+
+            // check clsags
+            let cls = v.tx["rctsig_prunable"]["CLSAGs"].as_array().unwrap();
+            for (i, cl) in clsags.iter().enumerate() {
+              assert_eq!(cl.D, point(&cls[i]["D"]));
+              assert_eq!(cl.c1, scalar(&cls[i]["c1"]));
+              assert_eq!(cl.s, scalar_vector(&cls[i]["s"]));
+            }
+
+            // check pseudo outs
+            assert_eq!(pseudo_outs, &point_vector(&v.tx["rctsig_prunable"]["pseudoOuts"]));
+          }
+          // TODO: Add
+          _ => panic!("non-null/CLSAG test vector"),
+        }
+      }
+    }
+
+    // check serialized hex
+    let mut buf = Vec::new();
+    tx.write(&mut buf).unwrap();
+    let serialized_tx = hex::encode(&buf);
+    assert_eq!(serialized_tx, v.hex);
+  }
+}
+
+#[test]
+fn signature_hash() {
+  for v in tx_vectors() {
+    let tx = Transaction::read(&mut hex::decode(v.hex.clone()).unwrap().as_slice()).unwrap();
+    // check for signature hashes
+    if let Some(sig_hash) = tx.signature_hash() {
+      assert_eq!(sig_hash, hex::decode(v.signature_hash.clone()).unwrap().as_slice());
+    } else {
+      // make sure it is a miner tx.
+      assert!(matches!(tx.prefix().inputs[0], Input::Gen(_)));
+    }
+  }
+}
+
+#[test]
+fn hash() {
+  for v in &tx_vectors() {
+    let tx = Transaction::read(&mut hex::decode(v.hex.clone()).unwrap().as_slice()).unwrap();
+    assert_eq!(tx.hash(), hex::decode(v.id.clone()).unwrap().as_slice());
+  }
+}
+
+#[test]
+fn clsag() {
+  /*
+    // following keys belong to the wallet that created the CLSAG_TX, and to the
+    // CLSAG_TX itself and here for debug purposes in case this test unexpectedly fails some day.
+    let view_key = "9df81dd2e369004d3737850e4f0abaf2111720f270b174acf8e08547e41afb0b";
+    let spend_key = "25f7339ce03a0206129c0bdd78396f80bf28183ccd16084d4ab1cbaf74f0c204";
+    let tx_key = "650c8038e5c6f1c533cacc1713ac27ef3ec70d7feedde0c5b37556d915b4460c";
+  */
+
+  #[derive(serde::Deserialize)]
+  struct TxData {
+    hex: String,
+    tx: Value,
+  }
+  #[derive(serde::Deserialize)]
+  struct OutData {
+    key: Value,
+    mask: Value,
+  }
+  let tx_data = serde_json::from_str::<TxData>(CLSAG_TX).unwrap();
+  let out_data = serde_json::from_str::<Vec<Vec<OutData>>>(RING_DATA).unwrap();
+  let tx =
+    Transaction::<NotPruned>::read(&mut hex::decode(tx_data.hex).unwrap().as_slice()).unwrap();
+
+  // gather rings
+  let mut rings = vec![];
+  for data in out_data {
+    let mut ring = vec![];
+    for out in &data {
+      ring.push([point(&out.key), point(&out.mask)]);
+    }
+    rings.push(ring)
+  }
+
+  // gather key images
+  let mut key_images = vec![];
+  let inputs = tx_data.tx["vin"].as_array().unwrap();
+  for input in inputs {
+    key_images.push(point(&input["key"]["k_image"]));
+  }
+
+  // gather pseudo_outs
+  let mut pseudo_outs = vec![];
+  let pouts = tx_data.tx["rctsig_prunable"]["pseudoOuts"].as_array().unwrap();
+  for po in pouts {
+    pseudo_outs.push(point(po));
+  }
+
+  // verify clsags
+  match tx {
+    Transaction::V2 { proofs: Some(ref proofs), .. } => match &proofs.prunable {
+      RctPrunable::Clsag { bulletproof: _, clsags, .. } => {
+        for (i, cls) in clsags.iter().enumerate() {
+          cls
+            .verify(&rings[i], &key_images[i], &pseudo_outs[i], &tx.signature_hash().unwrap())
+            .unwrap();
+        }
+      }
+      // TODO: Add
+      _ => panic!("non-CLSAG test vector"),
+    },
+    // TODO: Add
+    _ => panic!("non-CLSAG test vector"),
+  }
+}