feat(vc): re-execution before attestation

noir-projects/noir-contracts/contracts/spam_contract/src/main.nr

@@ -6,6 +6,8 @@ use dep::aztec::macros::aztec;
 #[aztec]
 contract Spam {
 
+    global MAX_EXTERNAL_CALL_SPAM = 4;
+
     use dep::aztec::{
         prelude::{Map, AztecAddress, PublicMutable},
         encrypted_logs::{encrypted_note_emission::encode_and_encrypt_note_unconstrained},
@@ -29,7 +31,12 @@ contract Spam {
     }
 
     #[private]
-    fn spam(nullifier_seed: Field, nullifier_count: u32, call_public: bool) {
+    fn spam(
+        nullifier_seed: Field,
+        nullifier_count: u32,
+        call_public: bool,
+        call_recursive_spam: bool
+    ) {
         let caller = context.msg_sender();
         let caller_keys = get_public_keys(caller);
         let amount = U128::from_integer(1);
@@ -58,6 +65,10 @@ contract Spam {
                 MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
             ).enqueue(&mut context);
         }
+
+        if (call_recursive_spam) {
+            Spam::at(context.this_address()).public_spam_with_external_call(0, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL).enqueue(&mut context);
+        }
     }
 
     #[public]
@@ -69,4 +80,28 @@ contract Spam {
             storage.public_balances.at(i as Field).write(prev + one);
         }
     }
+
+    // TODO(md): add something to the public spam such that we can test further enqueued calls
+    #[public]
+    #[internal]
+    fn public_spam_with_external_call(start: u32, end: u32) {
+        let one = U128::from_integer(1);
+        for i in start..end {
+            let prev = storage.public_balances.at(i as Field).read();
+            storage.public_balances.at(i as Field).write(prev + one);
+        }
+
+        Spam::at(context.this_address()).recursive_spam(0).call(&mut context);
+    }
+
+    #[public]
+    fn recursive_spam(counter: u32) {
+        let one = U128::from_integer(1);
+        if (counter < MAX_EXTERNAL_CALL_SPAM) {
+            let prev = storage.public_balances.at(counter as Field).read();
+            storage.public_balances.at(counter as Field).write(prev + one);
+
+            Spam::at(context.this_address()).recursive_spam(counter + 1).call(&mut context);
+        }
+    }
 }

yarn-project/aztec-node/src/aztec-node/server.ts

@@ -166,7 +166,7 @@ export class AztecNodeService implements AztecNode {
 
     const simulationProvider = await createSimulationProvider(config, log);
 
-    const validatorClient = createValidatorClient(config, p2pClient);
+    const validatorClient = createValidatorClient(config, p2pClient, worldStateSynchronizer, archiver, telemetry);
 
     // now create the sequencer
     const sequencer = config.disableSequencer

yarn-project/circuits.js/src/hash/hash.ts

@@ -4,7 +4,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { numToUInt8, numToUInt16BE, numToUInt32BE } from '@aztec/foundation/serialize';
 
 import { GeneratorIndex } from '../constants.gen.js';
-import { type ScopedL2ToL1Message, VerificationKey } from '../structs/index.js';
+import { type ScopedL2ToL1Message } from '../structs/l2_to_l1_message.js';
+import { VerificationKey } from '../structs/verification_key.js';
 
 /**
  * Computes a hash of a given verification key.

yarn-project/circuits.js/src/structs/public_data_update_request.ts

@@ -1,8 +1,12 @@
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 
+import { computePublicDataTreeLeafSlot } from '../hash/hash.js';
+import { type ContractStorageUpdateRequest } from './contract_storage_update_request.js';
+
 /**
  * Write operations on the public data tree including the previous value.
  */
@@ -74,6 +78,12 @@ export class PublicDataUpdateRequest {
     return new PublicDataUpdateRequest(Fr.fromBuffer(reader), Fr.fromBuffer(reader), reader.readNumber());
   }
 
+  static fromContractStorageUpdateRequest(contractAddress: AztecAddress, updateRequest: ContractStorageUpdateRequest) {
+    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, updateRequest.storageSlot);
+
+    return new PublicDataUpdateRequest(leafSlot, updateRequest.newValue, updateRequest.counter);
+  }
+
   static empty() {
     return new PublicDataUpdateRequest(Fr.ZERO, Fr.ZERO, 0);
   }

yarn-project/end-to-end/Earthfile

@@ -2,7 +2,7 @@ VERSION 0.8
 
 e2e-p2p:
   LOCALLY
