temp

Author: sanket1729

src/blind.rs

@@ -94,6 +94,7 @@ pub enum VerificationError {
     UtxoInputLenMismatch,
     /// Balance Check failed
     BalanceCheckFailed,
+    IndexOutOfBounds,
 }
 
 impl fmt::Display for VerificationError {
@@ -129,6 +130,7 @@ impl fmt::Display for VerificationError {
             VerificationError::SurjectionProofMissing(i) => {
                 write!(f, "Missing Surjection Proof for output index {}", i)
             }
+            VerificationError::IndexOutOfBounds => todo!(),
         }
     }
 }
@@ -825,6 +827,65 @@ pub enum TxInType{
 }
 
 impl Transaction {
+
+    /// Verify surjection proof for output at index i. Returns Ok(()) if there is
+    /// an explicit asset and no surjection proof
+    pub fn verify_surjection_proof(
+        &self,
+        secp: &Secp256k1<secp256k1_zkp::All>,
+        spent_utxos: &[TxOut],
+        i: usize,
+    ) -> Result<(), VerificationError>
+    {
+        if spent_utxos.len() != self.input.len() {
+            return Err(VerificationError::UtxoInputLenMismatch);
+        }
+        // Issuances and reissuances not supported yet
+        let mut in_commits = vec![];
+        let mut domain = vec![];
+        for (i, inp) in self.input.iter().enumerate() {
+            let gen = spent_utxos[i].get_asset_gen(secp)
+                .map_err(|e| VerificationError::SpentTxOutError(i, e))?;
+            domain.push(gen);
+            in_commits.push(
+                spent_utxos[i].get_value_commit(secp)
+                    .map_err(|e| VerificationError::SpentTxOutError(i, e))?
+            );
+            if inp.has_issuance() {
+                let (asset_id, token_id) = inp.issuance_ids();
+                let arr = [
+                    (inp.asset_issuance.amount, asset_id),
+                    (inp.asset_issuance.inflation_keys, token_id),
+                ];
+                for (amt, asset) in arr.iter() {
+                    match amt {
+                        Value::Null => continue,
+                        Value::Explicit(v) => {
+                            let gen = Generator::new_unblinded(secp, asset.into_tag());
+                            domain.push(gen);
+                            let comm = PedersenCommitment::new_unblinded(secp, *v, gen);
+                            in_commits.push(comm)
+                        },
+                        Value::Confidential(comm) => in_commits.push(*comm),
+                    }
+                }
+            }
+        }
+
+        let out = self.output.get(i).ok_or(VerificationError::IndexOutOfBounds)?;
+
+        // Surjection proof checks
+        if let Some(gen) = out.asset.commitment() {
+            let surjectionproof = out.witness.surjection_proof.as_ref().ok_or(
+                VerificationError::SurjectionProofMissing(i))?;
+            if !surjectionproof.verify(secp, gen, &domain) {
+                return Err(VerificationError::SurjectionProofVerificationError(i))
+            }
+        } else {
+            // No surjection proof checks for explicit assets
+        }
+        Ok(())
+    }
     /// Verify that the transaction has correctly calculated blinding
     /// factors and they CT verification equation holds.
     /// This is *NOT* a complete Transaction verification check
@@ -913,36 +974,36 @@ impl Transaction {
             }
         }
 
-        for (i, out) in self.output.iter().enumerate() {
-
-            // Compute the value commitments and asset generator
-            let out_commit = out.get_value_commit(secp)
-                .map_err(|e| VerificationError::SpentTxOutError(i, e))?;
-            out_commits.push(out_commit);
-
-            // rangeproof checks
-            if let Some(comm) = out.value.commitment() {
-                let gen = out.get_asset_gen(secp)
-                .map_err(|e| VerificationError::TxOutError(i, e))?;
-                let rangeproof = out.witness.rangeproof.as_ref().ok_or(
-                    VerificationError::RangeProofMissing(i))?;
-                rangeproof.verify(secp, comm, out.script_pubkey.as_bytes(), gen)
-                    .map_err(|e| VerificationError::RangeProofError(i, e))?;
-            } else {
-                // No rangeproof checks for explicit values
-            }
-
-            // Surjection proof checks
-            if let Some(gen) = out.asset.commitment() {
-                let surjectionproof = out.witness.surjection_proof.as_ref().ok_or(
-                    VerificationError::SurjectionProofMissing(i))?;
-                if !surjectionproof.verify(secp, gen, &domain) {
-                    return Err(VerificationError::SurjectionProofVerificationError(i))
-                }
-            } else {
-                // No surjection proof checks for explicit assets
-            }
-        }
+        // for (i, out) in self.output.iter().enumerate() {
+
+        //     // Compute the value commitments and asset generator
+        //     let out_commit = out.get_value_commit(secp)
+        //         .map_err(|e| VerificationError::SpentTxOutError(i, e))?;
+        //     out_commits.push(out_commit);
+
+        //     // rangeproof checks
+        //     if let Some(comm) = out.value.commitment() {
+        //         let gen = out.get_asset_gen(secp)
+        //         .map_err(|e| VerificationError::TxOutError(i, e))?;
+        //         let rangeproof = out.witness.rangeproof.as_ref().ok_or(
+        //             VerificationError::RangeProofMissing(i))?;
+        //         rangeproof.verify(secp, comm, out.script_pubkey.as_bytes(), gen)
+        //             .map_err(|e| VerificationError::RangeProofError(i, e))?;
+        //     } else {
+        //         // No rangeproof checks for explicit values
+        //     }
+
+        //     // Surjection proof checks
+        //     if let Some(gen) = out.asset.commitment() {
+        //         let surjectionproof = out.witness.surjection_proof.as_ref().ok_or(
+        //             VerificationError::SurjectionProofMissing(i))?;
+        //         if !surjectionproof.verify(secp, gen, &domain) {
+        //             return Err(VerificationError::SurjectionProofVerificationError(i))
+        //         }
+        //     } else {
+        //         // No surjection proof checks for explicit assets
+        //     }
+        // }
         // Final Balance check
         if !secp256k1_zkp::verify_commitments_sum_to_equal(secp, &in_commits, &out_commits) {
             return Err(VerificationError::BalanceCheckFailed)