app: 💸 a mock consensus spend is performed

crates/core/app/src/action_handler/transaction/stateful.rs

@@ -28,6 +28,15 @@ pub async fn fmd_parameters_valid<S: StateRead>(state: S, transaction: &Transact
     )
 }
 
+#[tracing::instrument(
+    skip_all,
+    fields(
+        current_fmd.precision_bits = current_fmd_parameters.precision_bits,
+        previous_fmd.precision_bits = previous_fmd_parameters.precision_bits,
+        previous_fmd.as_of_block_height = previous_fmd_parameters.as_of_block_height,
+        block_height,
+    )
+)]
 pub fn fmd_precision_within_grace_period(
     tx: &Transaction,
     previous_fmd_parameters: fmd::Parameters,
@@ -42,13 +51,21 @@ pub fn fmd_precision_within_grace_period(
     {
         // Clue must be using the current `fmd::Parameters`, or be within
         // `FMD_GRACE_PERIOD_BLOCKS` of the previous `fmd::Parameters`.
-        if clue.precision_bits() == current_fmd_parameters.precision_bits
-            || (clue.precision_bits() == previous_fmd_parameters.precision_bits
-                && block_height
-                    < previous_fmd_parameters.as_of_block_height + FMD_GRACE_PERIOD_BLOCKS)
-        {
+        let clue_precision = clue.precision_bits();
+        let using_current_precision = clue_precision == current_fmd_parameters.precision_bits;
+        let using_previous_precision = clue_precision == previous_fmd_parameters.precision_bits;
+        let within_grace_period =
+            block_height < previous_fmd_parameters.as_of_block_height + FMD_GRACE_PERIOD_BLOCKS;
+        if using_current_precision || (using_previous_precision && within_grace_period) {
             continue;
         } else {
+            tracing::error!(
+                %clue_precision,
+                %using_current_precision,
+                %using_previous_precision,
+                %within_grace_period,
+                "invalid clue precision"
+            );
             anyhow::bail!("consensus rule violated: invalid clue precision");
         }
     }

crates/core/app/tests/mock_consensus.rs

@@ -8,15 +8,22 @@ mod common;
 use {
     anyhow::anyhow,
     cnidarium::TempStorage,
+    penumbra_fee::Fee,
     penumbra_keys::test_keys,
     penumbra_mock_client::MockClient,
+    penumbra_mock_consensus::TestNode,
     penumbra_proto::DomainType,
     penumbra_sct::component::clock::EpochRead,
-    penumbra_shielded_pool::SpendPlan,
-    penumbra_transaction::TransactionPlan,
+    penumbra_shielded_pool::{OutputPlan, SpendPlan},
+    penumbra_transaction::{
+        memo::MemoPlaintext,
+        plan::{CluePlan, DetectionDataPlan, MemoPlan},
+        ActionPlan, Transaction, TransactionParameters, TransactionPlan, WitnessData,
+    },
+    rand_core::OsRng,
     std::ops::Deref,
     tap::Tap,
-    tracing::{error_span, Instrument},
+    tracing::{error_span, info, Instrument},
 };
 
 /// Exercises that a test node can be instantiated using the consensus service.
@@ -80,54 +87,90 @@ async fn mock_consensus_can_send_a_spend_action() -> anyhow::Result<()> {
     let guard = common::set_tracing_subscriber();
     let storage = TempStorage::new().await?;
     let mut test_node = common::start_test_node(&storage).await?;
-    let mut rng = <rand_chacha::ChaChaRng as rand_core::SeedableRng>::seed_from_u64(0xBEEF);
 
     // Sync the mock client, using the test account's full viewing key, to the latest snapshot.
     let (viewing_key, spend_key) = (&test_keys::FULL_VIEWING_KEY, &test_keys::SPEND_KEY);
     let client = MockClient::new(viewing_key.deref().clone())
         .with_sync_to_storage(&storage)
-        .await?;
+        .await?
+        .tap(|c| info!(client.notes = %c.notes.len(), "mock client synced to test storage"));
 
     // Take one of the test account's notes...
     let (commitment, note) = client
         .notes
         .iter()
         .next()
         .ok_or_else(|| anyhow!("mock client had no note"))?
-        .tap(|(commitment, note)| {
-            tracing::info!(?commitment, ?note, "mock client note commitment")
-        });
+        .tap(|(commitment, note)| info!(?commitment, ?note, "mock client note commitment"));
 
-    // Build a transaction spending this note.
-    let tx = {
-        let position = client
+    let spend: ActionPlan = {
+        let proof = client
             .sct
-            .witness(*commitment)
-            .ok_or_else(|| anyhow!("commitment is not witnessed"))?
-            .position();
-        let spend = SpendPlan::new(&mut rng, note.clone(), position);
+            .witness(commitment.clone())
+            .ok_or_else(|| anyhow!("commitment is not witnessed"))?;
+        let note = note.clone();
+        let position = proof.position();
+        SpendPlan::new(&mut OsRng, note, position).into()
+    };
+
+    // Build a transaction spending this note.
+    let tx: Transaction = {
+        let chain_id = TestNode::<()>::CHAIN_ID.to_string();
+        let transaction_parameters = TransactionParameters {
+            expiry_height: 0,
+            fee: Fee::default(),
+            chain_id,
+        };
+        let detection_data = Some(DetectionDataPlan {
+            clue_plans: vec![CluePlan::new(&mut OsRng, *test_keys::ADDRESS_0, 0)],
+        });
         let plan = TransactionPlan {
-            actions: vec![spend.into()],
-            ..Default::default()
+            actions: vec![
+                spend,
+                OutputPlan::new(&mut OsRng, note.value(), *test_keys::ADDRESS_1).into(),
+            ],
+            transaction_parameters,
+            detection_data,
+            memo: Some(MemoPlan::new(
+                &mut OsRng,
+                MemoPlaintext::blank_memo(*test_keys::ADDRESS_1),
+            )?),
+        };
+        let witness = WitnessData {
+            anchor: client.sct.root(),
+            state_commitment_proofs: plan
+                .spend_plans()
+                .map(|spend| {
+                    (
+                        spend.note.commit(),
+                        client.sct.witness(spend.note.commit()).unwrap(),
+                    )
+                })
+                .collect(),
         };
-        let witness = plan.witness_data(&client.sct)?;
-        let auth = plan.authorize(rand_core::OsRng, spend_key)?;
+        let auth = plan.authorize(OsRng, spend_key)?;
         plan.build_concurrent(viewing_key, &witness, &auth).await?
     };
 
     // Execute the transaction, and sync another mock client up to the latest snapshot.
     test_node
         .block()
-        .with_data(vec![tx.encode_to_vec()]) // TODO(kate): add a `with_tx` extension method
+        .with_data(vec![tx.encode_to_vec()])
         .execute()
         .await?;
 
     // Sync to the latest storage snapshot once more.
-    let client = MockClient::new(test_keys::FULL_VIEWING_KEY.clone())
+    let client_after_spend = MockClient::new(viewing_key.deref().clone())
         .with_sync_to_storage(&storage)
-        .await?;
+        .await?
+        .tap(|c| info!(client.notes = %c.notes.len(), "mock client synced to test storage"));
 
-    client.notes.get(&commitment).unwrap();
+    // Show that we performed the spend as expected.
+    assert_eq!(
+        client_after_spend.notes.len(),
+        client.notes.len() + 1,
+        "a new note should exist after performing the spend",
+    );
 
     // Free our temporary storage.
     drop(storage);

crates/test/mock-consensus/src/builder/init_chain.rs

@@ -67,10 +67,11 @@ impl Builder {
 
     fn init_chain_request(app_state_bytes: Bytes) -> Result<ConsensusRequest, anyhow::Error> {
         use tendermint::v0_37::abci::request::InitChain;
+        let chain_id = TestNode::<()>::CHAIN_ID.to_string();
         let consensus_params = Self::consensus_params();
         Ok(ConsensusRequest::InitChain(InitChain {
             time: tendermint::Time::now(),
-            chain_id: "test".to_string(), // XXX const here?
+            chain_id,
             consensus_params,
             validators: vec![],
             app_state_bytes,

crates/test/mock-consensus/src/lib.rs

@@ -25,6 +25,8 @@ pub struct TestNode<C> {
 }
 
 impl<C> TestNode<C> {
+    pub const CHAIN_ID: &'static str = "penumbra-test-chain";
+
     /// Returns the last app_hash value, as a slice of bytes.
     pub fn last_app_hash(&self) -> &[u8] {
         &self.last_app_hash