Price event bytes at the same rate as storage

contracts/eventer/src/lib.rs

@@ -8,6 +8,9 @@
 
 #![no_std]
 
+extern crate alloc;
+use alloc::vec::Vec;
+
 use piecrust_uplink as uplink;
 
 /// Struct that describes the state of the eventer contract
@@ -23,10 +26,23 @@ impl Eventer {
  uplink::emit("number", i);
  }
  }
+
+ pub fn emit_input(&mut self, input: Vec<u8>) -> (u64, u64) {
+ let spent_before = uplink::spent();
+ uplink::emit("input", input);
+ let spent_after = uplink::spent();
+ (spent_before, spent_after)
+ }
 }
 
 /// Expose `Eventer::emit_num()` to the host
 #[no_mangle]
 unsafe fn emit_events(arg_len: u32) -> u32 {
  uplink::wrap_call(arg_len, |num| STATE.emit_num(num))
 }
+
+/// Expose `Eventer::emit_input()` to the host
+#[no_mangle]
+unsafe fn emit_input(arg_len: u32) -> u32 {
+ uplink::wrap_call(arg_len, |input| STATE.emit_input(input))
+}

piecrust/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Make each event byte cost the same as a storage byte [#359]
+
 ### Fixed
 
 - Fix incomplete removal of economic protocol functionality

piecrust/src/config.rs

@@ -0,0 +1,8 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) DUSK NETWORK. All rights reserved.
+
+// The gas cost for each byte
+pub const BYTE_STORE_COST: i64 = 4;

piecrust/src/imports.rs

@@ -18,6 +18,7 @@ use piecrust_uplink::{
  ContractError, ContractId, ARGBUF_LEN, CONTRACT_ID_BYTES,
 };
 
+use crate::config::BYTE_STORE_COST;
 use crate::instance::{Env, WrappedInstance};
 use crate::Error;
 
@@ -324,6 +325,16 @@ pub(crate) fn emit(
  check_ptr(instance, topic_ofs, topic_len)?;
  check_arg(instance, arg_len)?;
 
+ // charge for each byte emitted in an event
+ let gas_remaining = instance.get_remaining_gas();
+ let gas_cost = BYTE_STORE_COST as u64 * (topic_len as u64 + arg_len as u64);
+
+ if gas_cost > gas_remaining {
+ instance.set_remaining_gas(0);
+ Err(Error::OutOfGas)?;
+ }
+ instance.set_remaining_gas(gas_remaining - gas_cost);
+
  let data = instance.with_arg_buf(|buf| {
  let arg_len = arg_len as usize;
  Vec::from(&buf[..arg_len])

piecrust/src/lib.rs

@@ -118,6 +118,7 @@
 #[macro_use]
 mod bytecode_macro;
 mod call_tree;
+mod config;
 mod contract;
 mod error;
 mod imports;

piecrust/src/vm.rs

@@ -18,6 +18,7 @@ use dusk_wasmtime::{
 };
 use tempfile::tempdir;
 
+use crate::config::BYTE_STORE_COST;
 use crate::session::{Session, SessionData};
 use crate::store::ContractStore;
 use crate::Error::{self, PersistenceError};
@@ -58,7 +59,6 @@ fn config() -> Config {
  // Support 64-bit memories
  config.wasm_memory64(true);
 
- const BYTE_STORE_COST: i64 = 4;
  const BYTE4_STORE_COST: i64 = 4 * BYTE_STORE_COST;
  const BYTE8_STORE_COST: i64 = 8 * BYTE_STORE_COST;
  const BYTE16_STORE_COST: i64 = 16 * BYTE_STORE_COST;

piecrust/tests/eventer.rs

@@ -38,3 +38,55 @@ pub fn vm_center_events() -> Result<(), Error> {
 
  Ok(())
 }
+
+#[test]
+pub fn event_costs() -> Result<(), Error> {
+ let vm = VM::ephemeral()?;
+
+ let mut session = vm.session(SessionData::builder())?;
+
+ let eventer_id = session.deploy(
+ contract_bytecode!("eventer"),
+ ContractData::builder().owner(OWNER),
+ LIMIT,
+ )?;
+
+ // This call is to "prime" the contract
+ let _ = session.call::<_, (u64, u64)>(
+ eventer_id,
+ "emit_input",
+ &vec![1u8; 100],
+ LIMIT,
+ )?;
+
+ let mut costs = vec![];
+
+ for size in (4..=40).step_by(4) {
+ let input = vec![1u8; size];
+ let (spent_before, spent_after) = session
+ .call::<_, (u64, u64)>(eventer_id, "emit_input", &input, LIMIT)?
+ .data;
+ let cost = spent_after - spent_before;
+ print!("{cost} ");
+ costs.push(cost);
+ }
+
+ // cost grows linearly with the amount of bytes processed, at a predictable
+ // rate.
+ //
+ // NOTE: it is not possible to directly test emission costs, unless this is
+ // externally configurable
+ let mut cost_diffs = Vec::with_capacity(costs.len() - 1);
+ for i in 0..costs.len() - 1 {
+ cost_diffs.push(costs[i + 1] - costs[i]);
+ }
+ let (ref_cost_diff, cost_diffs) = cost_diffs.split_first().unwrap();
+ for cost_diff in cost_diffs {
+ assert_eq!(
+ cost_diff, ref_cost_diff,
+ "cost should grow at a linear rate"
+ );
+ }
+
+ Ok(())
+}