feat(fees): move the open-bucket cascade carve into GenVM ✨

executor/src/lib.rs

@@ -470,6 +470,7 @@ pub async fn run_with_impl(
     };
 
     let data_fees_limit = supervisor.shared_data.gep(|x| &x.data_fees_limit);
+    let message_fee_cascade = entry_data.message_fee_cascade;
 
     let essential_data = Box::new(wasi::genlayer_sdk::SingleVMData {
         limiter: limiter_det,
@@ -515,7 +516,11 @@ pub async fn run_with_impl(
         granted_custom: Vec::new(),
     });
 
-    let run_result = rt::spawn_apply_run(&supervisor, essential_data).await?;
+    let mut run_result = rt::spawn_apply_run(&supervisor, essential_data).await?;
+
+    if let Some(cascade) = &message_fee_cascade {
+        rt::cascade::apply(&mut run_result.vm_data.accumulator.emissions, cascade);
+    }
 
     if let Some(code) = extra_leader_nondet_output_error(&supervisor, &run_result.run_ok) {
         return Ok(rt::vm::FullResult::empty_from(rt::vm::RunOk::FatalVMError(

executor/src/rt/cascade.rs

@@ -0,0 +1,54 @@
+use primitive_types::U256;
+
+use crate::domain::ExecutionEmission;
+
+fn pool_funded_fee(emission: &mut ExecutionEmission) -> Option<&mut U256> {
+    match emission {
+        ExecutionEmission::InternalMessage {
+            message_fee,
+            use_balance: false,
+            ..
+        }
+        | ExecutionEmission::InternalDeployMessage {
+            message_fee,
+            use_balance: false,
+            ..
+        } => Some(message_fee),
+        _ => None,
+    }
+}
+
+/// Raises each sender-pool internal message to the floor, then adds an equal
+/// share of half of `budget_total - Σ fees`; the other half stays with the
+/// parent so one deep path cannot drain the tree
+pub fn apply(
+    emissions: &mut [ExecutionEmission],
+    cascade: &genvm_modules_interfaces::fees::MessageFeeCascade,
+) {
+    let mut sum = U256::zero();
+    let mut count = 0u64;
+
+    for fee in emissions.iter_mut().filter_map(pool_funded_fee) {
+        *fee = (*fee).max(cascade.min_primary_fee);
+        sum = sum.saturating_add(*fee);
+        count += 1;
+    }
+
+    if count == 0 || sum >= cascade.budget_total {
+        return;
+    }
+
+    let per_child = (cascade.budget_total - sum) / (U256::from(2) * U256::from(count));
+    if per_child.is_zero() {
+        return;
+    }
+
+    // Each fee is at most `sum`, and `per_child` at most `budget_total - sum`
+    for fee in emissions.iter_mut().filter_map(pool_funded_fee) {
+        *fee += per_child;
+    }
+}
+
+#[cfg(test)]
+#[path = "cascade_test.rs"]
+mod tests;

executor/src/rt/cascade_test.rs

@@ -0,0 +1,110 @@
+use super::*;
+use genlayer_sdk::abi;
+
+fn internal(message_fee: u64, use_balance: bool) -> ExecutionEmission {
+    ExecutionEmission::InternalMessage {
+        call_key: abi::CallKey([0; 32]),
+        address: genlayer_sdk::calldata::Address::zero(),
+        calldata: abi::entry::MainCallData {
+            name: None,
+            args: None,
+            kwargs: None,
+        },
+        value: U256::zero(),
+        on: abi::gl_call::On::Finalized,
+        message_fee: U256::from(message_fee),
+        receipt_fee: U256::from(7),
+        fee_params: abi::fees::InternalMessageParams {
+            leader_time_units_allocation: U256::one(),
+            validator_time_units_allocation: U256::one(),
+            execution_budget_per_round: U256::one(),
+            rotations: vec![U256::one()],
+            max_price_gen_per_time_unit: U256::one(),
+            storage_fee_max_gas_price: U256::one(),
+            receipt_fee_max_gas_price: U256::one(),
+        },
+        subtree: bytes::Bytes::new(),
+        use_balance,
+    }
+}
+
+fn external(message_fee: u64) -> ExecutionEmission {
+    ExecutionEmission::ExternalMessage {
+        address: genlayer_sdk::calldata::Address::zero(),
+        calldata: bytes::Bytes::new(),
+        value: U256::zero(),
+        message_fee: U256::from(message_fee),
+        receipt_fee: U256::zero(),
+        fee_params: abi::fees::ExternalMessageParams {
+            gas_limit: U256::one(),
+            max_gas_price: U256::one(),
+        },
+    }
+}
+
+fn cascade(
+    min_primary_fee: u64,
+    budget_total: u64,
+) -> genvm_modules_interfaces::fees::MessageFeeCascade {
+    genvm_modules_interfaces::fees::MessageFeeCascade {
+        min_primary_fee: U256::from(min_primary_fee),
+        budget_total: U256::from(budget_total),
+    }
+}
+
+fn fees(emissions: &[ExecutionEmission]) -> Vec<u64> {
+    emissions
+        .iter()
+        .map(|e| match e {
+            ExecutionEmission::InternalMessage { message_fee, .. }
+            | ExecutionEmission::InternalDeployMessage { message_fee, .. }
+            | ExecutionEmission::ExternalMessage { message_fee, .. } => message_fee.low_u64(),
+            ExecutionEmission::Event { .. } => 0,
+        })
+        .collect()
+}
+
+#[test]
+fn floors_then_splits_half_of_spare() {
+    let mut emissions = vec![internal(10, false), internal(40, false), external(5)];
+    apply(&mut emissions, &cascade(30, 1_000));
+    // floors 30 + 40 = 70, spare 930, per child 930 / 4 = 232
+    assert_eq!(fees(&emissions), vec![262, 272, 5]);
+}
+
+#[test]
+fn balance_funded_messages_are_neither_floored_nor_counted() {
+    let mut emissions = vec![internal(10, true), internal(10, false)];
+    apply(&mut emissions, &cascade(30, 130));
+    // spare 100 over 1 child
+    assert_eq!(fees(&emissions), vec![10, 80]);
+}
+
+#[test]
+fn no_spare_only_floors() {
+    let mut emissions = vec![internal(10, false), internal(10, false)];
+    apply(&mut emissions, &cascade(30, 60));
+    assert_eq!(fees(&emissions), vec![30, 30]);
+}
+
+#[test]
+fn share_rounding_to_zero_only_floors() {
+    let mut emissions = vec![internal(30, false), internal(30, false)];
+    apply(&mut emissions, &cascade(30, 63));
+    assert_eq!(fees(&emissions), vec![30, 30]);
+}
+
+#[test]
+fn saturated_sum_is_not_spare() {
+    let mut emissions = vec![internal(0, false), internal(0, false)];
+    let mut big = cascade(0, 0);
+    big.min_primary_fee = U256::MAX;
+    big.budget_total = U256::MAX;
+    apply(&mut emissions, &big);
+    for e in &emissions {
+        let ExecutionEmission::InternalMessage { message_fee, .. } = e else {
+            unreachable!()
+        };
+        assert_eq!(*message_fee, U256::MAX);
+    }
+}

executor/src/rt/mod.rs

@@ -1,3 +1,4 @@
+pub mod cascade;
 pub mod errors;
 pub mod fees;
 pub mod memlimiter;

tests/integration/message/open_bucket_cascade/open_bucket_cascade.0.hash

@@ -0,0 +1 @@
+wKyumvQsLVjanIRIwjvLhl2jxkHaLJqX7ivPkbkELEY=

tests/integration/message/open_bucket_cascade/open_bucket_cascade.0.stdout

@@ -0,0 +1 @@
+executed with `Return(null)`

tests/integration/message/open_bucket_cascade/open_bucket_cascade.0_0.hash

@@ -0,0 +1 @@
+5nMefmkNp/gTzk2VAHkVPzAGkzwLXC+F1mej3QCQl/s=

tests/integration/message/open_bucket_cascade/open_bucket_cascade.0_0.stdout

@@ -0,0 +1,4 @@
+executed with `Return(null)`
+{"address":addr#3030303030303030303030303030303030303030,"call_key":b#666f6f0000000000000000000000000000000000000000000000000000000000,"calldata":{"":"foo","args":[1]},"fee_params":{"execution_budget_per_round":1024,"leader_timeunits_allocation":5,"max_price_gen_per_time_unit":1,"receipt_fee_max_gas_price":20,"rotations":[4,4,4,4,4],"storage_fee_max_gas_price":20,"validator_timeunits_allocation":5},"message_fee":300000,"on":"finalized","receipt_fee":1121,"subtree":b#,"type":"InternalMessage","use_balance":false,"value":0}
+{"address":addr#3030303030303030303030303030303030303030,"call_key":b#666f6f0000000000000000000000000000000000000000000000000000000000,"calldata":{"":"foo","args":[2]},"fee_params":{"execution_budget_per_round":1024,"leader_timeunits_allocation":5,"max_price_gen_per_time_unit":2,"receipt_fee_max_gas_price":20,"rotations":[4,4,4,4,4],"storage_fee_max_gas_price":20,"validator_timeunits_allocation":5},"message_fee":53476,"on":"finalized","receipt_fee":1057,"subtree":b#,"type":"InternalMessage","use_balance":true,"value":0}
+{"address":addr#3030303030303030303030303030303030303030,"call_key":b#666f6f0000000000000000000000000000000000000000000000000000000000,"calldata":{"":"foo","args":[3]},"fee_params":{"execution_budget_per_round":1024,"leader_timeunits_allocation":5,"max_price_gen_per_time_unit":1,"receipt_fee_max_gas_price":1606938044258990275541962092341162602522202993782792835301376,"rotations":[4,4,4,4,4],"storage_fee_max_gas_price":1606938044258990275541962092341162602522202993782792835301376,"validator_timeunits_allocation":5},"message_fee":300000,"on":"decided","receipt_fee":1057,"subtree":b#,"type":"InternalMessage","use_balance":false,"value":0}

tests/integration/message/open_bucket_cascade/open_bucket_cascade.jsonnet

@@ -0,0 +1,23 @@
+local simple = import 'templates/simple_deploy.jsonnet';
+local msg = import 'templates/message.json';
+local util = import 'templates/util.jsonnet';
+local s = simple.run('${jsonnetDir}/${fileBaseName}.py');
+// Default open-pool wildcards plus the cascade a node sends for an open bucket
+local extra = {
+	'balances': {
+		'AQAAAAAAAAAAAAAAAAAAAAAAAAA=': 1000000,
+	},
+	'message_fee_cascade': {
+		'min_primary_fee': 100000,
+		'budget_total': 1000000,
+	},
+};
+{tags: util.features([['message', 'send'], ['balance'], ['fees', 'balance']], 'stable') + ['python'],
+	entry: util.addPaths([util.chain([
+		s + extra,
+		s + extra + {
+			'code': null,
+			'message': msg,
+			'calldata': std.manifestJsonEx({'': 'emit', 'args': []}, '    '),
+		},
+	])])}

tests/integration/message/open_bucket_cascade/open_bucket_cascade.py

@@ -0,0 +1,29 @@
+# { "Depends": "py-genlayer:test" }
+import genlayer as gl
+from genlayer.vm.public_abi import Permissions
+
+_PARAMS = gl.chain.InternalMessageParams(
+	leader_time_units_allocation=5,
+	validator_time_units_allocation=5,
+	execution_budget_per_round=1024,
+	rotations=[4, 4, 4, 4, 4],
+	max_price_gen_per_time_unit=2,
+	storage_fee_max_gas_price=20,
+	receipt_fee_max_gas_price=20,
+)
+
+
+class Contract(gl.contract.Contract):
+	def __init__(self):
+		gl.storage.Root.get().set_permission(
+			Permissions.CAN_USE_BALANCE_FOR_MESSAGE_FEES, True
+		)
+
+	@gl.public.write
+	def emit(self):
+		target = gl.contract.get_at(gl.Address(b'\x30' * 20))
+		# Both sender-pool messages are floored, then share half of the spare
+		# budget; the balance-funded one keeps its metered fee
+		target.emit().foo(1)
+		target.emit(use_balance=gl.contract.UseBalanceParams(_PARAMS)).foo(2)
+		target.emit(on='decided').foo(3)