Charge for new storage bytes

CHANGELOG.md

@@ -46,6 +46,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
     - If the `witnessses_size > policies.witness_limit`, then transaction will be rejected.
     - GTF opcode changed its hardcoded constants for fields. It should be updated according to the values from the specification on the Sway side.
 - [#633](https://github.com/FuelLabs/fuel-vm/pull/633): Limit receipt count to `u16::MAX`.
+- [#634](https://github.com/FuelLabs/fuel-vm/pull/634): Charge for storage per new byte written. Write opcodes now return the number of new storage slots created, instead of just a boolean on whether the value existed before.
 
 ### Fixed
 

fuel-tx/src/transaction/consensus_parameters/gas.rs

@@ -321,6 +321,7 @@ pub struct GasCostsValues {
     // Non-opcode costs
     pub contract_root: DependentCost,
     pub state_root: DependentCost,
+    pub new_storage_per_byte: Word,
     pub vm_initialization: Word,
 }
 
@@ -477,6 +478,7 @@ impl GasCostsValues {
             // Non-opcode costs
             contract_root: DependentCost::free(),
             state_root: DependentCost::free(),
+            new_storage_per_byte: 0,
             vm_initialization: 0,
         }
     }
@@ -594,6 +596,7 @@ impl GasCostsValues {
             // Non-opcode costs
             contract_root: DependentCost::unit(),
             state_root: DependentCost::unit(),
+            new_storage_per_byte: 1,
             vm_initialization: 1,
         }
     }

fuel-tx/src/transaction/consensus_parameters/gas/default_gas_costs.rs

@@ -171,6 +171,7 @@ pub fn default_gas_costs() -> GasCostsValues {
             base: 412,
             units_per_gas: 1,
         },
+        new_storage_per_byte: 1,
         vm_initialization: 2000,
     }
 }

fuel-vm/src/interpreter/blockchain.rs

@@ -6,6 +6,7 @@ use super::{
     },
     gas::{
         dependent_gas_charge,
+        gas_charge,
         ProfileGas,
     },
     internal::{
@@ -318,8 +319,18 @@ where
         rb: RegisterId,
         c: Word,
     ) -> IoResult<(), S::DataError> {
-        let (SystemRegisters { fp, pc, .. }, mut w) =
-            split_registers(&mut self.registers);
+        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte;
+        let (
+            SystemRegisters {
+                cgas,
+                ggas,
+                is,
+                fp,
+                pc,
+                ..
+            },
+            mut w,
+        ) = split_registers(&mut self.registers);
         let (result, got_result) = w
             .get_mut_two(WriteRegKey::try_from(ra)?, WriteRegKey::try_from(rb)?)
             .ok_or(RuntimeError::Recoverable(
@@ -336,6 +347,12 @@ where
                 storage,
                 memory,
                 context,
+                profiler: &mut self.profiler,
+                new_storage_gas_per_byte,
+                current_contract: self.frames.last().map(|frame| frame.to()).copied(),
+                cgas,
+                ggas,
+                is: is.as_ref(),
                 fp: fp.as_ref(),
                 pc,
             },
@@ -373,8 +390,18 @@ where
         rb: RegisterId,
         c: Word,
     ) -> IoResult<(), S::DataError> {
-        let (SystemRegisters { fp, pc, .. }, mut w) =
-            split_registers(&mut self.registers);
+        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte;
+        let (
+            SystemRegisters {
+                cgas,
+                ggas,
+                is,
+                fp,
+                pc,
+                ..
+            },
+            mut w,
+        ) = split_registers(&mut self.registers);
         let exists = &mut w[WriteRegKey::try_from(rb)?];
         let Self {
             ref mut storage,
@@ -387,6 +414,12 @@ where
                 storage,
                 memory,
                 context,
+                profiler: &mut self.profiler,
+                new_storage_gas_per_byte,
+                current_contract: self.frames.last().map(|frame| frame.to()).copied(),
+                cgas,
+                ggas,
+                is: is.as_ref(),
                 fp: fp.as_ref(),
                 pc,
             },
@@ -403,8 +436,14 @@ where
         c: Word,
         d: Word,
     ) -> IoResult<(), S::DataError> {
+        let new_storage_per_byte = self.gas_costs().new_storage_per_byte;
         let contract_id = self.internal_contract().copied();
-        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
+        let (
+            SystemRegisters {
+                is, cgas, ggas, pc, ..
+            },
+            mut w,
+        ) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(rb)?];
 
         let input = StateWriteQWord::new(a, c, d)?;
@@ -414,7 +453,20 @@ where
             ..
         } = self;
 
