Merge pull request #3214 from ProvableHQ/feat/rejection-reason-2

[Feat] Tx rejection reasons (take 3)

Author: vicsn

Cargo.lock

@@ -56,6 +56,7 @@ pub enum ConsensusVersion {
     V14 = 14,
     /// V15: Introduces the record-existence check and `commit.*.raw` instruction variants.
     ///      Increase the anchor time to 35.
+    ///      Unconditionally stores transaction rejection reasons.
     V15 = 15,
 }
 

console/network/src/consensus_heights.rs

@@ -61,6 +61,9 @@ workspace = true
 [dependencies.snarkvm-ledger-puzzle]
 workspace = true
 
+[dependencies.snarkvm-synthesizer-error]
+workspace = true
+
 [dependencies.snarkvm-synthesizer-program]
 workspace = true
 

ledger/block/Cargo.toml

@@ -145,7 +145,7 @@ impl<N: Network> Block<N> {
 
     /// Initializes a new block from the given previous block hash, block header, authority,
     /// ratifications, solutions, aborted solution IDs, transactions, and aborted transaction IDs.
-    pub fn from(
+    fn from(
         previous_hash: N::BlockHash,
         header: Header<N>,
         authority: Authority<N>,

ledger/block/src/lib.rs

@@ -473,18 +473,22 @@ pub mod test_helpers {
             sample_rejected_deploy(2, 2, Uniform::rand(rng), false, true, rng),
             sample_rejected_deploy(2, 2, Uniform::rand(rng), true, true, rng),
             sample_rejected_execute(3, true, rng),
+            sample_rejected_execute(3, true, rng),
+            sample_rejected_execute(3, false, rng),
             sample_rejected_execute(3, false, rng),
             sample_accepted_execute(Uniform::rand(rng), true, rng),
             sample_accepted_execute(Uniform::rand(rng), false, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, true, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, false, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, true, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, false, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, true, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, false, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, true, rng),
-            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, false, rng),
+            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 1, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, Uniform::rand(rng), rng),
+            sample_rejected_deploy(Uniform::rand(rng), 2, Uniform::rand(rng), false, Uniform::rand(rng), rng),
             sample_rejected_execute(Uniform::rand(rng), true, rng),
+            sample_rejected_execute(Uniform::rand(rng), true, rng),
+            sample_rejected_execute(Uniform::rand(rng), false, rng),
             sample_rejected_execute(Uniform::rand(rng), false, rng),
         ]
     }

ledger/block/src/transactions/confirmed/mod.rs

@@ -19,6 +19,9 @@ pub use confirmed::*;
 pub mod rejected;
 pub use rejected::*;
 
+pub mod rejected_reason;
+pub use rejected_reason::*;
+
 mod bytes;
 mod merkle;
 mod serialize;
