Merge pull request #3831 from dusk-network/charge_blob

rusk: add gas_per_blob configuration

Author: herr-seppia

consensus/src/lib.rs

@@ -27,7 +27,7 @@ mod validation;
 
 pub use ratification::step::build_ratification_payload;
 pub use validation::step::build_validation_payload;
-pub use validation::step::validate_blobs;
+pub use validation::step::validate_blob_sidecars;
 
 mod iteration_ctx;
 pub mod merkle;

consensus/src/validation/step.rs

@@ -145,7 +145,7 @@ impl<T: Operations + 'static, D: Database> ValidationStep<T, D> {
 
         for tx in candidate.txs().iter() {
             // Validate blobs
-            validate_blobs(tx).map_err(|e| {
+            validate_blob_sidecars(tx).map_err(|e| {
                 OperationError::InvalidBlob(format!(
                     "Failed to validate blobs in transaction {}: {e}",
                     hex::encode(tx.id())
@@ -187,17 +187,16 @@ impl<T: Operations + 'static, D: Database> ValidationStep<T, D> {
     }
 }
 
-pub fn validate_blobs(tx: &Transaction) -> Result<(), BlobError> {
+/// Validates the blob sidecars of a transaction.
+///
+/// This function checks the following:
+/// - Each blob has a valid commitment.
+/// - Each blob has a valid KZG proof.
+/// - Each blob's hash matches the commitment in the sidecar.
+///
+/// If the transaction is not a blob transaction, it returns `Ok(())`.
+pub fn validate_blob_sidecars(tx: &Transaction) -> Result<(), BlobError> {
     if let Some(blobs) = tx.inner.blob() {
-        match blobs.len() {
-            0 => Err(BlobError::BlobEmpty),
-            n if n > 6 => Err(BlobError::BlobTooMany(n)),
-            _n => {
-                // TODO: Add checks for gas price and gas limit
-                Ok(())
-            }
-        }?;
-
         for blob in blobs {
             // Check sidecar is present
             let sidecar = blob

core/CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Add support for `TransactionData::Blob`
+- Add `error::TxPreconditionError`
+- Add `transfer::deploy_check`
+- Add `transfer::blob_check`
 
 ## [1.3.0] - 2025-04-17
 

core/src/error.rs

@@ -6,7 +6,7 @@
 
 //! Error-type for dusk-core.
 
-use alloc::string::String;
+use alloc::string::{String, ToString};
 use core::fmt;
 
 /// The dusk-core error type.
@@ -76,3 +76,47 @@ impl From<dusk_bytes::Error> for Error {
         }
     }
 }
+
+/// Error type for checking transaction conditions.
+///
+/// This error is used to indicate that a transaction does not meet the
+/// minimum requirements for deployment or blob gas charges.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TxPreconditionError {
+    /// The gas price is too low to deploy a transaction.
+    DeployLowPrice(u64),
+    /// The gas limit is too low to deploy a transaction.
+    DeployLowLimit(u64),
+    /// The gas limit is too low to cover the blob gas charges.
+    BlobLowLimit(u64),
+    /// No blob attached to the transaction.
+    BlobEmpty,
+    /// Too many blobs attached to the transaction.
+    BlobTooMany(usize),
+}
+
+impl TxPreconditionError {
+    /// Return the implementation of toString to be used inside the VM.
+    ///
+    /// Replacing this with the standard display will break the state root
+    /// backward compatibility
+    #[must_use]
+    pub fn legacy_to_string(&self) -> String {
+        match self {
+            TxPreconditionError::DeployLowPrice(_) => {
+                "gas price too low to deploy"
+            }
+            TxPreconditionError::DeployLowLimit(_) => {
+                "not enough gas to deploy"
+            }
+            TxPreconditionError::BlobLowLimit(_) => "not enough gas for blobs",
+            TxPreconditionError::BlobEmpty => {
+                "no blob attached to the transaction"
+            }
+            TxPreconditionError::BlobTooMany(_) => {
+                "too many blobs in the transaction"
+            }
+        }
+        .to_string()
+    }
+}

core/src/lib.rs

@@ -25,7 +25,7 @@ pub mod stake;
 pub mod transfer;
 
 mod error;
-pub use error::Error;
+pub use error::{Error, TxPreconditionError};
 
 mod dusk;
 pub use dusk::{dusk, from_dusk, Dusk, LUX};

core/src/transfer.rs

@@ -22,6 +22,7 @@ use rand::{CryptoRng, RngCore};
 use rkyv::{Archive, Deserialize, Serialize};
 
 use crate::abi::ContractId;
+use crate::error::TxPreconditionError;
 use crate::signatures::bls::{
     PublicKey as AccountPublicKey, SecretKey as AccountSecretKey,
 };
@@ -430,6 +431,79 @@ impl Transaction {
             0
         }
     }
+
+    /// Returns the minimum gas charged for a blob transaction deployment.
+    /// If the transaction is not a blob transaction, it returns None.
+    #[must_use]
+    pub fn blob_charge(&self, gas_per_blob: u64) -> Option<u64> {
+        self.blob().map(|blobs| blobs.len() as u64 * gas_per_blob)
+    }
+
+    /// Check if the transaction is a deployment transaction and if it
+    /// meets the minimum requirements for gas price and gas limit.
+    ///
+    /// # Errors
+    /// Returns an error if the transaction is a deployment transaction and
+    /// the gas price is lower than the minimum required gas price or if the
+    /// gas limit is lower than the required deployment charge.
+    pub fn deploy_check(
+        &self,
+        gas_per_deploy_byte: u64,
+        min_deploy_gas_price: u64,
+        min_deploy_points: u64,
+    ) -> Result<(), TxPreconditionError> {
+        if self.deploy().is_some() {
+            let deploy_charge =
+                self.deploy_charge(gas_per_deploy_byte, min_deploy_points);
+
+            if self.gas_price() < min_deploy_gas_price {
+                return Err(TxPreconditionError::DeployLowPrice(
+                    min_deploy_gas_price,
+                ));
+            }
+            if self.gas_limit() < deploy_charge {
+                return Err(TxPreconditionError::DeployLowLimit(deploy_charge));
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Check if the transaction is a blob transaction and if it meets the
+    /// minimum requirements for gas limit.
+    ///
+    /// # Returns
+    /// - `Ok(Some(u64))` the minimum gas amount to charge if the transaction is
+    ///   a blob transaction.
+    /// - `Ok(None)` if the transaction is not a blob transaction.
+    /// - `Err(TxPreconditionError)` in case of an error.
+    ///
+    /// # Errors
+    /// Returns an error if the transaction is a blob transaction and:
+    /// - the gas limit is lower than the minimum charge.
+    /// - the number of blobs is zero or greater than 6.
+    pub fn blob_check(
+        &self,
+        gas_per_blob: u64,
+    ) -> Result<Option<u64>, TxPreconditionError> {
+        if let Some(blobs) = self.blob() {
+            match blobs.len() {
+                0 => Err(TxPreconditionError::BlobEmpty),
+                n if n > 6 => Err(TxPreconditionError::BlobTooMany(n)),
+                _ => Ok(()),
+            }?;
+        } else {
+            return Ok(None);
+        }
+
+        let min_charge = self.blob_charge(gas_per_blob);
+        if let Some(min_charge) = min_charge {
+            if self.gas_limit() < min_charge {
+                return Err(TxPreconditionError::BlobLowLimit(min_charge));
+            }
+        }
+        Ok(min_charge)
+    }
 }
 
 impl From<PhoenixTransaction> for Transaction {

node/src/mempool.rs

@@ -16,6 +16,7 @@ use conf::{
 };
 use dusk_consensus::config::MAX_BLOCK_SIZE;
 use dusk_consensus::errors::BlobError;
+use dusk_core::TxPreconditionError;
 use node_data::events::{Event, TransactionEvent};
 use node_data::get_current_timestamp;
 use node_data::ledger::{Header, SpendingId, Transaction};
@@ -89,6 +90,26 @@ impl From<BlobError> for TxAcceptanceError {
     }
 }
 
+impl From<TxPreconditionError> for TxAcceptanceError {
+    fn from(err: TxPreconditionError) -> Self {
+        match err {
+            TxPreconditionError::BlobLowLimit(min) => {
+                TxAcceptanceError::GasLimitTooLow(min)
+            }
+            TxPreconditionError::DeployLowLimit(min) => {
+                TxAcceptanceError::GasLimitTooLow(min)
+            }
+            TxPreconditionError::DeployLowPrice(min) => {
+                TxAcceptanceError::GasPriceTooLow(min)
+            }
+            TxPreconditionError::BlobEmpty => TxAcceptanceError::BlobEmpty,
+            TxPreconditionError::BlobTooMany(n) => {
+                TxAcceptanceError::BlobTooMany(n)
+            }
+        }
+    }
+}
+
 pub struct MempoolSrv {
     inbound: AsyncQueue<Message>,
     conf: Params,
@@ -258,27 +279,43 @@ impl MempoolSrv {
             return Err(TxAcceptanceError::GasPriceTooLow(1));
         }
 
-        if tx.inner.deploy().is_some() {
-            // TODO: Remove this duplicated code in favor of vm::deploy_check
+        {
+            // Mimic the VM's additional checks for transactions
             let vm = vm.read().await;
-            let min_deployment_gas_price = vm.min_deployment_gas_price();
-            if tx.gas_price() < min_deployment_gas_price {
-                return Err(TxAcceptanceError::GasPriceTooLow(
+
+            // Check deployment tx
+            if tx.inner.deploy().is_some() {
+                let min_deployment_gas_price = vm.min_deployment_gas_price();
+                let gas_per_deploy_byte = vm.gas_per_deploy_byte();
+                let min_deploy_points = vm.min_deploy_points();
+                tx.inner.deploy_check(
+                    gas_per_deploy_byte,
                     min_deployment_gas_price,
-                ));
+                    min_deploy_points,
+                )?;
             }
 
-            let gas_per_deploy_byte = vm.gas_per_deploy_byte();
-            let deploy_charge = tx
-                .inner
-                .deploy_charge(gas_per_deploy_byte, vm.min_deploy_points());
-            if tx.inner.gas_limit() < deploy_charge {
-                return Err(TxAcceptanceError::GasLimitTooLow(deploy_charge));
+            // Check blob tx
+            if tx.inner.blob().is_some() {
+                db.read()
+                    .await
+                    .view(|db| {
+                        db.block_label_by_height(vm.blob_activation_height())
+                    })
+                    .map_err(|e| {
+                        anyhow!("Cannot get blob activation height: {e}")
+                    })?
+                    .ok_or(anyhow!(
+                        "Blobs acceptance will start at block height: {}",
+                        vm.blob_activation_height()
+                    ))?;
+
+                let gas_per_blob = vm.gas_per_blob();
+                tx.inner.blob_check(gas_per_blob)?;
+                dusk_consensus::validate_blob_sidecars(tx)?;
             }
-        } else if tx.inner.blob().is_some() {
-            dusk_consensus::validate_blobs(tx)?;
-        } else {
-            let vm = vm.read().await;
+
+            // Check global minimum gas limit
             let min_gas_limit = vm.min_gas_limit();
             if tx.inner.gas_limit() < min_gas_limit {
                 return Err(TxAcceptanceError::GasLimitTooLow(min_gas_limit));

node/src/vm.rs

@@ -92,6 +92,9 @@ pub trait VMExecution: Send + Sync + 'static {
     fn min_deployment_gas_price(&self) -> u64;
     fn min_gas_limit(&self) -> u64;
     fn min_deploy_points(&self) -> u64;
+
+    fn gas_per_blob(&self) -> u64;
+    fn blob_activation_height(&self) -> u64;
 }
 
 #[allow(clippy::large_enum_variant)]

rusk/src/lib/node/vm.rs

@@ -287,6 +287,14 @@ impl VMExecution for Rusk {
     fn min_deploy_points(&self) -> u64 {
         self.vm_config.min_deploy_points
     }
+
+    fn gas_per_blob(&self) -> u64 {
+        self.vm_config.gas_per_blob
+    }
+
+    fn blob_activation_height(&self) -> u64 {
+        self.vm_config.feature(FEATURE_BLOB).unwrap_or(u64::MAX)
+    }
 }
 
 fn has_unique_elements<T>(iter: T) -> bool

rusk/src/lib/node/vm/config.rs

@@ -13,6 +13,13 @@ use serde::{Deserialize, Serialize};
 const fn default_gas_per_deploy_byte() -> u64 {
     100
 }
+
+// TODO: This is a temporary value. Change this value to the tuned one as soon
+// as it's rolled out.
+const fn default_gas_per_blob() -> u64 {
+    0
+}
+
 const fn default_min_deploy_points() -> u64 {
     5_000_000
 }
@@ -26,6 +33,10 @@ const fn default_block_gas_limit() -> u64 {
 /// Configuration for the execution of a transaction.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
+    /// The amount of gas points charged for each blob in a transaction
+    #[serde(default = "default_gas_per_blob")]
+    pub gas_per_blob: u64,
+
     /// The amount of gas points charged for each byte in a contract-deployment
     /// bytecode.
     #[serde(default = "default_gas_per_deploy_byte")]
@@ -60,11 +71,13 @@ impl Default for Config {
 
 pub(crate) mod feature {
     pub const FEATURE_ABI_PUBLIC_SENDER: &str = "ABI_PUBLIC_SENDER";
+    pub const FEATURE_BLOB: &str = "BLOB";
 }
 
 impl Config {
     pub fn new() -> Self {
         Self {
+            gas_per_blob: default_gas_per_blob(),
             gas_per_deploy_byte: default_gas_per_deploy_byte(),
             min_deployment_gas_price: default_min_deployment_gas_price(),
             min_deploy_points: default_min_deploy_points(),
@@ -123,11 +136,17 @@ impl Config {
             .feature(feature::FEATURE_ABI_PUBLIC_SENDER)
             .map(|activation| block_height >= activation)
             .unwrap_or_default();
+        let with_blob = self
+            .feature(feature::FEATURE_BLOB)
+            .map(|activation| block_height >= activation)
+            .unwrap_or_default();
         ExecutionConfig {
+            gas_per_blob: self.gas_per_blob,
             gas_per_deploy_byte: self.gas_per_deploy_byte,
             min_deploy_points: self.min_deploy_points,
             min_deploy_gas_price: self.min_deployment_gas_price,
             with_public_sender,
+            with_blob,
         }
     }