Format redpallas keys as hex when debugging

zebra-chain/src/orchard/arbitrary.rs

@@ -74,8 +74,8 @@ impl Arbitrary for Signature<SpendAuth> {
     fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
         (array::uniform32(any::<u8>()), array::uniform32(any::<u8>()))
             .prop_map(|(r_bytes, s_bytes)| Self {
-                r_bytes,
-                s_bytes,
+                r_bytes: r_bytes.into(),
+                s_bytes: s_bytes.into(),
                 _marker: PhantomData,
             })
             .boxed()

zebra-chain/src/primitives/redpallas/batch.rs

@@ -229,7 +229,7 @@ impl Verifier {
 
             let s = {
                 // XXX-pallas: should not use CtOption here
-                let maybe_scalar = pallas::Scalar::from_repr(s_bytes);
+                let maybe_scalar = pallas::Scalar::from_repr(*s_bytes);
                 if maybe_scalar.is_some().into() {
                     maybe_scalar.unwrap()
                 } else {
@@ -258,10 +258,10 @@ impl Verifier {
                     //
                     // This validates the `rk` element, whose type is
                     // SpendAuthSig^{Orchard}.Public, i.e. ℙ.
-                    VerificationKey::<SpendAuth>::try_from(vk_bytes.bytes)?.point
+                    VerificationKey::<SpendAuth>::try_from(*vk_bytes.bytes)?.point
                 }
                 Inner::Binding { vk_bytes, .. } => {
-                    VerificationKey::<Binding>::try_from(vk_bytes.bytes)?.point
+                    VerificationKey::<Binding>::try_from(*vk_bytes.bytes)?.point
                 }
             };
 

zebra-chain/src/primitives/redpallas/signature.rs

@@ -12,13 +12,16 @@ use std::{io, marker::PhantomData};
 
 use super::SigType;
 
-use crate::serialization::{ReadZcashExt, SerializationError, ZcashDeserialize, ZcashSerialize};
+use crate::{
+    fmt::HexDebug,
+    serialization::{ReadZcashExt, SerializationError, ZcashDeserialize, ZcashSerialize},
+};
 
 /// A RedPallas signature.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct Signature<T: SigType> {
-    pub(crate) r_bytes: [u8; 32],
-    pub(crate) s_bytes: [u8; 32],
+    pub(crate) r_bytes: HexDebug<[u8; 32]>,
+    pub(crate) s_bytes: HexDebug<[u8; 32]>,
     pub(crate) _marker: PhantomData<T>,
 }
 
@@ -29,8 +32,8 @@ impl<T: SigType> From<[u8; 64]> for Signature<T> {
         let mut s_bytes = [0; 32];
         s_bytes.copy_from_slice(&bytes[32..64]);
         Signature {
-            r_bytes,
-            s_bytes,
+            r_bytes: r_bytes.into(),
+            s_bytes: s_bytes.into(),
             _marker: PhantomData,
         }
     }

zebra-chain/src/primitives/redpallas/signing_key.rs

@@ -1,4 +1,5 @@
-use std::convert::{TryFrom, TryInto};
+//! Redpallas signing keys for Zebra.
+
 use std::marker::PhantomData;
 
 use group::{ff::PrimeField, GroupEncoding};
@@ -117,8 +118,8 @@ impl<T: SigType> SigningKey<T> {
         let s_bytes = (nonce + (c * self.sk)).to_repr();
 
         Signature {
-            r_bytes,
-            s_bytes,
+            r_bytes: r_bytes.into(),
+            s_bytes: s_bytes.into(),
             _marker: PhantomData,
         }
     }

zebra-chain/src/primitives/redpallas/verification_key.rs

@@ -1,8 +1,12 @@
+//! Redpallas verification keys for Zebra.
+
 use std::marker::PhantomData;
 
 use group::{cofactor::CofactorGroup, ff::PrimeField, GroupEncoding};
 use halo2::pasta::pallas;
 
+use crate::fmt::HexDebug;
+
 use super::*;
 
 /// A refinement type for `[u8; 32]` indicating that the bytes represent
@@ -13,22 +17,22 @@ use super::*;
 /// used in signature verification.
 #[derive(Copy, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 pub struct VerificationKeyBytes<T: SigType> {
-    pub(crate) bytes: [u8; 32],
+    pub(crate) bytes: HexDebug<[u8; 32]>,
     pub(crate) _marker: PhantomData<T>,
 }
 
 impl<T: SigType> From<[u8; 32]> for VerificationKeyBytes<T> {
     fn from(bytes: [u8; 32]) -> VerificationKeyBytes<T> {
         VerificationKeyBytes {
-            bytes,
+            bytes: bytes.into(),
             _marker: PhantomData,
         }
     }
 }
 
 impl<T: SigType> From<VerificationKeyBytes<T>> for [u8; 32] {
     fn from(refined: VerificationKeyBytes<T>) -> [u8; 32] {
-        refined.bytes
+        *refined.bytes
     }
 }
 
@@ -65,7 +69,7 @@ impl<T: SigType> From<VerificationKey<T>> for VerificationKeyBytes<T> {
 
 impl<T: SigType> From<VerificationKey<T>> for [u8; 32] {
     fn from(pk: VerificationKey<T>) -> [u8; 32] {
-        pk.bytes.bytes
+        *pk.bytes.bytes
     }
 }
 
@@ -107,7 +111,7 @@ impl VerificationKey<SpendAuth> {
         use super::private::Sealed;
         let point = self.point + (SpendAuth::basepoint() * randomizer);
         let bytes = VerificationKeyBytes {
-            bytes: point.to_bytes(),
+            bytes: point.to_bytes().into(),
             _marker: PhantomData,
         };
         VerificationKey { point, bytes }
@@ -118,7 +122,7 @@ impl<T: SigType> VerificationKey<T> {
     pub(crate) fn from_scalar(s: &pallas::Scalar) -> VerificationKey<T> {
         let point = T::basepoint() * s;
         let bytes = VerificationKeyBytes {
-            bytes: point.to_bytes(),
+            bytes: point.to_bytes().into(),
             _marker: PhantomData,
         };
         VerificationKey { point, bytes }
@@ -154,7 +158,7 @@ impl<T: SigType> VerificationKey<T> {
 
         let s = {
             // XXX-pasta_curves: should not use CtOption here
-            let maybe_scalar = pallas::Scalar::from_repr(signature.s_bytes);
+            let maybe_scalar = pallas::Scalar::from_repr(*signature.s_bytes);
             if maybe_scalar.is_some().into() {
                 maybe_scalar.unwrap()
             } else {