@@ -31,6 +34,8 @@ use console::{
         Ciphertext,
         FINALIZE_ID_DEPTH,
         FINALIZE_OPERATIONS_DEPTH,
+        Identifier,
+        ProgramID,
         ProgramOwner,
         Record,
         TRANSACTIONS_DEPTH,
@@ -41,7 +46,8 @@ use console::{
 };
 use snarkvm_ledger_committee::Committee;
 use snarkvm_ledger_narwhal_batch_header::BatchHeader;
-use snarkvm_synthesizer_program::FinalizeOperation;
+use snarkvm_synthesizer_error::IndexedFinalizeError;
+use snarkvm_synthesizer_program::{Command, FinalizeOperation};
 
 use indexmap::IndexMap;
 

ledger/block/src/transactions/mod.rs

@@ -52,23 +52,23 @@ impl<N: Network> Rejected<N> {
     /// Returns the program owner of the rejected deployment.
     pub fn program_owner(&self) -> Option<&ProgramOwner<N>> {
         match self {
-            Self::Deployment(program_owner, _) => Some(program_owner),
-            Self::Execution(_) => None,
+            Self::Deployment(program_owner, ..) => Some(program_owner),
+            Self::Execution(..) => None,
         }
     }
 
     /// Returns the rejected deployment.
     pub fn deployment(&self) -> Option<&Deployment<N>> {
         match self {
             Self::Deployment(_, deployment) => Some(deployment),
-            Self::Execution(_) => None,
+            Self::Execution(..) => None,
         }
     }
 
     /// Returns the rejected execution.
     pub fn execution(&self) -> Option<&Execution<N>> {
         match self {
-            Self::Deployment(_, _) => None,
+            Self::Deployment(..) => None,
             Self::Execution(execution) => Some(execution),
         }
     }
@@ -148,17 +148,27 @@ pub mod test_helpers {
     pub(crate) fn sample_rejected_transactions() -> Vec<Rejected<CurrentNetwork>> {
         let rng = &mut TestRng::default();
 
-        vec![
-            sample_rejected_deployment(1, 0, false, false, rng),
-            sample_rejected_deployment(1, 0, false, true, rng),
-            sample_rejected_deployment(2, 0, false, false, rng),
-            sample_rejected_deployment(2, 0, false, true, rng),
-            sample_rejected_deployment(1, 1, false, false, rng),
-            sample_rejected_deployment(1, 1, false, true, rng),
-            sample_rejected_deployment(2, 1, true, false, rng),
-            sample_rejected_deployment(2, 1, true, true, rng),
-            sample_rejected_execution(true, rng),
-            sample_rejected_execution(false, rng),
-        ]
+        let mut txs = Vec::new();
+
+        // Sample the deployments.
+        for version in 1..=2 {
+            for edition in 0..=1 {
+                for has_translation_keys in [true, false] {
+                    for is_fee_private in [true, false] {
+                        let tx =
+                            sample_rejected_deployment(version, edition, has_translation_keys, is_fee_private, rng);
+                        txs.push(tx);
+                    }
+                }
+            }
+        }
+
+        // Sample the executions.
+        for is_fee_private in [true, false] {
+            let tx = sample_rejected_execution(is_fee_private, rng);
+            txs.push(tx);
+        }
+
+        txs
     }
 }

ledger/block/src/transactions/rejected/mod.rs

@@ -0,0 +1,114 @@
+// Copyright (c) 2019-2026 Provable Inc.
+// This file is part of the snarkVM library.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::*;
+
+impl<N: Network> FromBytes for RejectedReason<N> {
+    /// Reads the rejected reason from a buffer.
+    fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
+        // Read the variant.
+        let variant = u8::read_le(&mut reader)?;
+        match variant {
+            0 => {
+                let program_id = ProgramID::<N>::read_le(&mut reader)?;
+                Ok(Self::DuplicateProgramID(program_id))
+            }
+            1 => {
+                let program_id = ProgramID::<N>::read_le(&mut reader)?;
+                let edition = u16::read_le(&mut reader)?;
+                let resource = Identifier::<N>::read_le(&mut reader)?;
+                let index = u32::read_le(&mut reader)? as usize;
+                let command = Command::<N>::read_le(&mut reader)?;
+                Ok(Self::Finalize { program_id, edition, resource, index, command: Box::new(command) })
+            }
+            2 => {
+                // Read the optional program ID and edition.
+                let program_id = match u8::read_le(&mut reader)? {
+                    0 => None,
+                    1 => {
+                        let id = ProgramID::<N>::read_le(&mut reader)?;
+                        let edition = u16::read_le(&mut reader)?;
+                        Some((id, edition))
+                    }
+                    flag => return Err(error(format!("Invalid program_id presence flag {flag}"))),
+                };
+                // Read the optional resource.
+                let resource = match u8::read_le(&mut reader)? {
+                    0 => None,
+                    1 => Some(Identifier::<N>::read_le(&mut reader)?),
+                    flag => return Err(error(format!("Invalid resource presence flag {flag}"))),
+                };
+                Ok(Self::VM(program_id, resource))
+            }
+            3.. => Err(error(format!("Failed to decode rejected reason variant {variant}"))),
+        }
+    }
+}
+
+impl<N: Network> ToBytes for RejectedReason<N> {
+    /// Writes the rejected reason to a buffer.
+    fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
+        match self {
+            Self::DuplicateProgramID(program_id) => {
+                0u8.write_le(&mut writer)?;
+                program_id.write_le(&mut writer)
+            }
+            Self::Finalize { program_id, edition, resource, index, command } => {
+                1u8.write_le(&mut writer)?;
+                program_id.write_le(&mut writer)?;
+                edition.write_le(&mut writer)?;
+                resource.write_le(&mut writer)?;
+                u32::try_from(*index).map_err(|_| error("Command index exceeds u32::MAX"))?.write_le(&mut writer)?;
+                command.write_le(&mut writer)
+            }
+            Self::VM(program_id, resource) => {
+                2u8.write_le(&mut writer)?;
+                // Write the optional program ID and edition.
+                match program_id {
+                    None => 0u8.write_le(&mut writer)?,
+                    Some((id, edition)) => {
+                        1u8.write_le(&mut writer)?;
+                        id.write_le(&mut writer)?;
+                        edition.write_le(&mut writer)?;
+                    }
+                }
+                // Write the optional resource.
+                match resource {
+                    None => 0u8.write_le(&mut writer),
+                    Some(resource) => {
+                        1u8.write_le(&mut writer)?;
+                        resource.write_le(&mut writer)
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    type CurrentNetwork = console::network::MainnetV0;
+
+    #[test]
+    fn test_bytes() {
+        for expected in test_helpers::sample_rejected_reasons::<CurrentNetwork>() {
+            // Check the byte representation.
+            let expected_bytes = expected.to_bytes_le().unwrap();
+            assert_eq!(expected, RejectedReason::read_le(&expected_bytes[..]).unwrap());
+        }
+    }
+}

ledger/block/src/transactions/rejected_reason/bytes.rs

@@ -0,0 +1,89 @@
+// Copyright (c) 2019-2026 Provable Inc.
+// This file is part of the snarkVM library.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+mod bytes;
+mod serialize;
+mod string;
+
+use super::*;
+
+/// The reason a transaction was rejected.
+#[derive(Clone, PartialEq, Eq)]
+pub enum RejectedReason<N: Network> {
+    /// The transaction was rejected due to a duplicate program ID deployment in the same block.
+    DuplicateProgramID(ProgramID<N>),
+
+    /// The transaction was rejected due to a failed finalize command. (program ID, edition, resource, index, command).
+    /// Note: We do not log the actual error message from the finalize command, as it may contain
+    /// sensitive information or lead to DOS vectors by storing string representations of large structs.
+    Finalize { program_id: ProgramID<N>, edition: u16, resource: Identifier<N>, index: usize, command: Box<Command<N>> },
+
+    /// The transaction was rejected due to a VM error not captured by a finalize command.
+    /// The programID and resource are logged if they are available.
+    VM(Option<(ProgramID<N>, u16)>, Option<Identifier<N>>),
+}
+
+impl<N: Network> RejectedReason<N> {
+    /// Initializes the rejected reason from an indexed finalize error.
+    ///
+    /// `C` may be any type whose `Display` output is a valid `Command<N>` string (e.g. `Command<N>`
+    /// itself or `String`). If the command string cannot be re-parsed, the reason falls back to
+    /// `VM` so that a bad string never causes a panic in consensus code.
+    pub fn from_indexed_finalize_error<C: ToString>(error: IndexedFinalizeError<N, C>) -> Self {
+        let program_id = error.program_id;
+        let resource = error.resource;
+        match error.command.map(|b| *b) {
+            Some((index, command)) => {
+                // Parse the command from its display string. Falls back to VM on failure.
+                match (program_id, resource, command.to_string().parse::<Command<N>>()) {
+                    (Some((program_id, edition)), Some(resource), Ok(command)) => {
+                        Self::Finalize { program_id, edition, resource, index, command: Box::new(command) }
+                    }
+                    (program_id, resource, _) => Self::VM(program_id, resource),
+                }
+            }
+            None => Self::VM(program_id, resource),
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod test_helpers {
+    use super::*;
+    use std::str::FromStr;
+
+    /// Returns one instance of each `RejectedReason` variant for testing.
+    pub(crate) fn sample_rejected_reasons<N: Network>() -> Vec<RejectedReason<N>> {
+        let program = ProgramID::<N>::from_str("dummy_program.aleo").unwrap();
+        let credits = ProgramID::<N>::from_str("credits.aleo").unwrap();
+        let transfer = Identifier::<N>::from_str("transfer_public").unwrap();
+        let bond = Identifier::<N>::from_str("bond_public").unwrap();
+        let command = Command::<N>::from_str("assert.eq r0 r1;").unwrap();
+        vec![
+            RejectedReason::DuplicateProgramID(program),
+            RejectedReason::Finalize {
+                program_id: credits,
+                edition: 1,
+                resource: transfer,
+                index: 3,
+                command: Box::new(command),
+            },
+            RejectedReason::VM(Some((credits, 0u16)), Some(bond)),
+            RejectedReason::VM(None, Some(bond)),
+            RejectedReason::VM(Some((credits, 0u16)), None),
+            RejectedReason::VM(None, None),
+        ]
+    }
+}