fix comments

Author: OBorce

common/src/size_estimation/mod.rs

@@ -19,6 +19,7 @@ use std::{
 };
 
 use crypto::key::{PrivateKey, PublicKey, Signature};
+use parity_scale_codec::CompactLen;
 use serialization::Encode;
 
 use crate::chain::{
@@ -40,6 +41,8 @@ use crate::chain::{
 pub enum SizeEstimationError {
     #[error("Unsupported input destination")]
     UnsupportedInputDestination(Destination),
+    #[error("Attempted to estimate the size of a TX with too many inputs or outputs {0}")]
+    TooManyElements(usize),
 }
 
 /// Return the encoded size of an input signature.
@@ -194,31 +197,40 @@ pub fn input_signature_size_from_destination(
 
 /// Return the encoded size for a SignedTransaction also accounting for the compact encoding of the
 /// vectors for the specified number of inputs and outputs
-pub fn tx_size_with_num_inputs_and_outputs(num_outputs: usize, num_inputs: usize) -> usize {
-    #[derive(Encode)]
-    struct CompactSize {
-        #[codec(compact)]
-        value: u64,
+pub fn tx_size_with_num_inputs_and_outputs(
+    num_outputs: usize,
+    num_inputs: usize,
+) -> Result<usize, SizeEstimationError> {
+    lazy_static::lazy_static! {
+        static ref EMPTY_SIGNED_TX_SIZE: usize = {
+            let tx = SignedTransaction::new(
+                Transaction::new(1, vec![], vec![]).expect("should not fail"),
+                vec![],
+            )
+            .expect("should not fail");
+            serialization::Encode::encoded_size(&tx)
+        };
+    }
+    lazy_static::lazy_static! {
+        static ref ZERO_COMPACT_SIZE: usize = {
+            serialization::Compact::<u32>::compact_len(&0)
+        };
     }
 
-    let tx = SignedTransaction::new(
-        Transaction::new(1, vec![], vec![]).expect("should not fail"),
-        vec![],
-    )
-    .expect("should not fail");
-    let size = serialization::Encode::encoded_size(&tx);
-
-    let input_compact_size_diff =
-        serialization::Encode::encoded_size(&CompactSize {
-            value: num_inputs as u64,
-        }) - serialization::Encode::encoded_size(&CompactSize { value: 0 });
+    let input_compact_size_diff = serialization::Compact::<u32>::compact_len(
+        &(num_inputs
+            .try_into()
+            .map_err(|_| SizeEstimationError::TooManyElements(num_inputs))?),
+    ) - *ZERO_COMPACT_SIZE;
 
-    let output_compact_size_diff =
-        serialization::Encode::encoded_size(&CompactSize {
-            value: num_outputs as u64,
-        }) - serialization::Encode::encoded_size(&CompactSize { value: 0 });
+    let output_compact_size_diff = serialization::Compact::<u32>::compact_len(
+        &(num_outputs
+            .try_into()
+            .map_err(|_| SizeEstimationError::TooManyElements(num_inputs))?),
+    ) - *ZERO_COMPACT_SIZE;
 
-    size + output_compact_size_diff + (input_compact_size_diff * 2) // 2 for number of inputs and number of input signatures
+    // 2 for number of inputs and number of input signatures
+    Ok(*EMPTY_SIGNED_TX_SIZE + output_compact_size_diff + (input_compact_size_diff * 2))
 }
 
 pub fn outputs_encoded_size(outputs: &[TxOutput]) -> usize {
@@ -241,3 +253,6 @@ fn get_tx_output_destination(txo: &TxOutput) -> Option<&Destination> {
         | TxOutput::CreateOrder(_) => None,
     }
 }
+
+#[cfg(test)]
+mod tests;

common/src/size_estimation/tests.rs

@@ -0,0 +1,92 @@
+// Copyright (c) 2025 RBB S.r.l
+// [email protected]
+// SPDX-License-Identifier: MIT
+// Licensed under the MIT License;
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://github.com/mintlayer/mintlayer-core/blob/master/LICENSE
+//
+// 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 randomness::Rng;
+use rstest::rstest;
+use test_utils::random::{make_seedable_rng, Seed};
+
+use crate::chain::{
+    signature::{
+        inputsig::{standard_signature::StandardInputSignature, InputWitness},
+        sighash::sighashtype::SigHashType,
+    },
+    OutPointSourceId, SignedTransaction, Transaction, TxInput,
+};
+use crate::primitives::{Amount, Id};
+
+#[rstest]
+#[trace]
+#[case(Seed::from_entropy())]
+fn estimate_tx_size(#[case] seed: Seed) {
+    use crypto::key::{KeyKind, PrivateKey};
+    use serialization::Encode;
+
+    use crate::{
+        chain::{
+            output_value::OutputValue,
+            signature::inputsig::authorize_pubkey_spend::AuthorizedPublicKeySpend, Destination,
+            TxOutput,
+        },
+        size_estimation::tx_size_with_num_inputs_and_outputs,
+    };
+
+    let mut rng = make_seedable_rng(seed);
+
+    let num_inputs = rng.gen_range(1..10_000);
+    let inputs = (0..num_inputs)
+        .map(|_| {
+            TxInput::from_utxo(
+                OutPointSourceId::Transaction(Id::random_using(&mut rng)),
+                rng.gen_range(0..100),
+            )
+        })
+        .collect();
+
+    let num_outputs = rng.gen_range(1..10_000);
+    let outputs = (0..num_outputs)
+        .map(|_| {
+            let destination = Destination::PublicKey(
+                crypto::key::PrivateKey::new_from_rng(&mut rng, KeyKind::Secp256k1Schnorr).1,
+            );
+
+            TxOutput::Transfer(
+                OutputValue::Coin(Amount::from_atoms(rng.gen_range(1..10000))),
+                destination,
+            )
+        })
+        .collect();
+
+    let tx = Transaction::new(0, inputs, outputs).unwrap();
+    let signatures = (0..num_inputs)
+        .map(|_| {
+            let private_key =
+                PrivateKey::new_from_rng(&mut rng, crypto::key::KeyKind::Secp256k1Schnorr).0;
+            let signature = private_key.sign_message(&[0; 32], &mut rng).unwrap();
+            let raw_signature = AuthorizedPublicKeySpend::new(signature).encode();
+            let standard = StandardInputSignature::new(SigHashType::all(), raw_signature);
+            InputWitness::Standard(standard)
+        })
+        .collect();
+    let tx = SignedTransaction::new(tx, signatures).unwrap();
+
+    let estimated_tx_size = tx_size_with_num_inputs_and_outputs(num_outputs, num_inputs).unwrap()
+        + tx.inputs().iter().map(Encode::encoded_size).sum::<usize>()
+        + tx.signatures().iter().map(Encode::encoded_size).sum::<usize>()
+        + tx.outputs().iter().map(Encode::encoded_size).sum::<usize>();
+
+    let expected_tx_size = Encode::encoded_size(&tx);
+
+    assert_eq!(estimated_tx_size, expected_tx_size);
+}