feat(avm): seeding of fuzzer fee payer balance (#19089)

Adds function to fund the fee_payer account in cpp and TS before we
start fuzzing the tx so that we can pay for the transaction fee for the
tx.

We use `maxFee` instead of `effectiveFee` so there is a slight
overestimation.

Author: IlyasRidhuan

barretenberg/cpp/src/barretenberg/avm_fuzzer/common/interfaces/dbs.cpp

@@ -5,9 +5,12 @@
 
 #include "barretenberg/common/throw_or_abort.hpp"
 #include "barretenberg/crypto/merkle_tree/indexed_tree/indexed_leaf.hpp"
+#include "barretenberg/crypto/poseidon2/poseidon2.hpp"
+#include "barretenberg/vm2/common/aztec_constants.hpp"
 #include "barretenberg/vm2/common/aztec_types.hpp"
 
 using namespace bb::avm2::simulation;
+using Poseidon2 = bb::crypto::Poseidon2<bb::crypto::Poseidon2Bn254ScalarFieldParams>;
 using namespace bb::crypto::merkle_tree;
 using namespace bb::world_state;
 
@@ -380,4 +383,18 @@ void FuzzerWorldStateManager::register_contract_address(const AztecAddress& cont
     ws->insert_indexed_leaves<NullifierLeafValue>(MerkleTreeId::NULLIFIER_TREE, { contract_nullifier }, fork_id);
 }
 
+void FuzzerWorldStateManager::write_fee_payer_balance(const AztecAddress& fee_payer, const FF& balance)
+{
+    if (fee_payer == 0) {
+        return;
+    }
+    FF fee_juice_balance_slot = Poseidon2::hash({ FEE_JUICE_BALANCES_SLOT, fee_payer });
+    FF leaf_slot =
+        Poseidon2::hash({ GENERATOR_INDEX__PUBLIC_LEAF_INDEX, FF(FEE_JUICE_ADDRESS), fee_juice_balance_slot });
+
+    // Write to public data tree using current fork
+    auto fork_id = fork_ids.top();
+    ws->update_public_data(PublicDataLeafValue(leaf_slot, balance), fork_id);
+}
+
 } // namespace bb::avm2::fuzzer

barretenberg/cpp/src/barretenberg/avm_fuzzer/common/interfaces/dbs.hpp

@@ -139,6 +139,7 @@ class FuzzerWorldStateManager {
 
     void reset_world_state();
     void register_contract_address(const AztecAddress& contract_address);
+    void write_fee_payer_balance(const AztecAddress& fee_payer, const FF& balance);
 
     world_state::WorldStateRevision get_current_revision() const;
     world_state::WorldStateRevision fork();

barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/constants.hpp

@@ -18,10 +18,10 @@ const FF SLOT_NUMBER = 1;
 const uint64_t TIMESTAMP = 1000000;
 const EthAddress COINBASE = EthAddress{ 0 };
 const AztecAddress FEE_RECIPIENT = AztecAddress{ 0 };
-const uint128_t FEE_PER_DA_GAS = 1;
-const uint128_t FEE_PER_L2_GAS = 1;
+constexpr uint128_t FEE_PER_DA_GAS = 1;
+constexpr uint128_t FEE_PER_L2_GAS = 1;
 const std::string TRANSACTION_HASH = "0xdeadbeef";
-const GasFees EFFECTIVE_GAS_FEES = GasFees{ .fee_per_da_gas = 0, .fee_per_l2_gas = 0 };
+constexpr GasFees EFFECTIVE_GAS_FEES = GasFees{ .fee_per_da_gas = FEE_PER_DA_GAS, .fee_per_l2_gas = FEE_PER_L2_GAS };
 const FF FIRST_NULLIFIER = FF("0x00000000000000000000000000000000000000000000000000000000deadbeef");
 const std::vector<FF> NON_REVERTIBLE_ACCUMULATED_DATA_NULLIFIERS = { FIRST_NULLIFIER };
 const std::vector<FF> NON_REVERTIBLE_ACCUMULATED_DATA_NOTE_HASHES = {};

barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/simulator.cpp

@@ -75,7 +75,7 @@ SimulatorResult CppSimulator::simulate(fuzzer::FuzzerWorldStateManager& ws_mgr,
 {
 
     const PublicSimulatorConfig config{
-        .skip_fee_enforcement = true, // This is disabled once we need a prover fuzzer
+        .skip_fee_enforcement = false,
         .collect_call_metadata = true,
         .collect_public_inputs = true,
     };

barretenberg/cpp/src/barretenberg/avm_fuzzer/tx.fuzzer.cpp

@@ -37,7 +37,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         msgpack::unpack((reinterpret_cast<const char*>(data)), size).get().convert(tx_data);
     } catch (const std::exception& e) {
         fuzz_info("Failed to deserialize input in TestOneInput, creating default FuzzerTxData, exception: ", e.what());
-        return 0;
+        return -1; // Try rejecting inputs that cannot be deserialized
     }
 
     FuzzerWorldStateManager* ws_mgr = FuzzerWorldStateManager::getInstance();

barretenberg/cpp/src/barretenberg/avm_fuzzer/tx_fuzzer_lib.cpp

@@ -44,6 +44,14 @@ SimulatorResult fuzz_tx(FuzzerTxData& tx_data)
         ws_mgr->register_contract_address(addr);
     }
 
+    // Compute fee from gas limits and max fees per gas (upper bound on fee)
+    FF fee_required_da =
+        FF(tx_data.tx.gas_settings.gas_limits.da_gas) * FF(tx_data.tx.gas_settings.max_fees_per_gas.fee_per_da_gas);
+    FF fee_required_l2 =
+        FF(tx_data.tx.gas_settings.gas_limits.l2_gas) * FF(tx_data.tx.gas_settings.max_fees_per_gas.fee_per_l2_gas);
+
+    ws_mgr->write_fee_payer_balance(tx_data.tx.fee_payer, fee_required_da + fee_required_l2);
+
     // Run simulators
     auto cpp_simulator = CppSimulator();
     JsSimulator* js_simulator = JsSimulator::getInstance();

yarn-project/simulator/src/public/fuzzing/avm_fuzzer_simulator.ts

@@ -185,7 +185,7 @@ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
     super(contractDataSource, merkleTrees);
     const contractsDb = new PublicContractsDB(contractDataSource);
     this.simulator = new PublicTxSimulator(merkleTrees, contractsDb, globals, {
-      skipFeeEnforcement: true,
+      skipFeeEnforcement: false,
       collectDebugLogs: false,
       collectHints: false,
       collectStatistics: false,
@@ -209,6 +209,13 @@ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
    * Simulate a transaction from a C++ AvmTxHint.
    */
   public async simulate(txHint: AvmTxHint): Promise<PublicTxResult> {
+    // Compute fee from gas limits and max fees per gas (upper bound on fee)
+    const totalFee =
+      BigInt(txHint.gasSettings.gasLimits.daGas) * txHint.gasSettings.maxFeesPerGas.feePerDaGas +
+      BigInt(txHint.gasSettings.gasLimits.l2Gas) * txHint.gasSettings.maxFeesPerGas.feePerL2Gas;
+
+    await this.setFeePayerBalance(txHint.feePayer, new Fr(totalFee));
+
     const tx = await createTxFromHint(txHint);
     return await this.simulator.simulate(tx);
   }