feat: report native and pubdata in batch output (#170)

## What ❔

<!-- What are the changes this PR brings about? -->
<!-- Example: This PR adds a PR template to the repo. -->
<!-- (For bigger PRs adding more context is appreciated) -->

## Why ❔

<!-- Why are these changes done? What goal do they contribute to? What
are the principles behind them? -->
<!-- The `Why` has to be clear to non-Matter Labs entities running their
own ZK Chain -->
<!-- Example: PR templates ensure PR reviewers, observers, and future
iterators are in context about the evolution of repos. -->

## Is this a breaking change?
- [ ] Yes
- [ ] No

## Checklist

<!-- Check your PR fulfills the following items. -->
<!-- For draft PRs check the boxes as you complete them. -->

- [ ] PR title corresponds to the body of PR (we generate changelog
entries from PRs).
- [ ] Tests for the changes have been added / updated.
- [ ] Documentation comments have been added / updated.
- [ ] Code has been formatted.

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: antoniolocascio

basic_bootloader/Cargo.toml

@@ -32,6 +32,5 @@ evm-compatibility = ["code_in_kernel_space", "transfers_to_kernel_space", "syste
 cycle_marker = ["system_hooks/cycle_marker", "cycle_marker/log_to_file"]
 resources_for_tester = []
 unlimited_native = []
-report_native = []
 disable_system_contracts = []
 error_origins = ["zk_ee/error_origins"]

basic_bootloader/src/bootloader/account_models/mod.rs

@@ -61,8 +61,10 @@ pub struct TxProcessingResult<'a> {
     pub is_upgrade_tx: bool,
     pub gas_used: u64,
     pub gas_refunded: u64,
-    #[cfg(feature = "report_native")]
-    pub native_used: u64,
+
+    pub computational_native_used: u64,
+
+    pub pubdata_used: u64,
 }
 
 pub trait AccountModel<S: EthereumLikeTypes>

basic_bootloader/src/bootloader/gas_helpers.rs

@@ -7,10 +7,18 @@ use zk_ee::system::{Computational, Resources};
 
 use super::*;
 
-/// Returns the resources for the transaction and the withheld resources.
-/// The withheld resources are the resources that are withheld from the transaction's
-/// execution to ensure that it does not use too many native computational resources.
-/// They are reclaimed at the end of the transaction and used to charge the pubdata.
+pub struct ResourcesForTx<S: EthereumLikeTypes> {
+    // Resources to run the transaction.
+    // These will be capped to MAX_NATIVE_COMPUTATIONAL, to prevent
+    // transaction from using too many native computational resources.
+    pub main_resources: S::Resources,
+    /// Resources in excess of MAX_NATIVE_COMPUTATIONAL.
+    /// These resources can only be used for paying for pubdata.
+    pub withheld: S::Resources,
+    /// Computational native charged for as intrinsic
+    pub intrinsic_computational_native_charged: u64,
+}
+
 pub fn get_resources_for_tx<S: EthereumLikeTypes>(
     gas_limit: u64,
     native_per_pubdata: U256,
@@ -19,7 +27,7 @@ pub fn get_resources_for_tx<S: EthereumLikeTypes>(
     intrinsic_gas: usize,
     intrinsic_pubdata: usize,
     intrinsic_native: usize,
-) -> Result<(S::Resources, S::Resources), TxError> {
+) -> Result<ResourcesForTx<S>, TxError> {
     // TODO: operator trusted gas limit?
 
     // This is the real limit, which we later use to compute native_used.
@@ -49,11 +57,11 @@ pub fn get_resources_for_tx<S: EthereumLikeTypes>(
     // EVM tester requires high native limits, so for it we never hold off resources.
     // But for the real world, we bound the available resources.
 
-    #[allow(unused_variables)]
-    let withheld_resources = S::Resources::from_ergs(Ergs(0));
+    #[cfg(feature = "resources_for_tester")]
+    let withheld = S::Resources::from_ergs(Ergs(0));
 
     #[cfg(not(feature = "resources_for_tester"))]
-    let (native_limit, withheld_resources) = if native_limit <= MAX_NATIVE_COMPUTATIONAL {
+    let (native_limit, withheld) = if native_limit <= MAX_NATIVE_COMPUTATIONAL {
         (native_limit, S::Resources::from_ergs(Ergs(0)))
     } else {
         let withheld =
@@ -70,9 +78,14 @@ pub fn get_resources_for_tx<S: EthereumLikeTypes>(
     // Charge for calldata and intrinsic native
     let (calldata_gas, calldata_native) = cost_for_calldata(calldata)?;
 
+    let intrinsic_computational_native_charged = calldata_native
+        .checked_add(intrinsic_native as u64)
+        .ok_or(TxError::Validation(
+            errors::InvalidTransaction::OutOfNativeResourcesDuringValidation,
+        ))?;
+
     let native_limit = native_limit
-        .checked_sub(calldata_native)
-        .and_then(|native| native.checked_sub(intrinsic_native as u64))
+        .checked_sub(intrinsic_computational_native_charged)
         .ok_or(TxError::Validation(
             errors::InvalidTransaction::OutOfNativeResourcesDuringValidation,
         ))?;
@@ -98,8 +111,12 @@ pub fn get_resources_for_tx<S: EthereumLikeTypes>(
         let ergs = gas_limit_for_tx
             .checked_mul(ERGS_PER_GAS)
             .ok_or(internal_error!("glft*EPF"))?;
-        let resources = S::Resources::from_ergs_and_native(Ergs(ergs), native_limit);
-        Ok((resources, withheld_resources))
+        let main_resources = S::Resources::from_ergs_and_native(Ergs(ergs), native_limit);
+        Ok(ResourcesForTx {
+            main_resources,
+            withheld,
+            intrinsic_computational_native_charged,
+        })
     }
 }
 ///
@@ -151,21 +168,21 @@ pub fn get_resources_to_charge_for_pubdata<S: EthereumLikeTypes>(
 /// spent pubdata.
 /// If base_pubdata is Some, it's discounted from the current
 /// pubdata counter.
-/// Returns if the check succeeded and the resources to charge
-/// for pubdata.
+/// Returns if the check succeeded, the resources to charge
+/// for pubdata and the net pubdata used.
 ///
 pub fn check_enough_resources_for_pubdata<S: EthereumLikeTypes>(
     system: &mut System<S>,
     native_per_pubdata: U256,
     resources: &S::Resources,
     base_pubdata: Option<u64>,
-) -> Result<(bool, S::Resources), InternalError> {
-    let (_, resources_for_pubdata) =
+) -> Result<(bool, S::Resources, u64), InternalError> {
+    let (pubdata_used, resources_for_pubdata) =
         get_resources_to_charge_for_pubdata(system, native_per_pubdata, base_pubdata)?;
     let _ = system.get_logger().write_fmt(format_args!(
         "Checking gas for pubdata, resources_for_pubdata: {:?}, resources: {:?}\n",
         resources_for_pubdata, resources
     ));
     let enough = resources.has_enough(&resources_for_pubdata);
-    Ok((enough, resources_for_pubdata))
+    Ok((enough, resources_for_pubdata, pubdata_used))
 }

basic_bootloader/src/bootloader/mod.rs

@@ -282,8 +282,8 @@ impl<S: EthereumLikeTypes> BasicBootloader<S> {
                         contract_address,
                         gas_used: tx_processing_result.gas_used,
                         gas_refunded: tx_processing_result.gas_refunded,
-                        #[cfg(feature = "report_native")]
-                        native_used: tx_processing_result.native_used,
+                        computational_native_used: tx_processing_result.computational_native_used,
+                        pubdata_used: tx_processing_result.pubdata_used,
                     }));
 
                     let mut keccak = Keccak256::new();