-  RUN ./scripts/e2e_test.sh ./src/e2e_p2p_network.test.ts
+  RUN ./scripts/e2e_test.sh ./src/e2e_p2p/ --runInBand
 
 e2e-l1-with-wall-time:
   LOCALLY

yarn-project/end-to-end/scripts/e2e_test.sh

@@ -1,13 +1,15 @@
 #!/bin/bash
 
-# Usage: ./e2e_test.sh <test>
+# Usage: ./e2e_test.sh <test> <...extra_args>
 # Optional environment variables:
 #   HARDWARE_CONCURRENCY (default: "")
 
 set -eu
 
 # Main positional parameter
 TEST="$1"
+shift
+
 # Default values for environment variables
 HARDWARE_CONCURRENCY="${HARDWARE_CONCURRENCY:-}"
 FAKE_PROOFS="${FAKE_PROOFS:-}"
@@ -18,4 +20,4 @@ if ! docker image ls --format '{{.Repository}}:{{.Tag}}' | grep -q "aztecprotoco
   exit 1
 fi
 
-docker run -e HARDWARE_CONCURRENCY="$HARDWARE_CONCURRENCY" -e FAKE_PROOFS="$FAKE_PROOFS" --rm aztecprotocol/end-to-end:$AZTEC_DOCKER_TAG "$TEST"
+docker run -e HARDWARE_CONCURRENCY="$HARDWARE_CONCURRENCY" -e FAKE_PROOFS="$FAKE_PROOFS" --rm aztecprotocol/end-to-end:$AZTEC_DOCKER_TAG "$TEST" $@

yarn-project/end-to-end/src/e2e_p2p/gossip_network.test.ts

@@ -0,0 +1,76 @@
+import { type AztecNodeService } from '@aztec/aztec-node';
+import { sleep } from '@aztec/aztec.js';
+
+import fs from 'fs';
+
+import { type NodeContext, createNodes } from '../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest, WAIT_FOR_TX_TIMEOUT } from './p2p_network.js';
+import { createPXEServiceAndSubmitTransactions } from './shared.js';
+
+// Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
+const NUM_NODES = 4;
+const NUM_TXS_PER_NODE = 2;
+const BOOT_NODE_UDP_PORT = 40600;
+
+const DATA_DIR = './data/gossip';
+
+describe('e2e_p2p_network', () => {
+  let t: P2PNetworkTest;
+  let nodes: AztecNodeService[];
+
+  beforeEach(async () => {
+    t = await P2PNetworkTest.create('e2e_p2p_network', NUM_NODES, BOOT_NODE_UDP_PORT);
+    await t.applyBaseSnapshots();
+    await t.setup();
+  });
+
+  afterEach(async () => {
+    await t.stopNodes(nodes);
+    await t.teardown();
+    for (let i = 0; i < NUM_NODES; i++) {
+      fs.rmSync(`${DATA_DIR}-${i}`, { recursive: true, force: true });
+    }
+  });
+
+  it('should rollup txs from all peers', async () => {
+    // create the bootstrap node for the network
+    if (!t.bootstrapNodeEnr) {
+      throw new Error('Bootstrap node ENR is not available');
+    }
+    // create our network of nodes and submit txs into each of them
+    // the number of txs per node and the number of txs per rollup
+    // should be set so that the only way for rollups to be built
+    // is if the txs are successfully gossiped around the nodes.
+    const contexts: NodeContext[] = [];
+    t.logger.info('Creating nodes');
+    nodes = await createNodes(
+      t.ctx.aztecNodeConfig,
+      t.peerIdPrivateKeys,
+      t.bootstrapNodeEnr,
+      NUM_NODES,
+      BOOT_NODE_UDP_PORT,
+      DATA_DIR,
+    );
+
+    // wait a bit for peers to discover each other
+    await sleep(4000);
+
+    t.logger.info('Submitting transactions');
+    for (const node of nodes) {
+      const context = await createPXEServiceAndSubmitTransactions(t.logger, node, NUM_TXS_PER_NODE);
+      contexts.push(context);
+    }
+
+    t.logger.info('Waiting for transactions to be mined');
+    // now ensure that all txs were successfully mined
+    await Promise.all(
+      contexts.flatMap((context, i) =>
+        context.txs.map(async (tx, j) => {
+          t.logger.info(`Waiting for tx ${i}-${j}: ${await tx.getTxHash()} to be mined`);
+          return tx.wait({ timeout: WAIT_FOR_TX_TIMEOUT });
+        }),
+      ),
+    );
+    t.logger.info('All transactions mined');
+  });
+});