From f6c3c4711ed526958cfe41fecdd3eb231582b802 Mon Sep 17 00:00:00 2001 From: sklppy88 Date: Sat, 7 Dec 2024 00:01:48 +0000 Subject: [PATCH] more --- .../aztec-nr/authwit/src/cheatcodes.nr | 2 +- .../aztec-nr/aztec/src/initializer.nr | 2 + .../contracts/auth_contract/src/main.nr | 2 + .../contracts/auth_contract/src/test/main.nr | 326 +++++++++++------- .../contracts/counter_contract/src/main.nr | 48 +-- .../contracts/router_contract/src/test.nr | 4 +- .../token_contract/src/test/burn_private.nr | 3 + yarn-project/txe/src/oracle/txe_oracle.ts | 3 +- .../txe/src/txe_service/txe_service.ts | 3 + .../txe/src/util/txe_world_state_db.ts | 15 +- 10 files changed, 250 insertions(+), 158 deletions(-) diff --git a/noir-projects/aztec-nr/authwit/src/cheatcodes.nr b/noir-projects/aztec-nr/authwit/src/cheatcodes.nr index 21347c52316..d6f6642f916 100644 --- a/noir-projects/aztec-nr/authwit/src/cheatcodes.nr +++ b/noir-projects/aztec-nr/authwit/src/cheatcodes.nr @@ -17,7 +17,7 @@ where C: CallInterface, { let target = call_interface.get_contract_address(); - let inputs = cheatcodes::get_private_context_inputs(get_block_number()); + let inputs = cheatcodes::get_private_context_inputs(get_block_number() - 1); let chain_id = inputs.tx_context.chain_id; let version = inputs.tx_context.version; let args_hash = hash_args(call_interface.get_args()); diff --git a/noir-projects/aztec-nr/aztec/src/initializer.nr b/noir-projects/aztec-nr/aztec/src/initializer.nr index 36dc2b41893..b9f3a197ede 100644 --- a/noir-projects/aztec-nr/aztec/src/initializer.nr +++ b/noir-projects/aztec-nr/aztec/src/initializer.nr @@ -14,6 +14,8 @@ use crate::{ pub fn mark_as_initialized_public(context: &mut PublicContext) { let init_nullifier = compute_unsiloed_contract_initialization_nullifier((*context).this_address()); + std::println("INIT_NULLIFIER"); + std::println(init_nullifier); context.push_nullifier(init_nullifier); } diff --git a/noir-projects/noir-contracts/contracts/auth_contract/src/main.nr b/noir-projects/noir-contracts/contracts/auth_contract/src/main.nr index b28debc8aad..76739e241ab 100644 --- a/noir-projects/noir-contracts/contracts/auth_contract/src/main.nr +++ b/noir-projects/noir-contracts/contracts/auth_contract/src/main.nr @@ -28,6 +28,8 @@ contract Auth { #[initializer] fn constructor(admin: AztecAddress) { assert(!admin.is_zero(), "invalid admin"); + std::println("CONTRACT ADDRESS"); + std::println(context.this_address()); storage.admin.initialize(admin); } diff --git a/noir-projects/noir-contracts/contracts/auth_contract/src/test/main.nr b/noir-projects/noir-contracts/contracts/auth_contract/src/test/main.nr index 7f8368a7005..48d0b7dee29 100644 --- a/noir-projects/noir-contracts/contracts/auth_contract/src/test/main.nr +++ b/noir-projects/noir-contracts/contracts/auth_contract/src/test/main.nr @@ -7,124 +7,214 @@ global CHANGE_AUTHORIZED_DELAY_BLOCKS: u32 = 5; // TODO (#8588): These were ported over directly from e2e tests. Refactor these in the correct TXe style. #[test] -unconstrained fn main() { +unconstrained fn authorized_is_unset_initially() { // Setup without account contracts. We are not using authwits here, so dummy accounts are enough - let (env, auth_contract_address, admin, to_authorize, other) = utils::setup(); + let (env, auth_contract_address, admin) = utils::setup(); - let authorized_is_unset_initially = || { - env.impersonate(admin); - let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); - assert_eq(authorized, AztecAddress::from_field(0)); - }; - authorized_is_unset_initially(); - - let non_admin_cannot_set_unauthorized = || { - env.impersonate(other); - env.assert_public_call_fails(Auth::at(auth_contract_address).set_authorized(to_authorize)); - }; - non_admin_cannot_set_unauthorized(); - - let admin_sets_authorized = || { - env.impersonate(admin); - Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); - env.advance_block_by(1); - - let scheduled_authorized = - Auth::at(auth_contract_address).get_scheduled_authorized().view(&mut env.public()); - assert_eq(scheduled_authorized, to_authorize); - }; - admin_sets_authorized(); - - let authorized_is_not_yet_effective = || { - env.impersonate(to_authorize); - let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); - assert_eq(authorized, AztecAddress::zero()); - - env.assert_private_call_fails(Auth::at(auth_contract_address).do_private_authorized_thing()); - }; - authorized_is_not_yet_effective(); - - let authorized_becomes_effective_after_delay = || { - env.impersonate(to_authorize); - - // We advance block by 4, because the delay is 5, and we initially advanced block by one after setting the value. See below comment for explanation. - env.advance_block_by(CHANGE_AUTHORIZED_DELAY_BLOCKS - 1); - let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); - assert_eq(authorized, to_authorize); - - let authorized_in_private: AztecAddress = - Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); - assert_eq(authorized_in_private, AztecAddress::zero()); - - // We need to always advance the block one more time to get the current value in private, compared to the value in public. - // To see why let's see this diagram. - // When we schedule a change in public, lets say we are at block 2 (building a tx to be included in block 2), which means the latest committed block is block 1. - // Thus, the value change will be set to block 7 (2 + 5). - // If we now advance our env by 5 blocks, we will be at block 7 (building a tx to be included in block 7), which means the latest committed block is block 6. - // Reading the value in public will work, because it will use the current block (7), and the current block is the block of change; but - // if we try to create a historical proof, we do not have access to block 7 yet, and have to build the proof off of block 6, but at this time, the value change will not have - // taken place yet, therefore we need to be at block 8 (building a tx to be included in block 8), for the historical proof to work, as it will have access to the full block 7 - // where the value change takes effect. - // Note: We do not see this behavior in the e2e tests because setting the value inplicitly advances the block number by 1. - // 1 2 3 4 5 6 7 8 9 - // | | | | | | | | | - // ^ - // value change scheduled here - // ^ - // get_authorized() (public) called here with block_number = 7 - // ^ - // get_authorized() (private) called here with block_number = 8 - env.advance_block_by(1); - let authorized_in_private_again = - Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); - assert_eq(authorized_in_private_again, to_authorize); - - Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); - }; - authorized_becomes_effective_after_delay(); - - let authorize_other = || { - env.impersonate(admin); - Auth::at(auth_contract_address).set_authorized(other).call(&mut env.public()); - env.advance_block_by(1); - - let scheduled_authorized = - Auth::at(auth_contract_address).get_scheduled_authorized().view(&mut env.public()); - assert_eq(scheduled_authorized, other); - - let authorized: AztecAddress = - Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); - assert_eq(authorized, to_authorize); - - env.impersonate(to_authorize); - Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); - - env.impersonate(other); - env.assert_private_call_fails(Auth::at(auth_contract_address).do_private_authorized_thing()); - }; - authorize_other(); - - let authorized_becomes_effective_after_delay_again = || { - env.impersonate(to_authorize); - - // We advance the block by 4 again like above - env.advance_block_by(CHANGE_AUTHORIZED_DELAY_BLOCKS - 1); - let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); - assert_eq(authorized, other); - - let authorized_in_private = - Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); - assert_eq(authorized_in_private, to_authorize); - - env.advance_block_by(1); - let authorized_in_private_again = - Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); - assert_eq(authorized_in_private_again, other); - - env.assert_private_call_fails(Auth::at(auth_contract_address).do_private_authorized_thing()); - - env.impersonate(other); - Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); - }; - authorized_becomes_effective_after_delay_again(); + env.impersonate(admin); + let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); + assert_eq(authorized, AztecAddress::from_field(0)); } + +#[test(should_fail)] +unconstrained fn non_admin_cannot_set_unauthorized() { + let (env, auth_contract_address, _, to_authorize, other) = utils::setup(); + + env.impersonate(other); + Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); +} + +#[test] +unconstrained fn admin_sets_unauthorized() { + let (env, auth_contract_address, admin, to_authorize) = utils::setup(); + env.impersonate(admin); + Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); + env.advance_block_by(1); + + let scheduled_authorized = + Auth::at(auth_contract_address).get_scheduled_authorized().view(&mut env.public()); + assert_eq(scheduled_authorized, to_authorize); +} + +#[test(should_fail)] +unconstrained fn authorized_is_not_yet_effective() { + let (env, auth_contract_address, admin, to_authorize) = utils::setup(); + env.impersonate(admin); + Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); + env.advance_block_by(1); + + env.impersonate(to_authorize); + let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); + assert_eq(authorized, AztecAddress::zero()); + + Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); +} + +#[test] +unconstrained fn authorized_becomes_effective_after_delay() { + let (env, auth_contract_address, admin, to_authorize) = utils::setup(); + env.impersonate(admin); + Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); + env.advance_block_by(1); + + env.impersonate(to_authorize); + + // We advance block by 4, because the delay is 5, and we initially advanced block by one after setting the value. See below comment for explanation. + env.advance_block_by(CHANGE_AUTHORIZED_DELAY_BLOCKS - 1); + let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); + assert_eq(authorized, to_authorize); + + let authorized_in_private: AztecAddress = + Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); + assert_eq(authorized_in_private, AztecAddress::zero()); + + // We need to always advance the block one more time to get the current value in private, compared to the value in public. + // To see why let's see this diagram. + // When we schedule a change in public, lets say we are at block 2 (building a tx to be included in block 2), which means the latest committed block is block 1. + // Thus, the value change will be set to block 7 (2 + 5). + // If we now advance our env by 5 blocks, we will be at block 7 (building a tx to be included in block 7), which means the latest committed block is block 6. + // Reading the value in public will work, because it will use the current block (7), and the current block is the block of change; but + // if we try to create a historical proof, we do not have access to block 7 yet, and have to build the proof off of block 6, but at this time, the value change will not have + // taken place yet, therefore we need to be at block 8 (building a tx to be included in block 8), for the historical proof to work, as it will have access to the full block 7 + // where the value change takes effect. + // Note: We do not see this behavior in the e2e tests because setting the value inplicitly advances the block number by 1. + // 1 2 3 4 5 6 7 8 9 + // | | | | | | | | | + // ^ + // value change scheduled here + // ^ + // get_authorized() (public) called here with block_number = 7 + // ^ + // get_authorized() (private) called here with block_number = 8 + env.advance_block_by(1); + let authorized_in_private_again = + Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); + assert_eq(authorized_in_private_again, to_authorize); + + Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); + env.advance_block_by(1); +} + +#[test] +unconstrained fn authorize_other() { + let (env, auth_contract_address, admin, to_authorize, other) = utils::setup(); + env.impersonate(admin); + Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); + env.advance_block_by(1); + + env.impersonate(to_authorize); + + // We advance block by 4, because the delay is 5, and we initially advanced block by one after setting the value. See below comment for explanation. + env.advance_block_by(CHANGE_AUTHORIZED_DELAY_BLOCKS - 1); + let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); + assert_eq(authorized, to_authorize); + + let authorized_in_private: AztecAddress = + Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); + assert_eq(authorized_in_private, AztecAddress::zero()); + + // We need to always advance the block one more time to get the current value in private, compared to the value in public. + // To see why let's see this diagram. + // When we schedule a change in public, lets say we are at block 2 (building a tx to be included in block 2), which means the latest committed block is block 1. + // Thus, the value change will be set to block 7 (2 + 5). + // If we now advance our env by 5 blocks, we will be at block 7 (building a tx to be included in block 7), which means the latest committed block is block 6. + // Reading the value in public will work, because it will use the current block (7), and the current block is the block of change; but + // if we try to create a historical proof, we do not have access to block 7 yet, and have to build the proof off of block 6, but at this time, the value change will not have + // taken place yet, therefore we need to be at block 8 (building a tx to be included in block 8), for the historical proof to work, as it will have access to the full block 7 + // where the value change takes effect. + // Note: We do not see this behavior in the e2e tests because setting the value inplicitly advances the block number by 1. + // 1 2 3 4 5 6 7 8 9 + // | | | | | | | | | + // ^ + // value change scheduled here + // ^ + // get_authorized() (public) called here with block_number = 7 + // ^ + // get_authorized() (private) called here with block_number = 8 + env.advance_block_by(1); + let authorized_in_private_again = + Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); + assert_eq(authorized_in_private_again, to_authorize); + + Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); + env.advance_block_by(1); + + env.impersonate(admin); + Auth::at(auth_contract_address).set_authorized(other).call(&mut env.public()); + // env.advance_block_by(1); + + // let scheduled_authorized = + // Auth::at(auth_contract_address).get_scheduled_authorized().view(&mut env.public()); + // assert_eq(scheduled_authorized, other); + + // let authorized: AztecAddress = + // Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); + // assert_eq(authorized, to_authorize); + + // env.impersonate(to_authorize); + // Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); + + // env.impersonate(other); + // Auth::at(auth_contract_address).do_private_authorized_thing(); +} + +// #[test] +// unconstrained fn authorized_becomes_effective_after_delay_again() { +// let (env, auth_contract_address, admin, to_authorize, other) = utils::setup(); +// env.impersonate(admin); +// Auth::at(auth_contract_address).set_authorized(to_authorize).call(&mut env.public()); +// env.advance_block_by(1); + +// env.impersonate(to_authorize); + +// // We advance block by 4, because the delay is 5, and we initially advanced block by one after setting the value. See below comment for explanation. +// env.advance_block_by(CHANGE_AUTHORIZED_DELAY_BLOCKS - 1); +// let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); +// assert_eq(authorized, to_authorize); + +// let authorized_in_private: AztecAddress = +// Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); +// assert_eq(authorized_in_private, AztecAddress::zero()); + +// env.advance_block_by(1); +// let authorized_in_private_again = +// Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); +// assert_eq(authorized_in_private_again, to_authorize); + +// Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); +// env.advance_block_by(1); + +// env.impersonate(admin); +// Auth::at(auth_contract_address).set_authorized(other).call(&mut env.public()); +// env.advance_block_by(1); + +// // let scheduled_authorized = +// // Auth::at(auth_contract_address).get_scheduled_authorized().view(&mut env.public()); +// // assert_eq(scheduled_authorized, other); + +// // let authorized: AztecAddress = +// // Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); +// // assert_eq(authorized, to_authorize); + +// // env.impersonate(to_authorize); +// // Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); + +// // env.impersonate(to_authorize); + +// // // We advance the block by 4 again like above +// // env.advance_block_by(CHANGE_AUTHORIZED_DELAY_BLOCKS - 1); +// // let authorized = Auth::at(auth_contract_address).get_authorized().view(&mut env.public()); +// // assert_eq(authorized, other); + +// // let authorized_in_private = +// // Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); +// // assert_eq(authorized_in_private, to_authorize); + +// // env.advance_block_by(1); +// // let authorized_in_private_again = +// // Auth::at(auth_contract_address).get_authorized_in_private().view(&mut env.private()); +// // assert_eq(authorized_in_private_again, other); + +// // env.impersonate(other); +// // Auth::at(auth_contract_address).do_private_authorized_thing().call(&mut env.private()); +// } diff --git a/noir-projects/noir-contracts/contracts/counter_contract/src/main.nr b/noir-projects/noir-contracts/contracts/counter_contract/src/main.nr index 575bde4cabf..99507d51b99 100644 --- a/noir-projects/noir-contracts/contracts/counter_contract/src/main.nr +++ b/noir-projects/noir-contracts/contracts/counter_contract/src/main.nr @@ -99,13 +99,13 @@ contract Counter { // docs:end:get_counter // docs:start:test_imports + use dep::aztec::note::lifecycle::destroy_note; use dep::aztec::note::note_getter::{MAX_NOTES_PER_PAGE, view_notes}; use dep::aztec::note::note_viewer_options::NoteViewerOptions; - use dep::aztec::note::lifecycle::destroy_note; + use dep::aztec::protocol_types::debug_log::debug_log_format; use dep::aztec::protocol_types::storage::map::derive_storage_slot_in_map; use dep::aztec::test::helpers::{cheatcodes, test_environment::TestEnvironment}; - use dep::aztec::protocol_types::debug_log::debug_log_format; // docs:end:test_imports // docs:start:txe_test_increment @@ -147,7 +147,6 @@ contract Counter { } // docs:end:txe_test_increment - #[test] unconstrained fn increment_test_abc() { // Setup env, generate keys @@ -225,7 +224,7 @@ contract Counter { let notes: BoundedVec = view_notes(owner_slot, options); } - #[test] + #[test] unconstrained fn increment_test() { // Setup env, generate keys let mut env = TestEnvironment::new(); @@ -265,49 +264,38 @@ contract Counter { Counter::at(contract_address).increment_two(owner, outgoing_viewer).call(&mut env.private()); let notes: BoundedVec = view_notes(owner_slot, options); - assert( - notes.len() == 3 - ); + assert(notes.len() == 3); assert(get_counter(owner) == 7); env.advance_block_by(1); let notes: BoundedVec = view_notes(owner_slot, options); assert(get_counter(owner) == 7); - assert( - notes.len() == 3 - ); + assert(notes.len() == 3); - Counter::at(contract_address).increment_three(owner, outgoing_viewer).call(&mut env.private()); + Counter::at(contract_address).increment_three(owner, outgoing_viewer).call( + &mut env.private(), + ); let notes: BoundedVec = view_notes(owner_slot, options); assert(get_counter(owner) == 7); - assert( - notes.len() == 4 - ); + assert(notes.len() == 4); env.advance_block_by(1); let notes: BoundedVec = view_notes(owner_slot, options); - std::println("COUNT"); - std::println((get_counter(owner))); - + assert(notes.len() == 4); assert(get_counter(owner) == 7); - assert( - notes.len() == 4 - ); - Counter::at(contract_address).decrement_three(owner, outgoing_viewer).call(&mut env.private()); - assert( - notes.len() == 4 + Counter::at(contract_address).decrement_three(owner, outgoing_viewer).call( + &mut env.private(), ); - std::println("COUNT"); - std::println((get_counter(owner))); - - // assert(get_counter(owner) == 8); + let notes: BoundedVec = view_notes(owner_slot, options); + assert(get_counter(owner) == 11); + assert(notes.len() == 5); env.advance_block_by(1); - std::println("COUNT"); - std::println((get_counter(owner))); - // assert(get_counter(owner) == 6); + let notes: BoundedVec = view_notes(owner_slot, options); + assert(get_counter(owner) == 6); + assert(notes.len() == 4); } #[test] diff --git a/noir-projects/noir-contracts/contracts/router_contract/src/test.nr b/noir-projects/noir-contracts/contracts/router_contract/src/test.nr index a708a71ad11..300b958e36d 100644 --- a/noir-projects/noir-contracts/contracts/router_contract/src/test.nr +++ b/noir-projects/noir-contracts/contracts/router_contract/src/test.nr @@ -10,7 +10,7 @@ unconstrained fn test_check_block_number() { let router_contract_address = router_contract.to_address(); let router = Router::at(router_contract_address); - env.advance_block_by(9); + env.advance_block_by(8); // First we sanity-check that current block number is as expected let current_block_number = env.block_number(); @@ -28,7 +28,7 @@ unconstrained fn test_fail_check_block_number() { let router_contract_address = router_contract.to_address(); let router = Router::at(router_contract_address); - env.advance_block_by(9); + env.advance_block_by(8); // First we sanity-check that current block number is as expected let current_block_number = env.block_number(); diff --git a/noir-projects/noir-contracts/contracts/token_contract/src/test/burn_private.nr b/noir-projects/noir-contracts/contracts/token_contract/src/test/burn_private.nr index a3ac58f79a1..84b07439cb3 100644 --- a/noir-projects/noir-contracts/contracts/token_contract/src/test/burn_private.nr +++ b/noir-projects/noir-contracts/contracts/token_contract/src/test/burn_private.nr @@ -19,6 +19,7 @@ unconstrained fn burn_private_on_behalf_of_other() { let (env, token_contract_address, owner, recipient, mint_amount) = utils::setup_and_mint_to_private(/* with_account_contracts */ true); let burn_amount = mint_amount / 10; + env.advance_block_by(1); // Burn on behalf of other let burn_call_interface = @@ -30,6 +31,8 @@ unconstrained fn burn_private_on_behalf_of_other() { ); // Impersonate recipient to perform the call env.impersonate(recipient); + env.advance_block_by(1); + // Burn tokens burn_call_interface.call(&mut env.private()); utils::check_private_balance(token_contract_address, owner, mint_amount - burn_amount); diff --git a/yarn-project/txe/src/oracle/txe_oracle.ts b/yarn-project/txe/src/oracle/txe_oracle.ts index ccc0ab8a742..1a0bf8c33da 100644 --- a/yarn-project/txe/src/oracle/txe_oracle.ts +++ b/yarn-project/txe/src/oracle/txe_oracle.ts @@ -631,6 +631,7 @@ export class TXE implements TypedOracle { new Fr(blockNumber + 6969), ...this.noteCache.getAllNullifiers(), ...this.manuallyCreatedNullifiers, + ...this.siloedNullifiersFromPublic, ]; txEffect.publicDataWrites = this.publicDataWrites; @@ -867,7 +868,7 @@ export class TXE implements TypedOracle { const simulator = new PublicTxSimulator( db, - new TXEWorldStateDB(db, new TXEPublicContractDataSource(this)), + new TXEWorldStateDB(db, new TXEPublicContractDataSource(this), this), new NoopTelemetryClient(), globalVariables, /*realAvmProvingRequests=*/ false, diff --git a/yarn-project/txe/src/txe_service/txe_service.ts b/yarn-project/txe/src/txe_service/txe_service.ts index 2ad824a463d..33b98cc5aa5 100644 --- a/yarn-project/txe/src/txe_service/txe_service.ts +++ b/yarn-project/txe/src/txe_service/txe_service.ts @@ -150,6 +150,7 @@ export class TXEService { startStorageSlot: ForeignCallSingle, values: ForeignCallArray, ) { + console.log('CALLING STORAGE WRITE'); const startStorageSlotFr = fromSingle(startStorageSlot); const valuesFr = fromArray(values); const contractAddressFr = addressFromSingle(contractAddress); @@ -319,6 +320,7 @@ export class TXEService { } async storageWrite(startStorageSlot: ForeignCallSingle, values: ForeignCallArray) { + console.log('CALLING STORAGE WRITE'); const newValues = await this.typedOracle.storageWrite(fromSingle(startStorageSlot), fromArray(values)); return toForeignCallResult([toArray(newValues)]); } @@ -601,6 +603,7 @@ export class TXEService { } async avmOpcodeStorageWrite(slot: ForeignCallSingle, value: ForeignCallSingle) { + console.log('CALLING STORAGE WRITE'); await this.typedOracle.storageWrite(fromSingle(slot), [fromSingle(value)]); return toForeignCallResult([]); } diff --git a/yarn-project/txe/src/util/txe_world_state_db.ts b/yarn-project/txe/src/util/txe_world_state_db.ts index d1a2b6f1737..4aa68d0e41b 100644 --- a/yarn-project/txe/src/util/txe_world_state_db.ts +++ b/yarn-project/txe/src/util/txe_world_state_db.ts @@ -5,12 +5,14 @@ import { Fr, PublicDataTreeLeaf, type PublicDataTreeLeafPreimage, + PublicDataWrite, } from '@aztec/circuits.js'; import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash'; import { WorldStateDB } from '@aztec/simulator'; +import { TXE } from '../oracle/txe_oracle.js'; export class TXEWorldStateDB extends WorldStateDB { - constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource) { + constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource, private txe: TXE) { super(merkleDb, dataSource); } @@ -31,11 +33,12 @@ export class TXEWorldStateDB extends WorldStateDB { } override async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise { - await this.merkleDb.batchInsert( - MerkleTreeId.PUBLIC_DATA_TREE, - [new PublicDataTreeLeaf(computePublicDataTreeLeafSlot(contract, slot), newValue).toBuffer()], - 0, - ); + await this.txe.addPublicDataWrites([new PublicDataWrite(computePublicDataTreeLeafSlot(contract, slot), newValue)]); + // await this.merkleDb.batchInsert( + // MerkleTreeId.PUBLIC_DATA_TREE, + // [new PublicDataTreeLeaf().toBuffer()], + // 0, + // ); return newValue.toBigInt(); }