-        state_write_qword(&contract_id?, storage, memory.as_mut(), pc, result, input)
+        state_write_qword(
+            &contract_id?,
+            storage,
+            memory.as_mut(),
+            &mut self.profiler,
+            new_storage_per_byte,
+            self.frames.last().map(|frame| frame.to()).copied(),
+            cgas,
+            ggas,
+            is.as_ref(),
+            pc,
+            result,
+            input,
+        )
     }
 
     pub(crate) fn timestamp(
@@ -846,6 +898,12 @@ pub(crate) struct StateWordCtx<'vm, S> {
     pub storage: &'vm mut S,
     pub memory: &'vm [u8; MEM_SIZE],
     pub context: &'vm Context,
+    pub profiler: &'vm mut Profiler,
+    pub new_storage_gas_per_byte: Word,
+    pub current_contract: Option<ContractId>,
+    pub cgas: RegMut<'vm, CGAS>,
+    pub ggas: RegMut<'vm, GGAS>,
+    pub is: Reg<'vm, IS>,
     pub fp: Reg<'vm, FP>,
     pub pc: RegMut<'vm, PC>,
 }
@@ -857,6 +915,7 @@ pub(crate) fn state_read_word<S: InterpreterStorage>(
         context,
         fp,
         pc,
+        ..
     }: StateWordCtx<S>,
     result: &mut Word,
     got_result: &mut Word,
@@ -890,11 +949,17 @@ pub(crate) fn state_write_word<S: InterpreterStorage>(
         storage,
         memory,
         context,
+        profiler,
+        new_storage_gas_per_byte,
+        current_contract,
+        cgas,
+        ggas,
+        is,
         fp,
         pc,
     }: StateWordCtx<S>,
     a: Word,
-    exists: &mut Word,
+    created_new: &mut Word,
     c: Word,
 ) -> IoResult<(), S::DataError> {
     let key = CheckedMemConstLen::<{ Bytes32::LEN }>::new(a)?;
@@ -913,7 +978,23 @@ pub(crate) fn state_write_word<S: InterpreterStorage>(
         .merkle_contract_state_insert(contract, key, &value)
         .map_err(RuntimeError::Storage)?;
 
-    *exists = result.is_some() as Word;
+    *created_new = result.is_none() as Word;
+
+    if result.is_none() {
+        // New data was written, charge gas for it
+        let profiler = ProfileGas {
+            pc: pc.as_ref(),
+            is,
+            current_contract,
+            profiler,
+        };
+        gas_charge(
+            cgas,
+            ggas,
+            profiler,
+            (Bytes32::LEN as u64) * new_storage_gas_per_byte,
+        )?;
+    }
 
     Ok(inc_pc(pc)?)
 }
@@ -1123,10 +1204,17 @@ impl StateWriteQWord {
     }
 }
 
