also simplify the money_contract. delete Partial and encode_without_signature()

bin/daod/src/money_contract/transfer/validate.rs

@@ -30,10 +30,7 @@ use darkfi::{
 
 use crate::{
     demo::{CallDataBase, StateRegistry, Transaction},
-    money_contract::{
-        state::State,
-        transfer::wallet::partial::{PartialClearInput, PartialInput},
-    },
+    money_contract::state::State,
     note::EncryptedNote2,
 };
 
@@ -162,6 +159,10 @@ pub struct CallData {
     pub inputs: Vec<Input>,
     /// Anonymous outputs
     pub outputs: Vec<Output>,
+    /// Clear input signatures
+    pub clear_signatures: Vec<schnorr::Signature>,
+    /// Input signatures
+    pub signatures: Vec<schnorr::Signature>,
 }
 
 impl CallDataBase for CallData {
@@ -235,19 +236,23 @@ impl CallData {
 
         // Verify the available signatures
         let mut unsigned_tx_data = vec![];
-        self.encode_without_signature(&mut unsigned_tx_data, proofs)?;
+        self.clear_inputs.encode(&mut unsigned_tx_data)?;
+        self.inputs.encode(&mut unsigned_tx_data)?;
+        self.outputs.encode(&mut unsigned_tx_data)?;
 
-        for (i, input) in self.clear_inputs.iter().enumerate() {
+        for (i, (input, signature)) in
+            self.clear_inputs.iter().zip(self.clear_signatures.iter()).enumerate()
+        {
             let public = &input.signature_public;
-            if !public.verify(&unsigned_tx_data[..], &input.signature) {
+            if !public.verify(&unsigned_tx_data[..], signature) {
                 error!("tx::verify(): Failed to verify Clear Input signature {}", i);
                 return Err(VerifyFailed::ClearInputSignature(i))
             }
         }
 
-        for (i, input) in self.inputs.iter().enumerate() {
+        for (i, (input, signature)) in self.inputs.iter().zip(self.signatures.iter()).enumerate() {
             let public = &input.revealed.signature_public;
-            if !public.verify(&unsigned_tx_data[..], &input.signature) {
+            if !public.verify(&unsigned_tx_data[..], signature) {
                 error!("tx::verify(): Failed to verify Input signature {}", i);
                 return Err(VerifyFailed::InputSignature(i))
             }
@@ -256,19 +261,6 @@ impl CallData {
         Ok(())
     }
 
-    pub fn encode_without_signature<S: io::Write>(
-        &self,
-        mut s: S,
-        proofs: &Vec<Proof>,
-    ) -> Result<usize> {
-        let mut len = 0;
-        len += self.clear_inputs.encode_without_signature(&mut s)?;
-        len += self.inputs.encode_without_signature(&mut s)?;
-        len += self.outputs.encode(&mut s)?;
-        len += proofs.encode(s)?;
-        Ok(len)
-    }
-
     fn verify_token_commitments(&self) -> bool {
         assert_ne!(self.outputs.len(), 0);
         let token_commit_value = self.outputs[0].revealed.token_commit;
@@ -300,8 +292,6 @@ pub struct ClearInput {
     pub token_blind: DrkValueBlind,
     /// Public key for the signature
     pub signature_public: PublicKey,
-    ///  signature
-    pub signature: schnorr::Signature,
 }
 
 /// A transaction's anonymous input
@@ -309,8 +299,6 @@ pub struct ClearInput {
 pub struct Input {
     /// Public inputs for the zero-knowledge proof
     pub revealed: BurnRevealedValues,
-    /// Input's signature
-    pub signature: schnorr::Signature,
 }
 
 /// A transaction's anonymous output
@@ -322,63 +310,6 @@ pub struct Output {
     pub enc_note: EncryptedNote2,
 }
 
-impl ClearInput {
-    pub fn from_partial(partial: PartialClearInput, signature: schnorr::Signature) -> Self {
-        Self {
-            value: partial.value,
-            token_id: partial.token_id,
-            value_blind: partial.value_blind,
-            token_blind: partial.token_blind,
-            signature_public: partial.signature_public,
-            signature,
-        }
-    }
-
-    fn encode_without_signature<S: io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.value.encode(&mut s)?;
-        len += self.token_id.encode(&mut s)?;
-        len += self.value_blind.encode(&mut s)?;
-        len += self.token_blind.encode(&mut s)?;
-        len += self.signature_public.encode(s)?;
-        Ok(len)
-    }
-}
-
-impl Input {
-    pub fn from_partial(partial: PartialInput, signature: schnorr::Signature) -> Self {
-        Self { revealed: partial.revealed, signature }
-    }
-
-    fn encode_without_signature<S: io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.revealed.encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-trait EncodableWithoutSignature {
-    fn encode_without_signature<S: io::Write>(&self, s: S) -> Result<usize>;
-}
-
-macro_rules! impl_vec_without_signature {
-    ($type: ty) => {
-        impl EncodableWithoutSignature for Vec<$type> {
-            #[inline]
-            fn encode_without_signature<S: io::Write>(&self, mut s: S) -> Result<usize> {
-                let mut len = 0;
-                len += VarInt(self.len() as u64).encode(&mut s)?;
-                for c in self.iter() {
-                    len += c.encode_without_signature(&mut s)?;
-                }
-                Ok(len)
-            }
-        }
-    };
-}
-impl_vec_without_signature!(ClearInput);
-impl_vec_without_signature!(Input);
-
 #[derive(Debug, Clone, thiserror::Error)]
 pub enum Error {
     #[error(transparent)]
@@ -429,6 +360,9 @@ pub enum VerifyFailed {
 
     #[error("Internal error: {0}")]
     InternalError(String),
+
+    #[error("DarkFi error: {0}")]
+    DarkFiError(String),
 }
 
 type Result<T> = std::result::Result<T, Error>;
@@ -439,6 +373,12 @@ impl From<Error> for VerifyFailed {
     }
 }
 
+impl From<DarkFiError> for VerifyFailed {
+    fn from(err: DarkFiError) -> Self {
+        Self::DarkFiError(err.to_string())
+    }
+}
+
 impl From<DarkFiError> for Error {
     fn from(err: DarkFiError) -> Self {
         Self::DarkFiError(err.to_string())

bin/daod/src/money_contract/transfer/wallet/builder.rs

@@ -18,7 +18,6 @@ use darkfi::{
     Result,
 };
 
-use super::partial::{Partial, PartialClearInput, PartialInput};
 use crate::{
     demo::{FuncCall, ZkContractInfo, ZkContractTable},
     money_contract::transfer::validate::{CallData, ClearInput, Input, Output},
@@ -67,7 +66,7 @@ pub struct BuilderOutputInfo {
 
 impl Builder {
     fn compute_remainder_blind(
-        clear_inputs: &[PartialClearInput],
+        clear_inputs: &[ClearInput],
         input_blinds: &[DrkValueBlind],
         output_blinds: &[DrkValueBlind],
     ) -> DrkValueBlind {
@@ -97,7 +96,7 @@ impl Builder {
             let signature_public = PublicKey::from_secret(input.signature_secret);
             let value_blind = DrkValueBlind::random(&mut OsRng);
 
-            let clear_input = PartialClearInput {
+            let clear_input = ClearInput {
                 value: input.value,
                 token_id: input.token_id,
                 value_blind,
@@ -150,7 +149,7 @@ impl Builder {
             // First we make the tx then sign after
             signature_secrets.push(signature_secret);
 
-            let input = PartialInput { revealed };
+            let input = Input { revealed };
             inputs.push(input);
         }
 
@@ -210,35 +209,33 @@ impl Builder {
             outputs.push(output);
         }
 
-        let partial = Partial { clear_inputs, inputs, outputs, proofs };
+        //let partial = Partial { clear_inputs, inputs, outputs, proofs };
 
         let mut unsigned_tx_data = vec![];
-        partial.encode(&mut unsigned_tx_data)?;
+        clear_inputs.encode(&mut unsigned_tx_data)?;
+        inputs.encode(&mut unsigned_tx_data)?;
+        outputs.encode(&mut unsigned_tx_data)?;
 
-        let mut clear_inputs = vec![];
-        for (input, info) in partial.clear_inputs.into_iter().zip(self.clear_inputs) {
-            let secret = info.signature_secret;
+        let mut clear_signatures = vec![];
+        for clear_input in self.clear_inputs {
+            let secret = clear_input.signature_secret;
             let signature = secret.sign(&unsigned_tx_data[..]);
-            let input = ClearInput::from_partial(input, signature);
-            clear_inputs.push(input);
+            clear_signatures.push(signature);
         }
 
-        let mut inputs = vec![];
-        for (input, signature_secret) in
-            partial.inputs.into_iter().zip(signature_secrets.into_iter())
-        {
+        let mut signatures = vec![];
+        for signature_secret in signature_secrets {
             let signature = signature_secret.sign(&unsigned_tx_data[..]);
-            let input = Input::from_partial(input, signature);
-            inputs.push(input);
+            signatures.push(signature);
         }
 
-        let call_data = CallData { clear_inputs, inputs, outputs: partial.outputs };
+        let call_data = CallData { clear_inputs, inputs, outputs, clear_signatures, signatures };
 
         Ok(FuncCall {
             contract_id: "Money".to_string(),
             func_id: "Money::transfer()".to_string(),
             call_data: Box::new(call_data),
-            proofs: partial.proofs,
+            proofs,
         })
     }
 }

bin/daod/src/money_contract/transfer/wallet/mod.rs

@@ -1,3 +1,2 @@
 pub mod builder;
-pub mod partial;
 pub use builder::{Builder, BuilderClearInputInfo, BuilderInputInfo, BuilderOutputInfo, Note};

bin/daod/src/money_contract/transfer/wallet/partial.rs

@@ -1,33 +0,0 @@
-use darkfi::{
-    crypto::{
-        keypair::PublicKey,
-        types::{DrkTokenId, DrkValueBlind},
-        BurnRevealedValues, Proof,
-    },
-    util::serial::{SerialDecodable, SerialEncodable},
-};
-
-use crate::money_contract::transfer::validate::Output;
-
-#[derive(Clone, SerialEncodable, SerialDecodable)]
-pub struct Partial {
-    pub clear_inputs: Vec<PartialClearInput>,
-    pub inputs: Vec<PartialInput>,
-    pub outputs: Vec<Output>,
-
-    pub proofs: Vec<Proof>,
-}
-
-#[derive(Clone, SerialEncodable, SerialDecodable)]
-pub struct PartialClearInput {
-    pub value: u64,
-    pub token_id: DrkTokenId,
-    pub value_blind: DrkValueBlind,
-    pub token_blind: DrkValueBlind,
-    pub signature_public: PublicKey,
-}
-
-#[derive(Clone, SerialEncodable, SerialDecodable)]
-pub struct PartialInput {
-    pub revealed: BurnRevealedValues,
-}