diff --git a/program-runtime/src/accounts_data_meter.rs b/program-runtime/src/accounts_data_meter.rs index 2c8def2047..ef9c1fb60f 100644 --- a/program-runtime/src/accounts_data_meter.rs +++ b/program-runtime/src/accounts_data_meter.rs @@ -73,20 +73,22 @@ impl AccountsDataMeter { self.maximum.saturating_sub(self.current()) } - /// Consume accounts data space, in bytes. If `amount` is positive, we are *increasing* the - /// amount of accounts data space used. If `amount` is negative, we are *decreasing* the - /// amount of accounts data space used. If `amount` is greater than the remaining space, - /// return an error and *do not* consume more accounts data space. - pub fn consume(&mut self, amount: i64) -> Result<(), InstructionError> { + /// Adjust the space used by accounts data by `amount` (in bytes). + /// + /// If `amount` is *positive*, we *increase* the space used by accounts data. If `amount` is + /// *negative*, we *decrease* the space used by accounts data. If `amount` is greater than + /// the remaining space, return an error and *do not* adjust accounts data space. + pub fn adjust_delta(&mut self, amount: i64) -> Result<(), InstructionError> { if amount > self.remaining() as i64 { return Err(InstructionError::AccountsDataBudgetExceeded); } - self.consume_unchecked(amount); + self.adjust_delta_unchecked(amount); Ok(()) } - /// Unconditionally consume accounts data space. Refer to `consume()` for more documentation. - pub fn consume_unchecked(&mut self, amount: i64) { + /// Unconditionally adjust accounts data space. Refer to `adjust_delta()` for more + /// documentation. + pub fn adjust_delta_unchecked(&mut self, amount: i64) { self.delta = self.delta.saturating_add(amount); } } @@ -141,63 +143,65 @@ mod tests { } #[test] - fn test_consume() { + fn test_adjust_delta() { let initial_accounts_data_len = 0; let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len); // Test: simple, positive numbers - let result = accounts_data_meter.consume(0); + let result = accounts_data_meter.adjust_delta(0); assert!(result.is_ok()); - let result = accounts_data_meter.consume(1); + let result = accounts_data_meter.adjust_delta(1); assert!(result.is_ok()); - let result = accounts_data_meter.consume(4); + let result = accounts_data_meter.adjust_delta(4); assert!(result.is_ok()); - let result = accounts_data_meter.consume(9); + let result = accounts_data_meter.adjust_delta(9); assert!(result.is_ok()); - // Test: can consume the remaining amount + // Test: adjust_delta can use up the remaining amount let remaining = accounts_data_meter.remaining() as i64; - let result = accounts_data_meter.consume(remaining); + let result = accounts_data_meter.adjust_delta(remaining); assert!(result.is_ok()); assert_eq!(accounts_data_meter.remaining(), 0); } #[test] - fn test_consume_deallocate() { + fn test_adjust_delta_deallocate() { let initial_accounts_data_len = 10_000; let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len); let remaining_before = accounts_data_meter.remaining(); let amount = (initial_accounts_data_len / 2) as i64; let amount = -amount; - let result = accounts_data_meter.consume(amount); + let result = accounts_data_meter.adjust_delta(amount); assert!(result.is_ok()); let remaining_after = accounts_data_meter.remaining(); assert_eq!(remaining_after, remaining_before + amount.abs() as u64); } #[test] - fn test_consume_too_much() { + fn test_adjust_delta_exceeding() { let initial_accounts_data_len = 0; let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len); - // Test: consuming more than what's available (1) returns an error, (2) does not consume + // Test: adjusting delta by more than what's available + // (1) returns an error, + // (2) does not adjust delta let remaining = accounts_data_meter.remaining(); - let result = accounts_data_meter.consume(remaining as i64 + 1); + let result = accounts_data_meter.adjust_delta(remaining as i64 + 1); assert!(result.is_err()); assert_eq!(accounts_data_meter.remaining(), remaining); } #[test] - fn test_consume_zero() { + fn test_adjust_delta_zero() { // Pre-condition: set up the accounts data meter such that there is no remaining space let initial_accounts_data_len = 1234; let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len); accounts_data_meter.maximum = initial_accounts_data_len; assert_eq!(accounts_data_meter.remaining(), 0); - // Test: can always consume zero, even if there is no remaining space - let result = accounts_data_meter.consume(0); + // Test: can always adjust delta by zero, even if there is no remaining space + let result = accounts_data_meter.adjust_delta(0); assert!(result.is_ok()); } } diff --git a/program-runtime/src/invoke_context.rs b/program-runtime/src/invoke_context.rs index 6e0bebbe58..dfeeef1770 100644 --- a/program-runtime/src/invoke_context.rs +++ b/program-runtime/src/invoke_context.rs @@ -507,9 +507,10 @@ impl<'a> InvokeContext<'a> { let post_data_len = account.data().len() as i64; let data_len_delta = post_data_len.saturating_sub(pre_data_len); if cap_accounts_data_len { - self.accounts_data_meter.consume(data_len_delta)?; + self.accounts_data_meter.adjust_delta(data_len_delta)?; } else { - self.accounts_data_meter.consume_unchecked(data_len_delta); + self.accounts_data_meter + .adjust_delta_unchecked(data_len_delta); } Ok(()) @@ -600,9 +601,10 @@ impl<'a> InvokeContext<'a> { let post_data_len = account.data().len() as i64; let data_len_delta = post_data_len.saturating_sub(pre_data_len); if cap_accounts_data_len { - self.accounts_data_meter.consume(data_len_delta)?; + self.accounts_data_meter.adjust_delta(data_len_delta)?; } else { - self.accounts_data_meter.consume_unchecked(data_len_delta); + self.accounts_data_meter + .adjust_delta_unchecked(data_len_delta); } return Ok(());