-fn state_write_qword<S: InterpreterStorage>(
+#[allow(clippy::too_many_arguments)]
+fn state_write_qword<'vm, S: InterpreterStorage>(
     contract_id: &ContractId,
     storage: &mut S,
     memory: &[u8; MEM_SIZE],
+    profiler: &'vm mut Profiler,
+    new_storage_gas_per_byte: Word,
+    current_contract: Option<ContractId>,
+    cgas: RegMut<'vm, CGAS>,
+    ggas: RegMut<'vm, GGAS>,
+    is: Reg<'vm, IS>,
     pc: RegMut<PC>,
     result_register: &mut Word,
     input: StateWriteQWord,
@@ -1139,11 +1227,26 @@ fn state_write_qword<S: InterpreterStorage>(
         .flat_map(|chunk| Some(Bytes32::from(<[u8; 32]>::try_from(chunk).ok()?)))
         .collect();
 
-    let any_none = storage
+    let unset_count = storage
         .merkle_contract_state_insert_range(contract_id, destination_key, &values)
-        .map_err(RuntimeError::Storage)?
-        .is_some();
-    *result_register = any_none as Word;
+        .map_err(RuntimeError::Storage)?;
+    *result_register = unset_count as Word;
+
+    if unset_count > 0 {
+        // New data was written, charge gas for it
+        let profiler = ProfileGas {
+            pc: pc.as_ref(),
+            is,
+            current_contract,
+            profiler,
+        };
+        gas_charge(
+            cgas,
+            ggas,
+            profiler,
+            (unset_count as u64) * (Bytes32::LEN as u64) * new_storage_gas_per_byte,
+        )?;
+    }
 
     inc_pc(pc)?;
 

fuel-vm/src/interpreter/blockchain/test.rs

@@ -64,6 +64,9 @@ fn test_state_read_word(
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     memory[0..ContractId::LEN].copy_from_slice(&[3u8; ContractId::LEN][..]);
     memory[32..64].copy_from_slice(&[4u8; 32][..]);
+    let is = 4;
+    let mut cgas = 1000;
+    let mut ggas = 1000;
     let mut pc = 4;
     let mut result = 0;
     let mut got_result = 0;
@@ -86,6 +89,12 @@ fn test_state_read_word(
             storage: &mut storage,
             memory: &mut memory,
             context: &context,
+            profiler: &mut Profiler::default(),
+            new_storage_gas_per_byte: 1,
+            current_contract: None,
+            cgas: RegMut::new(&mut cgas),
+            ggas: RegMut::new(&mut ggas),
+            is: Reg::new(&is),
             fp: Reg::new(&fp),
             pc: RegMut::new(&mut pc),
         };
@@ -97,6 +106,12 @@ fn test_state_read_word(
         storage: &mut storage,
         memory: &mut memory,
         context: &context,
+        profiler: &mut Profiler::default(),
+        new_storage_gas_per_byte: 1,
+        current_contract: None,
+        cgas: RegMut::new(&mut cgas),
+        ggas: RegMut::new(&mut ggas),
+        is: Reg::new(&is),
         fp: Reg::new(&fp),
         pc: RegMut::new(&mut pc),
     };
@@ -106,13 +121,13 @@ fn test_state_read_word(
     Ok((result, got_result))
 }
 
-#[test_case(false, 0, false, 32 => Ok(0); "Nothing set")]
-#[test_case(false, 0, true, 32 => Ok(1); "Something set")]
+#[test_case(false, 0, false, 32 => Ok(1); "Nothing set")]
+#[test_case(false, 0, true, 32 => Ok(0); "Something set")]
 #[test_case(true, 0, false, 32 => Err(RuntimeError::Recoverable(PanicReason::ExpectedInternalContext)); "Can't write state from external context")]
-#[test_case(false, 1, false, 32 => Ok(0); "Wrong contract id")]
-#[test_case(false, 0, false, 33 => Ok(0); "Wrong key")]
-#[test_case(false, 1, true, 32 => Ok(0); "Wrong contract id with existing")]
-#[test_case(false, 0, true, 33 => Ok(0); "Wrong key with existing")]
+#[test_case(false, 1, false, 32 => Ok(1); "Wrong contract id")]
+#[test_case(false, 0, false, 33 => Ok(1); "Wrong key")]
+#[test_case(false, 1, true, 32 => Ok(1); "Wrong contract id with existing")]
+#[test_case(false, 0, true, 33 => Ok(1); "Wrong key with existing")]
 #[test_case(true, 0, false, Word::MAX => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Overflowing key")]
 #[test_case(true, 0, false, VM_MAX_RAM => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Overflowing key ram")]
 fn test_state_write_word(
@@ -137,6 +152,10 @@ fn test_state_write_word(
         }
     };
 
+    let is = 4;
+    let mut cgas = 1000;
+    let mut ggas = 1000;
+
     if insert {
         let fp = 0;
         let context = Context::Call {
@@ -146,6 +165,12 @@ fn test_state_write_word(
             storage: &mut storage,
             memory: &mut memory,
             context: &context,
+            profiler: &mut Profiler::default(),
+            new_storage_gas_per_byte: 1,
+            current_contract: None,
+            cgas: RegMut::new(&mut cgas),
+            ggas: RegMut::new(&mut ggas),
+            is: Reg::new(&is),
             fp: Reg::new(&fp),
             pc: RegMut::new(&mut pc),
         };
@@ -157,6 +182,12 @@ fn test_state_write_word(
         storage: &mut storage,
         memory: &mut memory,
         context: &context,
+        new_storage_gas_per_byte: 1,
+        current_contract: None,
+        profiler: &mut Profiler::default(),
+        cgas: RegMut::new(&mut cgas),
+        ggas: RegMut::new(&mut ggas),
+        is: Reg::new(&is),
         fp: Reg::new(&fp),
         pc: RegMut::new(&mut pc),
     };