add consts

Author: Mr-Leshiy

rust/catalyst-voting/src/txs/v1/decoding.rs

@@ -7,26 +7,41 @@ use anyhow::{anyhow, bail, ensure};
 use super::{EncryptedVote, PublicKey, Tx, Vote, VoterProof};
 use crate::utils::{read_array, read_be_u32, read_be_u64, read_be_u8};
 
+/// Jörmungandr tx fragment tag.
+const FRAGMENT_TAG: u8 = 11;
+/// Jörmungandr tx input tag.
+const INPUT_TAG: u8 = 0xFF;
+/// Jörmungandr tx number of inputs.
+const NUMBER_OF_INPUTS: u8 = 1;
+/// Jörmungandr tx number of outputs.
+const NUMBER_OF_OUTPUTS: u8 = 0;
+/// Jörmungandr tx padding tag.
+const PADDING_TAG: u8 = 0;
+/// Jörmungandr tx private vote tag.
+const PRIVATE_VOTE_TAG: u8 = 2;
+/// Jörmungandr tx public vote tag.
+const PUBLIC_VOTE_TAG: u8 = 1;
+
 impl Tx {
     /// Convert this `Tx` to its underlying sequence of bytes.
     #[must_use]
     #[allow(clippy::cast_possible_truncation)]
     pub fn to_bytes(&self) -> Vec<u8> {
         // Initialize already with the padding tag `0` and fragment tag `11`.
-        let mut tx_body = vec![0, 11];
+        let mut tx_body = vec![PADDING_TAG, FRAGMENT_TAG];
 
         tx_body.extend_from_slice(&self.vote_plan_id);
         tx_body.push(self.proposal_index);
 
         match &self.vote {
             Vote::Public(vote) => {
                 // Public vote tag
-                tx_body.push(1);
+                tx_body.push(PUBLIC_VOTE_TAG);
                 tx_body.push(*vote);
             },
             Vote::Private(vote, proof) => {
                 // Private vote tag
-                tx_body.push(2);
+                tx_body.push(PRIVATE_VOTE_TAG);
                 tx_body.push(vote.size() as u8);
                 tx_body.extend_from_slice(&vote.to_bytes());
 
@@ -38,11 +53,11 @@ impl Tx {
         // Zeros block date
         tx_body.extend_from_slice(&[0u8; 8]);
         // Number of inputs
-        tx_body.push(1);
+        tx_body.push(NUMBER_OF_INPUTS);
         // Number of outputs
-        tx_body.push(0);
+        tx_body.push(NUMBER_OF_OUTPUTS);
         // Input tag
-        tx_body.push(0xFF);
+        tx_body.push(INPUT_TAG);
         // Zero value
         tx_body.extend_from_slice(&[0u8; 8]);
 
@@ -70,14 +85,14 @@ impl Tx {
 
         let padding_tag = read_be_u8(reader)?;
         ensure!(
-            padding_tag == 0,
-            "Invalid padding tag field value, must be equals to `0`, provided: {padding_tag}.",
+            padding_tag == PADDING_TAG,
+            "Invalid padding tag field value, must be equals to {PADDING_TAG}, provided: {padding_tag}.",
         );
 
         let fragment_tag = read_be_u8(reader)?;
         ensure!(
-            fragment_tag == 11,
-            "Invalid fragment tag field value, must be equals to `11`, provided: {fragment_tag}.",
+            fragment_tag == FRAGMENT_TAG,
+            "Invalid fragment tag field value, must be equals to {FRAGMENT_TAG}, provided: {fragment_tag}.",
         );
 
         let vote_plan_id = read_array(reader)?;
@@ -86,11 +101,11 @@ impl Tx {
 
         let vote_tag = read_be_u8(reader)?;
         let vote = match vote_tag {
-            1 => {
+            PUBLIC_VOTE_TAG => {
                 let vote = read_be_u8(reader)?;
                 Vote::Public(vote)
             },
-            2 => {
+            PRIVATE_VOTE_TAG => {
                 let size = read_be_u8(reader)?;
                 let vote = EncryptedVote::from_bytes(reader, size.into())
                     .map_err(|e| anyhow!("Invalid encrypted vote, error: {e}."))?;
@@ -101,28 +116,32 @@ impl Tx {
 
                 Vote::Private(vote, proof)
             },
-            tag => bail!("Invalid vote tag value, must be equals to `0` or `1`, provided: {tag}"),
+            tag => {
+                bail!(
+                    "Invalid vote tag value, must be equals to {PUBLIC_VOTE_TAG} or {PRIVATE_VOTE_TAG}, provided: {tag}"
+                )
+            },
         };
 
         // skip block date (epoch and slot)
         read_be_u64(reader)?;
 
         let inputs_amount = read_be_u8(reader)?;
         ensure!(
-            inputs_amount == 1,
-            "Invalid number of inputs, expected: `1`, provided: {inputs_amount}",
+            inputs_amount == NUMBER_OF_INPUTS,
+            "Invalid number of inputs, expected: {NUMBER_OF_INPUTS}, provided: {inputs_amount}",
         );
 
         let outputs_amount = read_be_u8(reader)?;
         ensure!(
-            outputs_amount == 0,
-            "Invalid number of outputs, expected: `0`, provided: {outputs_amount}",
+            outputs_amount == NUMBER_OF_OUTPUTS,
+            "Invalid number of outputs, expected: {NUMBER_OF_OUTPUTS}, provided: {outputs_amount}",
         );
 
         let input_tag = read_be_u8(reader)?;
         ensure!(
-            input_tag == 0xFF,
-            "Invalid input tag, expected: `255`, provided: {input_tag}",
+            input_tag == INPUT_TAG,
+            "Invalid input tag, expected: {INPUT_TAG}, provided: {input_tag}",
         );
 
         // skip value