diff --git a/noir-projects/aztec-nr/aztec/src/hash.nr b/noir-projects/aztec-nr/aztec/src/hash.nr index f19f266147e4..d729ce41ae51 100644 --- a/noir-projects/aztec-nr/aztec/src/hash.nr +++ b/noir-projects/aztec-nr/aztec/src/hash.nr @@ -14,7 +14,6 @@ pub fn compute_secret_hash(secret: Field) -> Field { pub fn compute_unencrypted_log_hash( contract_address: AztecAddress, - event_selector: Field, log: T ) -> Field where T: ToBytesForUnencryptedLog { let message_bytes: [u8; N] = log.to_be_bytes_arr(); @@ -26,16 +25,12 @@ pub fn compute_unencrypted_log_hash( for i in 0..32 { hash_bytes[i] = address_bytes[i]; } - let event_bytes = event_selector.to_be_bytes(4); - for i in 0..4 { - hash_bytes[32 + i] = event_bytes[i]; - } let len_bytes = (n as Field).to_be_bytes(4); for i in 0..4 { - hash_bytes[36 + i] = len_bytes[i]; + hash_bytes[32 + i] = len_bytes[i]; } for i in 0..n { - hash_bytes[40 + i] = message_bytes[i]; + hash_bytes[36 + i] = message_bytes[i]; } sha256_to_field(hash_bytes) @@ -148,7 +143,6 @@ fn compute_var_args_hash() { #[test] fn compute_unenc_log_hash_array() { let contract_address = AztecAddress::from_field(0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6); - let event_selector = 5; let log = [ 0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2, 0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c, @@ -156,33 +150,30 @@ fn compute_unenc_log_hash_array() { 0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2, 0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd ]; - let hash = compute_unencrypted_log_hash(contract_address, event_selector, log); - assert(hash == 0x00846d6969c8c2f61d39cd2762efcb0abb14f88d59c2675910251ef2bcffe9a7); + let hash = compute_unencrypted_log_hash(contract_address, log); + assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284); } #[test] fn compute_unenc_log_hash_addr() { let contract_address = AztecAddress::from_field(0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6); - let event_selector = 5; let log = AztecAddress::from_field(0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303); - let hash = compute_unencrypted_log_hash(contract_address, event_selector, log); - assert(hash == 0x00880a801230ea08c98a802a11b4786cba474513875f0fc69a615e81c5f9f21c); + let hash = compute_unencrypted_log_hash(contract_address, log); + assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3); } #[test] fn compute_unenc_log_hash_str() { let contract_address = AztecAddress::from_field(0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8); - let event_selector = 5; let log = "dummy"; - let hash = compute_unencrypted_log_hash(contract_address, event_selector, log); - assert(hash == 0x00a78b5347813624ecfd26e5b8bc6146f418b0cfcc8296b5112d09b8ebba9496); + let hash = compute_unencrypted_log_hash(contract_address, log); + assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20); } #[test] fn compute_unenc_log_hash_longer_str() { let contract_address = AztecAddress::from_field(0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8); - let event_selector = 5; let log = "Hello this is a string"; - let hash = compute_unencrypted_log_hash(contract_address, event_selector, log); - assert(hash == 0x001f3390ea242afee7ce46dafdbdc4bd4f1cf20cd63850d12d60ff9956712c4f); + let hash = compute_unencrypted_log_hash(contract_address, log); + assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841); } diff --git a/noir-projects/aztec-nr/aztec/src/oracle/logs.nr b/noir-projects/aztec-nr/aztec/src/oracle/logs.nr index 02bbd75de4af..e7bf8b0008d7 100644 --- a/noir-projects/aztec-nr/aztec/src/oracle/logs.nr +++ b/noir-projects/aztec-nr/aztec/src/oracle/logs.nr @@ -89,25 +89,23 @@ unconstrained pub fn compute_encrypted_event_log( } #[oracle(emitUnencryptedLog)] -unconstrained fn emit_unencrypted_log_oracle_private(_contract_address: AztecAddress, _event_selector: Field, _message: T, _counter: u32) -> Field {} +unconstrained fn emit_unencrypted_log_oracle_private(_contract_address: AztecAddress, _message: T, _counter: u32) -> Field {} unconstrained pub fn emit_unencrypted_log_private_internal( contract_address: AztecAddress, - event_selector: Field, message: T, counter: u32 ) -> Field { - emit_unencrypted_log_oracle_private(contract_address, event_selector, message, counter) + emit_unencrypted_log_oracle_private(contract_address, message, counter) } #[oracle(emitContractClassUnencryptedLog)] -unconstrained fn emit_contract_class_unencrypted_log_private(contract_address: AztecAddress, event_selector: Field, message: [Field; N], counter: u32) -> Field {} +unconstrained fn emit_contract_class_unencrypted_log_private(contract_address: AztecAddress, message: [Field; N], counter: u32) -> Field {} unconstrained pub fn emit_contract_class_unencrypted_log_private_internal( contract_address: AztecAddress, - event_selector: Field, message: [Field; N], counter: u32 ) -> Field { - emit_contract_class_unencrypted_log_private(contract_address, event_selector, message, counter) + emit_contract_class_unencrypted_log_private(contract_address, message, counter) } diff --git a/noir-projects/aztec-nr/aztec/src/oracle/logs_traits.nr b/noir-projects/aztec-nr/aztec/src/oracle/logs_traits.nr index c3d2cfb83c76..b874d949afd2 100644 --- a/noir-projects/aztec-nr/aztec/src/oracle/logs_traits.nr +++ b/noir-projects/aztec-nr/aztec/src/oracle/logs_traits.nr @@ -100,18 +100,18 @@ trait ToBytesForUnencryptedLog { fn output_bytes(self) -> [u8; M]; } -impl ToBytesForUnencryptedLog<32, 72> for Field { +impl ToBytesForUnencryptedLog<32, 68> for Field { fn to_be_bytes_arr(self) -> [u8; 32] { self.to_be_bytes(32).as_array() } - fn output_bytes(self) -> [u8; 72] {[self as u8; 72]} + fn output_bytes(self) -> [u8; 68] {[self as u8; 68]} } -impl ToBytesForUnencryptedLog<32, 72> for AztecAddress { +impl ToBytesForUnencryptedLog<32, 68> for AztecAddress { fn to_be_bytes_arr(self) -> [u8; 32] { self.to_field().to_be_bytes(32).as_array() } - fn output_bytes(self) -> [u8; 72] {[self.to_field() as u8; 72]} + fn output_bytes(self) -> [u8; 68] {[self.to_field() as u8; 68]} } fn arr_to_be_bytes_arr(fields: [Field; L]) -> [u8; N] { @@ -140,219 +140,219 @@ fn str_to_be_bytes_arr(string: str) -> [u8; N] { bytes.as_array() } -impl ToBytesForUnencryptedLog<32, 72> for [Field; 1] { +impl ToBytesForUnencryptedLog<32, 68> for [Field; 1] { fn to_be_bytes_arr(self) -> [u8; 32] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 72] { - [self[0] as u8; 72] + fn output_bytes(self) -> [u8; 68] { + [self[0] as u8; 68] } } -impl ToBytesForUnencryptedLog<64, 104> for [Field; 2] { +impl ToBytesForUnencryptedLog<64, 100> for [Field; 2] { fn to_be_bytes_arr(self) -> [u8; 64] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 104] { - [self[0] as u8; 104] + fn output_bytes(self) -> [u8; 100] { + [self[0] as u8; 100] } } -impl ToBytesForUnencryptedLog<96, 136> for [Field; 3] { +impl ToBytesForUnencryptedLog<96, 132> for [Field; 3] { fn to_be_bytes_arr(self) -> [u8; 96] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 136] { - [self[0] as u8; 136] + fn output_bytes(self) -> [u8; 132] { + [self[0] as u8; 132] } } -impl ToBytesForUnencryptedLog<128, 168> for [Field; 4] { +impl ToBytesForUnencryptedLog<128, 164> for [Field; 4] { fn to_be_bytes_arr(self) -> [u8; 128] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 168] { - [self[0] as u8; 168] + fn output_bytes(self) -> [u8; 164] { + [self[0] as u8; 164] } } -impl ToBytesForUnencryptedLog<160, 200> for [Field; 5] { +impl ToBytesForUnencryptedLog<160, 196> for [Field; 5] { fn to_be_bytes_arr(self) -> [u8; 160] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 200] { - [self[0] as u8; 200] + fn output_bytes(self) -> [u8; 196] { + [self[0] as u8; 196] } } -impl ToBytesForUnencryptedLog<192, 232> for [Field; 6] { +impl ToBytesForUnencryptedLog<192, 228> for [Field; 6] { fn to_be_bytes_arr(self) -> [u8; 192] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 232] { - [self[0] as u8; 232] + fn output_bytes(self) -> [u8; 228] { + [self[0] as u8; 228] } } -impl ToBytesForUnencryptedLog<224, 264> for [Field; 7] { +impl ToBytesForUnencryptedLog<224, 260> for [Field; 7] { fn to_be_bytes_arr(self) -> [u8; 224] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 264] { - [self[0] as u8; 264] + fn output_bytes(self) -> [u8; 260] { + [self[0] as u8; 260] } } -impl ToBytesForUnencryptedLog<256, 296> for [Field; 8] { +impl ToBytesForUnencryptedLog<256, 292> for [Field; 8] { fn to_be_bytes_arr(self) -> [u8; 256] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 296] { - [self[0] as u8; 296] + fn output_bytes(self) -> [u8; 292] { + [self[0] as u8; 292] } } -impl ToBytesForUnencryptedLog<288, 328> for [Field; 9] { +impl ToBytesForUnencryptedLog<288, 324> for [Field; 9] { fn to_be_bytes_arr(self) -> [u8; 288] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 328] { - [self[0] as u8; 328] + fn output_bytes(self) -> [u8; 324] { + [self[0] as u8; 324] } } -impl ToBytesForUnencryptedLog<320, 360> for [Field; 10] { +impl ToBytesForUnencryptedLog<320, 356> for [Field; 10] { fn to_be_bytes_arr(self) -> [u8; 320] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 360] { - [self[0] as u8; 360] + fn output_bytes(self) -> [u8; 356] { + [self[0] as u8; 356] } } -impl ToBytesForUnencryptedLog<352, 392> for [Field; 11] { +impl ToBytesForUnencryptedLog<352, 388> for [Field; 11] { fn to_be_bytes_arr(self) -> [u8; 352] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 392] { - [self[0] as u8; 392] + fn output_bytes(self) -> [u8; 388] { + [self[0] as u8; 388] } } -impl ToBytesForUnencryptedLog<384, 424> for [Field; 12] { +impl ToBytesForUnencryptedLog<384, 420> for [Field; 12] { fn to_be_bytes_arr(self) -> [u8; 384] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 424] { - [self[0] as u8; 424] + fn output_bytes(self) -> [u8; 420] { + [self[0] as u8; 420] } } -impl ToBytesForUnencryptedLog<416, 456> for [Field; 13] { +impl ToBytesForUnencryptedLog<416, 452> for [Field; 13] { fn to_be_bytes_arr(self) -> [u8; 416] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 456] { - [self[0] as u8; 456] + fn output_bytes(self) -> [u8; 452] { + [self[0] as u8; 452] } } -impl ToBytesForUnencryptedLog<448, 488> for [Field; 14] { +impl ToBytesForUnencryptedLog<448, 484> for [Field; 14] { fn to_be_bytes_arr(self) -> [u8; 448] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 488] { - [self[0] as u8; 488] + fn output_bytes(self) -> [u8; 484] { + [self[0] as u8; 484] } } -impl ToBytesForUnencryptedLog<480, 520> for [Field; 15] { +impl ToBytesForUnencryptedLog<480, 516> for [Field; 15] { fn to_be_bytes_arr(self) -> [u8; 480] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 520] { - [self[0] as u8; 520] + fn output_bytes(self) -> [u8; 516] { + [self[0] as u8; 516] } } -impl ToBytesForUnencryptedLog<512, 552> for [Field; 16] { +impl ToBytesForUnencryptedLog<512, 548> for [Field; 16] { fn to_be_bytes_arr(self) -> [u8; 512] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 552] { - [self[0] as u8; 552] + fn output_bytes(self) -> [u8; 548] { + [self[0] as u8; 548] } } -impl ToBytesForUnencryptedLog<544, 584> for [Field; 17] { +impl ToBytesForUnencryptedLog<544, 580> for [Field; 17] { fn to_be_bytes_arr(self) -> [u8; 544] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 584] { - [self[0] as u8; 584] + fn output_bytes(self) -> [u8; 580] { + [self[0] as u8; 580] } } -impl ToBytesForUnencryptedLog<576, 616> for [Field; 18] { +impl ToBytesForUnencryptedLog<576, 612> for [Field; 18] { fn to_be_bytes_arr(self) -> [u8; 576] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 616] { - [self[0] as u8; 616] + fn output_bytes(self) -> [u8; 612] { + [self[0] as u8; 612] } } -impl ToBytesForUnencryptedLog<608, 648> for [Field; 19] { +impl ToBytesForUnencryptedLog<608, 644> for [Field; 19] { fn to_be_bytes_arr(self) -> [u8; 608] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 648] { - [self[0] as u8; 648] + fn output_bytes(self) -> [u8; 644] { + [self[0] as u8; 644] } } -impl ToBytesForUnencryptedLog<640, 680> for [Field; 20] { +impl ToBytesForUnencryptedLog<640, 676> for [Field; 20] { fn to_be_bytes_arr(self) -> [u8; 640] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 680] { - [self[0] as u8; 680] + fn output_bytes(self) -> [u8; 676] { + [self[0] as u8; 676] } } -impl ToBytesForUnencryptedLog<672, 712> for [Field; 21] { +impl ToBytesForUnencryptedLog<672, 708> for [Field; 21] { fn to_be_bytes_arr(self) -> [u8; 672] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 712] { - [self[0] as u8; 712] + fn output_bytes(self) -> [u8; 708] { + [self[0] as u8; 708] } } -impl ToBytesForUnencryptedLog<704, 744> for [Field; 22] { +impl ToBytesForUnencryptedLog<704, 740> for [Field; 22] { fn to_be_bytes_arr(self) -> [u8; 704] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 744] { - [self[0] as u8; 744] + fn output_bytes(self) -> [u8; 740] { + [self[0] as u8; 740] } } -impl ToBytesForUnencryptedLog<736, 776> for [Field; 23] { +impl ToBytesForUnencryptedLog<736, 772> for [Field; 23] { fn to_be_bytes_arr(self) -> [u8; 736] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 776] { - [self[0] as u8; 776] + fn output_bytes(self) -> [u8; 772] { + [self[0] as u8; 772] } } -impl ToBytesForUnencryptedLog<768, 808> for [Field; 24] { +impl ToBytesForUnencryptedLog<768, 804> for [Field; 24] { fn to_be_bytes_arr(self) -> [u8; 768] { arr_to_be_bytes_arr(self) } - fn output_bytes(self) -> [u8; 808] { - [self[0] as u8; 808] + fn output_bytes(self) -> [u8; 804] { + [self[0] as u8; 804] } } diff --git a/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr b/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr index 3d2a944e38b9..d82807cc8fb0 100644 --- a/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr +++ b/noir-projects/noir-contracts/contracts/contract_class_registerer_contract/src/main.nr @@ -131,12 +131,11 @@ contract ContractClassRegisterer { // Ordinary logs are not protected by the above so this fn shouldn't be called by anything else #[contract_library_method] pub fn emit_contract_class_unencrypted_log(context: &mut PrivateContext, log: [Field; N]) { - let event_selector = 5; // TODO: compute actual event selector. let contract_address = context.this_address(); let counter = context.next_counter(); - let log_hash = emit_contract_class_unencrypted_log_private_internal(contract_address, event_selector, log, counter); - // 44 = addr (32) + selector (4) + raw log len (4) + processed log len (4) - let len = 44 + N * 32; + let log_hash = emit_contract_class_unencrypted_log_private_internal(contract_address, log, counter); + // 40 = addr (32) + raw log len (4) + processed log len (4) + let len = 40 + N * 32; let side_effect = LogHash { value: log_hash, counter, length: len }; context.unencrypted_logs_hashes.push(side_effect); } diff --git a/noir-projects/noir-contracts/contracts/contract_instance_deployer_contract/src/main.nr b/noir-projects/noir-contracts/contracts/contract_instance_deployer_contract/src/main.nr index 6b9582d3d799..2310b39f60a4 100644 --- a/noir-projects/noir-contracts/contracts/contract_instance_deployer_contract/src/main.nr +++ b/noir-projects/noir-contracts/contracts/contract_instance_deployer_contract/src/main.nr @@ -70,18 +70,14 @@ contract ContractInstanceDeployer { let contract_address = context.this_address(); let counter = context.next_counter(); - // The event_type_id is not strictly needed. So i'm setting it to 0 here, and we can then purge it - // later on. - let event_type_id = 0; - // @todo This is very inefficient, we are doing a lot of back and forth conversions. let log_slice = payload.to_be_bytes_arr(); - let log_hash = compute_unencrypted_log_hash(contract_address, event_type_id, payload); - // 44 = addr (32) + selector (4) + raw log len (4) + processed log len (4) - let len = 44 + log_slice.len().to_field(); + let log_hash = compute_unencrypted_log_hash(contract_address, payload); + // 40 = addr (32) + raw log len (4) + processed log len (4) + let len = 40 + log_slice.len().to_field(); let side_effect = LogHash { value: log_hash, counter, length: len }; context.unencrypted_logs_hashes.push(side_effect); - let _void = emit_unencrypted_log_private_internal(contract_address, event_type_id, payload, counter); + let _void = emit_unencrypted_log_private_internal(contract_address, payload, counter); } } diff --git a/noir-projects/noir-contracts/contracts/private_fpc_contract/src/lib.nr b/noir-projects/noir-contracts/contracts/private_fpc_contract/src/lib.nr index 3b1345c3a3e3..0f8e23c71a0d 100644 --- a/noir-projects/noir-contracts/contracts/private_fpc_contract/src/lib.nr +++ b/noir-projects/noir-contracts/contracts/private_fpc_contract/src/lib.nr @@ -5,12 +5,11 @@ use dep::aztec::context::PrivateContext; fn emit_nonce_as_unencrypted_log(context: &mut PrivateContext, nonce: Field) { let counter = context.next_counter(); - let event_type_id = 0; let log_slice = nonce.to_be_bytes_arr(); - let log_hash = compute_unencrypted_log_hash(context.this_address(), event_type_id, nonce); - // 44 = addr (32) + selector (4) + raw log len (4) + processed log len (4) - let len = 44 + log_slice.len().to_field(); + let log_hash = compute_unencrypted_log_hash(context.this_address(), nonce); + // 40 = addr (32) + raw log len (4) + processed log len (4) + let len = 40 + log_slice.len().to_field(); let side_effect = LogHash { value: log_hash, counter, length: len }; context.unencrypted_logs_hashes.push(side_effect); - let _void = emit_unencrypted_log_private_internal(context.this_address(), event_type_id, nonce, counter); + let _void = emit_unencrypted_log_private_internal(context.this_address(), nonce, counter); } diff --git a/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts b/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts index 828567e36e34..479356288b05 100644 --- a/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts +++ b/yarn-project/archiver/src/archiver/archiver_store_test_suite.ts @@ -1,6 +1,6 @@ import { InboxLeaf, L2Block, LogId, LogType, TxHash } from '@aztec/circuit-types'; import '@aztec/circuit-types/jest'; -import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js'; +import { AztecAddress, EventSelector, Fr, INITIAL_L2_BLOCK_NUM, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js'; import { makeContractClassPublic, makeExecutablePrivateFunctionWithMembershipProof, @@ -410,26 +410,6 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch } }); - it('"selector" filter param is respected', async () => { - // Get a random selector from the logs - const targetBlockIndex = randomInt(numBlocks); - const targetTxIndex = randomInt(txsPerBlock); - const targetFunctionLogIndex = randomInt(numPublicFunctionCalls); - const targetLogIndex = randomInt(numUnencryptedLogs); - const targetSelector = - blocks.retrievedData[targetBlockIndex].body.txEffects[targetTxIndex].unencryptedLogs.functionLogs[ - targetFunctionLogIndex - ].logs[targetLogIndex].selector; - - const response = await store.getUnencryptedLogs({ selector: targetSelector }); - - expect(response.maxLogsHit).toBeFalsy(); - - for (const extendedLog of response.logs) { - expect(extendedLog.log.selector.equals(targetSelector)).toBeTruthy(); - } - }); - it('"afterLog" filter param is respected', async () => { // Get a random log as reference const targetBlockIndex = randomInt(numBlocks); diff --git a/yarn-project/archiver/src/archiver/kv_archiver_store/log_store.ts b/yarn-project/archiver/src/archiver/kv_archiver_store/log_store.ts index dc928dae0095..98021283217b 100644 --- a/yarn-project/archiver/src/archiver/kv_archiver_store/log_store.ts +++ b/yarn-project/archiver/src/archiver/kv_archiver_store/log_store.ts @@ -180,18 +180,12 @@ export class LogStore { let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0; for (; logIndex < txLogs.length; logIndex++) { const log = txLogs[logIndex]; - if (filter.contractAddress && !log.contractAddress.equals(filter.contractAddress)) { - continue; - } - - if (filter.selector && !log.selector.equals(filter.selector)) { - continue; - } - - results.push(new ExtendedUnencryptedL2Log(new LogId(blockNumber, txIndex, logIndex), log)); - if (results.length >= this.#logsMaxPageSize) { - maxLogsHit = true; - break; + if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) { + results.push(new ExtendedUnencryptedL2Log(new LogId(blockNumber, txIndex, logIndex), log)); + if (results.length >= this.#logsMaxPageSize) { + maxLogsHit = true; + break; + } } } diff --git a/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts b/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts index eb483b552cfe..bbfbb6e311f1 100644 --- a/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts +++ b/yarn-project/archiver/src/archiver/memory_archiver_store/memory_archiver_store.ts @@ -388,7 +388,6 @@ export class MemoryArchiverStore implements ArchiverDataStore { } const contractAddress = filter.contractAddress; - const selector = filter.selector; const logs: ExtendedUnencryptedL2Log[] = []; @@ -401,8 +400,7 @@ export class MemoryArchiverStore implements ArchiverDataStore { const log = txLogs[logIndexInTx]; if ( (!txHash || block.body.txEffects[txIndexInBlock].txHash.equals(txHash)) && - (!contractAddress || log.contractAddress.equals(contractAddress)) && - (!selector || log.selector.equals(selector)) + (!contractAddress || log.contractAddress.equals(contractAddress)) ) { logs.push(new ExtendedUnencryptedL2Log(new LogId(block.number, txIndexInBlock, logIndexInTx), log)); if (logs.length === this.maxLogs) { diff --git a/yarn-project/circuit-types/src/logs/log_filter.ts b/yarn-project/circuit-types/src/logs/log_filter.ts index deb81e98efa3..93a33725b2f7 100644 --- a/yarn-project/circuit-types/src/logs/log_filter.ts +++ b/yarn-project/circuit-types/src/logs/log_filter.ts @@ -1,5 +1,4 @@ import { type AztecAddress } from '@aztec/circuits.js'; -import { type EventSelector } from '@aztec/foundation/abi'; import { type TxHash } from '../tx/tx_hash.js'; import { type LogId } from './log_id.js'; @@ -19,6 +18,4 @@ export type LogFilter = { afterLog?: LogId; /** The contract address to filter logs by. */ contractAddress?: AztecAddress; - /** Selector of the event/log topic. */ - selector?: EventSelector; }; diff --git a/yarn-project/circuit-types/src/logs/unencrypted_l2_log.ts b/yarn-project/circuit-types/src/logs/unencrypted_l2_log.ts index 152d0998bc62..173454cf9e6b 100644 --- a/yarn-project/circuit-types/src/logs/unencrypted_l2_log.ts +++ b/yarn-project/circuit-types/src/logs/unencrypted_l2_log.ts @@ -1,5 +1,4 @@ import { AztecAddress } from '@aztec/circuits.js'; -import { EventSelector } from '@aztec/foundation/abi'; import { randomBytes, sha256Trunc } from '@aztec/foundation/crypto'; import { BufferReader, prefixBufferWithLength, toHumanReadable } from '@aztec/foundation/serialize'; @@ -17,15 +16,13 @@ export class UnencryptedL2Log { * TODO: Optimize this once it makes sense. */ public readonly contractAddress: AztecAddress, - /** Selector of the event/log topic. */ - public readonly selector: EventSelector, /** The data contents of the log. */ public readonly data: Buffer, ) {} get length(): number { // TODO(6578): explain magic number 4 here - return EventSelector.SIZE + this.data.length + AztecAddress.SIZE_IN_BYTES + 4; + return this.data.length + AztecAddress.SIZE_IN_BYTES + 4; } /** @@ -33,11 +30,7 @@ export class UnencryptedL2Log { * @returns A buffer containing the serialized log. */ public toBuffer(): Buffer { - return Buffer.concat([ - this.contractAddress.toBuffer(), - this.selector.toBuffer(), - prefixBufferWithLength(this.data), - ]); + return Buffer.concat([this.contractAddress.toBuffer(), prefixBufferWithLength(this.data)]); } /** @@ -47,25 +40,20 @@ export class UnencryptedL2Log { */ public toHumanReadable(): string { const payload = toHumanReadable(this.data); - return `UnencryptedL2Log(contractAddress: ${this.contractAddress.toString()}, selector: ${this.selector.toString()}, data: ${payload})`; + return `UnencryptedL2Log(contractAddress: ${this.contractAddress.toString()}, data: ${payload})`; } /** Returns a JSON-friendly representation of the log. */ public toJSON(): object { return { contractAddress: this.contractAddress.toString(), - selector: this.selector.toString(), data: this.data.toString('hex'), }; } /** Converts a plain JSON object into an instance. */ public static fromJSON(obj: any) { - return new UnencryptedL2Log( - AztecAddress.fromString(obj.contractAddress), - EventSelector.fromString(obj.selector), - Buffer.from(obj.data, 'hex'), - ); + return new UnencryptedL2Log(AztecAddress.fromString(obj.contractAddress), Buffer.from(obj.data, 'hex')); } /** @@ -76,9 +64,8 @@ export class UnencryptedL2Log { public static fromBuffer(buffer: Buffer | BufferReader): UnencryptedL2Log { const reader = BufferReader.asReader(buffer); const contractAddress = AztecAddress.fromBuffer(reader); - const selector = EventSelector.fromBuffer(reader); const data = reader.readBuffer(); - return new UnencryptedL2Log(contractAddress, selector, data); + return new UnencryptedL2Log(contractAddress, data); } /** @@ -107,9 +94,8 @@ export class UnencryptedL2Log { */ public static random(): UnencryptedL2Log { const contractAddress = AztecAddress.random(); - const selector = EventSelector.random(); - const dataLength = EventSelector.SIZE + randomBytes(1)[0]; + const dataLength = randomBytes(1)[0]; const data = randomBytes(dataLength); - return new UnencryptedL2Log(contractAddress, selector, data); + return new UnencryptedL2Log(contractAddress, data); } } diff --git a/yarn-project/cli/src/cmds/get_logs.ts b/yarn-project/cli/src/cmds/get_logs.ts index 29afb7bbc6fb..871dc3c8291b 100644 --- a/yarn-project/cli/src/cmds/get_logs.ts +++ b/yarn-project/cli/src/cmds/get_logs.ts @@ -1,5 +1,4 @@ import { type AztecAddress, type LogFilter, type LogId, type TxHash } from '@aztec/aztec.js'; -import { type EventSelector } from '@aztec/foundation/abi'; import { type DebugLogger, type LogFn } from '@aztec/foundation/log'; import { sleep } from '@aztec/foundation/sleep'; @@ -11,7 +10,6 @@ export async function getLogs( toBlock: number, afterLog: LogId, contractAddress: AztecAddress, - selector: EventSelector, rpcUrl: string, follow: boolean, debugLogger: DebugLogger, @@ -28,7 +26,7 @@ export async function getLogs( } } - const filter: LogFilter = { txHash, fromBlock, toBlock, afterLog, contractAddress, selector }; + const filter: LogFilter = { txHash, fromBlock, toBlock, afterLog, contractAddress }; const fetchLogs = async () => { const response = await pxe.getUnencryptedLogs(filter); diff --git a/yarn-project/cli/src/index.ts b/yarn-project/cli/src/index.ts index 9b97fd90f069..786a0b09c747 100644 --- a/yarn-project/cli/src/index.ts +++ b/yarn-project/cli/src/index.ts @@ -17,7 +17,6 @@ import { parseOptionalAztecAddress, parseOptionalInteger, parseOptionalLogId, - parseOptionalSelector, parseOptionalTxHash, parsePartialAddress, parsePrivateKey, @@ -403,12 +402,11 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command { .option('-tb, --to-block ', 'Up to which block to fetch logs (defaults to latest).', parseOptionalInteger) .option('-al --after-log ', 'ID of a log after which to fetch the logs.', parseOptionalLogId) .option('-ca, --contract-address
', 'Contract address to filter logs by.', parseOptionalAztecAddress) - .option('-s, --selector ', 'Event selector to filter logs by.', parseOptionalSelector) .addOption(pxeOption) .option('--follow', 'If set, will keep polling for new logs until interrupted.') - .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, selector, rpcUrl, follow }) => { + .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, rpcUrl, follow }) => { const { getLogs } = await import('./cmds/get_logs.js'); - await getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, selector, rpcUrl, follow, debugLogger, log); + await getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, rpcUrl, follow, debugLogger, log); }); program diff --git a/yarn-project/pxe/src/pxe_service/pxe_service.ts b/yarn-project/pxe/src/pxe_service/pxe_service.ts index 7549f45efef9..6dcf9d3f421e 100644 --- a/yarn-project/pxe/src/pxe_service/pxe_service.ts +++ b/yarn-project/pxe/src/pxe_service/pxe_service.ts @@ -936,6 +936,7 @@ export class PXEService implements PXE { const decodedEvents = unencryptedLogs .map(unencryptedLog => { const unencryptedLogBuf = unencryptedLog.log.data; + // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission. if ( !EventSelector.fromBuffer(unencryptedLogBuf.subarray(unencryptedLogBuf.byteLength - 4)).equals( eventMetadata.eventSelector, diff --git a/yarn-project/simulator/src/acvm/oracle/oracle.ts b/yarn-project/simulator/src/acvm/oracle/oracle.ts index b3f04b974293..b5cbb0170737 100644 --- a/yarn-project/simulator/src/acvm/oracle/oracle.ts +++ b/yarn-project/simulator/src/acvm/oracle/oracle.ts @@ -387,18 +387,9 @@ export class Oracle { return bytes; } - emitUnencryptedLog( - [contractAddress]: ACVMField[], - [eventSelector]: ACVMField[], - message: ACVMField[], - [counter]: ACVMField[], - ): ACVMField { + emitUnencryptedLog([contractAddress]: ACVMField[], message: ACVMField[], [counter]: ACVMField[]): ACVMField { const logPayload = Buffer.concat(message.map(fromACVMField).map(f => f.toBuffer())); - const log = new UnencryptedL2Log( - AztecAddress.fromString(contractAddress), - EventSelector.fromField(fromACVMField(eventSelector)), - logPayload, - ); + const log = new UnencryptedL2Log(AztecAddress.fromString(contractAddress), logPayload); this.typedOracle.emitUnencryptedLog(log, +counter); return toACVMField(0); @@ -406,16 +397,11 @@ export class Oracle { emitContractClassUnencryptedLog( [contractAddress]: ACVMField[], - [eventSelector]: ACVMField[], message: ACVMField[], [counter]: ACVMField[], ): ACVMField { const logPayload = Buffer.concat(message.map(fromACVMField).map(f => f.toBuffer())); - const log = new UnencryptedL2Log( - AztecAddress.fromString(contractAddress), - EventSelector.fromField(fromACVMField(eventSelector)), - logPayload, - ); + const log = new UnencryptedL2Log(AztecAddress.fromString(contractAddress), logPayload); const logHash = this.typedOracle.emitContractClassUnencryptedLog(log, +counter); return toACVMField(logHash); diff --git a/yarn-project/simulator/src/public/side_effect_trace.test.ts b/yarn-project/simulator/src/public/side_effect_trace.test.ts index 63337b137352..63224eafddf7 100644 --- a/yarn-project/simulator/src/public/side_effect_trace.test.ts +++ b/yarn-project/simulator/src/public/side_effect_trace.test.ts @@ -1,6 +1,5 @@ import { UnencryptedL2Log } from '@aztec/circuit-types'; import { AztecAddress, EthAddress, Gas, L2ToL1Message } from '@aztec/circuits.js'; -import { EventSelector } from '@aztec/foundation/abi'; import { Fr } from '@aztec/foundation/fields'; import { SerializableContractInstance } from '@aztec/types/contracts'; @@ -207,11 +206,7 @@ describe('Side Effect Trace', () => { expect(trace.getCounter()).toBe(startCounterPlus1); const pxResult = toPxResult(trace); - const expectLog = new UnencryptedL2Log( - AztecAddress.fromField(address), - EventSelector.fromField(new Fr(0)), - Buffer.concat(log.map(f => f.toBuffer())), - ); + const expectLog = new UnencryptedL2Log(AztecAddress.fromField(address), Buffer.concat(log.map(f => f.toBuffer()))); expect(pxResult.unencryptedLogs.logs).toEqual([expectLog]); expect(pxResult.allUnencryptedLogs.logs).toEqual([expectLog]); expect(pxResult.unencryptedLogsHashes).toEqual([ diff --git a/yarn-project/simulator/src/public/side_effect_trace.ts b/yarn-project/simulator/src/public/side_effect_trace.ts index c397db272ac7..66e835ea6470 100644 --- a/yarn-project/simulator/src/public/side_effect_trace.ts +++ b/yarn-project/simulator/src/public/side_effect_trace.ts @@ -16,7 +16,6 @@ import { Nullifier, ReadRequest, } from '@aztec/circuits.js'; -import { EventSelector } from '@aztec/foundation/abi'; import { Fr } from '@aztec/foundation/fields'; import { createDebugLogger } from '@aztec/foundation/log'; import { type ContractInstanceWithAddress } from '@aztec/types/contracts'; @@ -177,8 +176,6 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface { // TODO(4805): check if some threshold is reached for max logs const ulog = new UnencryptedL2Log( AztecAddress.fromField(contractAddress), - // TODO(#7198): Remove event selector from UnencryptedL2Log - EventSelector.fromField(new Fr(0)), Buffer.concat(log.map(f => f.toBuffer())), ); const basicLogHash = Fr.fromBuffer(ulog.hash());