Addresses the boundary conditions for the Masp VP predicate

wasm/wasm_source/Cargo.toml

@@ -42,6 +42,7 @@ wee_alloc = "0.4.5"
 getrandom = { version = "0.2", features = ["custom"] }
 masp_proofs = { git = "https://github.com/anoma/masp", rev = "bee40fc465f6afbd10558d12fe96eb1742eee45c", optional = true }
 masp_primitives = { git = "https://github.com/anoma/masp", rev = "bee40fc465f6afbd10558d12fe96eb1742eee45c", optional = true }
+ripemd160 = "0.9.1"
 
 [dev-dependencies]
 namada = {path = "../../shared"}

wasm/wasm_source/src/vp_masp.rs

@@ -1,25 +1,67 @@
 use std::cmp::Ordering;
 
 use masp_primitives::asset_type::AssetType;
-use masp_primitives::transaction::components::Amount;
+use masp_primitives::legacy::TransparentAddress::{PublicKey, Script};
+use masp_primitives::transaction::components::{Amount, TxOut};
 /// Multi-asset shielded pool VP.
 use namada_vp_prelude::address::masp;
 use namada_vp_prelude::storage::Epoch;
 use namada_vp_prelude::*;
+use ripemd160::{Digest, Ripemd160};
+
+/// Generates the current asset type given the current epoch and an
+/// unique token address
+fn asset_type_from_epoched_address(epoch: Epoch, token: &Address) -> AssetType {
+    // Timestamp the chosen token with the current epoch
+    let token_bytes = (token, epoch.0)
+        .try_to_vec()
+        .expect("token should serialize");
+    // Generate the unique asset identifier from the unique token address
+    AssetType::new(token_bytes.as_ref()).expect("unable to create asset type")
+}
+
+/// Checks if the asset type matches the expected asset type, Adds a
+/// debug log if the values do not match.
+fn valid_asset_type(
+    asset_type: &AssetType,
+    asset_type_to_test: &AssetType,
+) -> bool {
+    let res =
+        asset_type.get_identifier() == asset_type_to_test.get_identifier();
+    if !res {
+        debug_log!(
+            "The asset type must be derived from the token address and \
+             current epoch"
+        );
+    }
+    res
+}
+
+/// Checks if the reported transparent amount and the unshielded
+/// values agree, if not adds to the debug log
+fn valid_transfer_amount(
+    reporeted_transparent_value: u64,
+    unshielded_transfer_value: u64,
+) -> bool {
+    let res = reporeted_transparent_value == unshielded_transfer_value;
+    if !res {
+        debug_log!(
+            "The unshielded amount {} disagrees with the calculated masp \
+             transparented value {}",
+            unshielded_transfer_value,
+            reporeted_transparent_value
+        )
+    }
+    res
+}
 
 /// Convert Namada amount and token type to MASP equivalents
 fn convert_amount(
     epoch: Epoch,
     token: &Address,
     val: token::Amount,
 ) -> (AssetType, Amount) {
-    // Timestamp the chosen token with the current epoch
-    let token_bytes = (token, epoch.0)
-        .try_to_vec()
-        .expect("token should serialize");
-    // Generate the unique asset identifier from the unique token address
-    let asset_type = AssetType::new(token_bytes.as_ref())
-        .expect("unable to create asset type");
+    let asset_type = asset_type_from_epoched_address(epoch, token);
     // Combine the value and unit into one amount
     let amount = Amount::from_nonnegative(asset_type, u64::from(val))
         .expect("invalid value or asset type for amount");
@@ -55,7 +97,32 @@ fn validate_tx(
         transparent_tx_pool += shielded_tx.value_balance.clone();
 
         // Handle shielding/transparent input
+        // The following boundary conditions must be satisfied
+        // 1. One transparent input
+        // 2. Zero transparent output
+        // 3. the transparent transaction value pool's amount must equal the
+        // containing wrapper transaction's fee amount
         if transfer.source != masp() {
+            // Satisfies 1.
+            if shielded_tx.vin.len() != 1 {
+                debug_log!(
+                    "Transparent input to a transaction from the masp must be \
+                     1 but is {}",
+                    shielded_tx.vin.len()
+                );
+                return reject();
+            }
+
+            // Satisfies 2.
+            if !shielded_tx.vout.is_empty() {
+                debug_log!(
+                    "Transparent output to a transaction from the masp must \
+                     be 0 but is {}",
+                    shielded_tx.vin.len()
+                );
+                return reject();
+            }
+
             // Note that the asset type is timestamped so shields
             // where the shielded value has an incorrect timestamp
             // are automatically rejected
@@ -70,9 +137,50 @@ fn validate_tx(
         }
 
         // Handle unshielding/transparent output
+        // The following boundary conditions must be satisfied
+        // 1. Zero transparent inupt
+        // 2. One transparent output
+        // 3. Asset type must be properly derived
+        // 4. Value from the output must be the same as the containing transfer
+        // 5. Public key must be the hash of the target
         if transfer.target != masp() {
+            // Satisfies 1.
+            if !shielded_tx.vin.is_empty() {
+                debug_log!(
+                    "Transparent input to a transaction to the masp must be 0 \
+                     but is {}",
+                    shielded_tx.vin.len()
+                );
+                return reject();
+            }
+
+            // Satisfies 2.
+            if shielded_tx.vout.len() != 1 {
+                debug_log!(
+                    "Transparent output to a transaction to the masp must be \
+                     1 but is {}",
+                    shielded_tx.vin.len()
+                );
+                return reject();
+            }
+
+            let out: &TxOut = &shielded_tx.vout[0];
+
+            let expected_asset_type: AssetType =
+                asset_type_from_epoched_address(
+                    ctx.get_block_epoch().unwrap(),
+                    &transfer.token,
+                );
+
+            // Satisfies 3. and 4.
+            if !(valid_asset_type(&expected_asset_type, &out.asset_type)
+                && valid_transfer_amount(out.value, u64::from(transfer.amount)))
+            {
+                return reject();
+            }
+
             // Timestamp is derived to allow unshields for older tokens
-            let atype =
+            let atype: &AssetType =
                 shielded_tx.value_balance.components().next().unwrap().0;
 
             let transp_amt =
@@ -81,6 +189,28 @@ fn validate_tx(
 
             // Non-masp destinations subtract from transparent tx pool
             transparent_tx_pool -= transp_amt;
+
+            // Satisfies 5.
+            match out.script_pubkey.address() {
+                None | Some(Script(_)) => {}
+                Some(PublicKey(pub_bytes)) => {
+                    let target_enc = transfer
+                        .target
+                        .try_to_vec()
+                        .expect("target address encoding");
+
+                    let hash =
+                        Ripemd160::digest(sha256(&target_enc).as_slice());
+
+                    if <[u8; 20]>::from(hash) != pub_bytes {
+                        debug_log!(
+                            "the public key of the output account does not \
+                             match the transfer target"
+                        );
+                        return reject();
+                    }
+                }
+            }
         }
 
         match transparent_tx_pool.partial_cmp(&Amount::zero()) {