chore: merge v4 into backport-to-v4-next-staging (#22010)

## Summary
Merges v4 branch into backport-to-v4-next-staging to bring in 17 commits
from v4 that were missing.

Key changes from v4:
- fix: verify accumulated pairing points in native ChonkVerifier
(#21975)
- chore: Properly compute finalized block (#21795, #21850)
- feat(archiver): validate contract instance addresses before storing
(#21787)
- feat(p2p): add tx validator for contract instance deployment addresses
(#21771)
- Various accumulated backports and bug fixes

## Conflicts resolved
6 files had merge conflicts, all resolved:
- `archiver/src/factory.ts` — kept `ContractClassPublicWithCommitment`
type from staging
- `archiver/src/modules/data_store_updater.ts` — merged imports from
both branches
- `archiver/src/store/kv_archiver_store.test.ts` — took v4's richer
describe block structure, adapted to singular `addProposedBlock` API
- `aztec-node/src/aztec-node/server.ts` — kept staging's block 0 check
and `getWorldState` method name
- `stdlib/src/tx/validator/error_texts.ts` — kept staging's contract
class error constants
- `world-state/src/synchronizer/server_world_state_synchronizer.ts` —
kept verbose log level

## Test plan
- CI should verify the merge compiles and tests pass
- Once merged, this branch can be merged into the backport-to-v4-next
branch

ClaudeBox log: https://claudebox.work/s/0150633f06bfb379?run=1

Author: spalladino

barretenberg/cpp/src/barretenberg/chonk/chonk_verifier.cpp

@@ -27,6 +27,12 @@ template <> ChonkVerifier<false>::Output ChonkVerifier<false>::verify(const Proo
     HidingKernelIO kernel_io;
     kernel_io.reconstruct_from_public(verifier.get_public_inputs());
 
+    // Check accumulated pairing points from the IVC chain (inner recursive verifications)
+    if (!kernel_io.pairing_inputs.check()) {
+        info("ChonkVerifier: verification failed at PI pairing points check");
+        return false;
+    }
+
     // Step 2: Perform databus consistency check
     const Commitment calldata_commitment = verifier.get_calldata_commitment();
     const Commitment return_data_commitment = kernel_io.kernel_return_data;

barretenberg/rust/bootstrap.sh

@@ -60,6 +60,12 @@ function release {
     (cd ../ts && yarn generate)
   fi
 
+  # Check if this version is already published on crates.io (idempotent re-runs).
+  if curl -sf -H "User-Agent: aztec-packages-ci (tech@aztec-labs.com)" "https://crates.io/api/v1/crates/barretenberg-rs/$version" | jq -e '.version.num' &>/dev/null; then
+    echo "barretenberg-rs@$version already published on crates.io. Skipping."
+    return 0
+  fi
+
   # Publish to crates.io (--allow-dirty because version was just set and generated files are gitignored)
   local extra_flags=""
   if ! gh release view "v$version" --repo AztecProtocol/aztec-packages &>/dev/null; then

noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr

@@ -117,8 +117,8 @@ pub fn assert_is_initialized_private(context: &mut PrivateContext) {
 /// Asserts that the contract has been initialized, from a utility function's perspective.
 ///
 /// Only checks the private initialization nullifier in the settled nullifier tree. Since both nullifiers are emitted
-/// in
-/// the same transaction, the private nullifier's presence in settled state guarantees the public one is also settled.
+/// in the same transaction, the private nullifier's presence in settled state guarantees the public one is also
+/// settled.
 pub unconstrained fn assert_is_initialized_utility(context: UtilityContext) {
     let address = context.this_address();
     let instance = get_contract_instance(address);

spartan/environments/network-defaults.yml

@@ -280,19 +280,19 @@ networks:
     # P2P
     P2P_MAX_PENDING_TX_COUNT: 1000
     P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true
-    # Slasher penalties
-    SLASH_PRUNE_PENALTY: 10e18
-    SLASH_DATA_WITHHOLDING_PENALTY: 10e18
-    SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9
-    SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1
-    SLASH_INACTIVITY_PENALTY: 10e18
-    SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10e18
-    SLASH_DUPLICATE_PROPOSAL_PENALTY: 10e18
-    SLASH_DUPLICATE_ATTESTATION_PENALTY: 10e18
-    SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10e18
-    SLASH_UNKNOWN_PENALTY: 10e18
-    SLASH_INVALID_BLOCK_PENALTY: 10e18
-    SLASH_GRACE_PERIOD_L2_SLOTS: 64
+    # Slasher penalties — must be >= AZTEC_SLASH_AMOUNT_SMALL (100000e18) to trigger votes
+    SLASH_PRUNE_PENALTY: 0
+    SLASH_DATA_WITHHOLDING_PENALTY: 0
+    SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7
+    SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2
+    SLASH_INACTIVITY_PENALTY: 100000e18
+    SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 100000e18
+    SLASH_DUPLICATE_PROPOSAL_PENALTY: 0
+    SLASH_DUPLICATE_ATTESTATION_PENALTY: 0
+    SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 100000e18
+    SLASH_UNKNOWN_PENALTY: 100000e18
+    SLASH_INVALID_BLOCK_PENALTY: 100000e18
+    SLASH_GRACE_PERIOD_L2_SLOTS: 3600
     ENABLE_VERSION_CHECK: true
 
   mainnet:

yarn-project/archiver/src/archiver-misc.test.ts

@@ -55,9 +55,7 @@ describe('Archiver misc', () => {
 
     const tracer = getTelemetryClient().getTracer('');
     const instrumentation = mock<ArchiverInstrumentation>({ isEnabled: () => true, tracer });
-    const archiverStore = new KVArchiverDataStore(await openTmpStore('archiver_misc_test'), 1000, {
-      epochDuration: EPOCH_DURATION,
-    });
+    const archiverStore = new KVArchiverDataStore(await openTmpStore('archiver_misc_test'), 1000);
     const events = new EventEmitter() as ArchiverEmitter;
     const l2TipsCache = new L2TipsCache(archiverStore.blockStore);
 

yarn-project/archiver/src/archiver-store.test.ts

@@ -61,7 +61,7 @@ describe('Archiver Store', () => {
     const tracer = getTelemetryClient().getTracer('');
     instrumentation = mock<ArchiverInstrumentation>({ isEnabled: () => true, tracer });
 
-    archiverStore = new KVArchiverDataStore(await openTmpStore('archiver_test'), 1000, { epochDuration: 4 });
+    archiverStore = new KVArchiverDataStore(await openTmpStore('archiver_test'), 1000);
 
     l1Constants = {
       l1GenesisTime: BigInt(now),
@@ -544,5 +544,47 @@ describe('Archiver Store', () => {
       expect(await archiver.getSynchedCheckpointNumber()).toEqual(CheckpointNumber(2));
       expect(await archiver.getProvenCheckpointNumber()).toEqual(CheckpointNumber(1));
     });
+
+    it('rolls back finalized checkpoint number when target is before finalized block', async () => {
+      const genesisArchive = new AppendOnlyTreeSnapshot(new Fr(GENESIS_ARCHIVE_ROOT), 1);
+      // Checkpoint 1: blocks 1-2, Checkpoint 2: blocks 3-4, Checkpoint 3: blocks 5-6
+      const testCheckpoints = await makeChainedCheckpoints(3, {
+        previousArchive: genesisArchive,
+        blocksPerCheckpoint: 2,
+      });
+      await archiverStore.addCheckpoints(testCheckpoints);
+
+      // Mark checkpoints 1 and 2 as proven and finalized
+      await archiverStore.setProvenCheckpointNumber(CheckpointNumber(2));
+      await archiverStore.setFinalizedCheckpointNumber(CheckpointNumber(2));
+      expect(await archiver.getFinalizedL2BlockNumber()).toEqual(BlockNumber(4));
+
+      // Roll back to block 2 (end of checkpoint 1), which is before finalized block 4
+      await archiver.rollbackTo(BlockNumber(2));
+
+      expect(await archiver.getSynchedCheckpointNumber()).toEqual(CheckpointNumber(1));
+      expect(await archiver.getFinalizedL2BlockNumber()).toEqual(BlockNumber(2));
+    });
+
+    it('preserves finalized checkpoint number when target is after finalized block', async () => {
+      const genesisArchive = new AppendOnlyTreeSnapshot(new Fr(GENESIS_ARCHIVE_ROOT), 1);
+      // Checkpoint 1: blocks 1-2, Checkpoint 2: blocks 3-4, Checkpoint 3: blocks 5-6
+      const testCheckpoints = await makeChainedCheckpoints(3, {
+        previousArchive: genesisArchive,
+        blocksPerCheckpoint: 2,
+      });
+      await archiverStore.addCheckpoints(testCheckpoints);
+
+      // Mark checkpoint 1 as finalized, checkpoint 2 as proven
+      await archiverStore.setProvenCheckpointNumber(CheckpointNumber(2));
+      await archiverStore.setFinalizedCheckpointNumber(CheckpointNumber(1));
+      expect(await archiver.getFinalizedL2BlockNumber()).toEqual(BlockNumber(2));
+
+      // Roll back to block 4 (end of checkpoint 2), which is after finalized block 2
+      await archiver.rollbackTo(BlockNumber(4));
+
+      expect(await archiver.getSynchedCheckpointNumber()).toEqual(CheckpointNumber(2));
+      expect(await archiver.getFinalizedL2BlockNumber()).toEqual(BlockNumber(2));
+    });
   });
 });

yarn-project/archiver/src/archiver-sync.test.ts

@@ -95,7 +95,7 @@ describe('Archiver Sync', () => {
     instrumentation = mock<ArchiverInstrumentation>({ isEnabled: () => true, tracer });
 
     // Create archiver store
-    archiverStore = new KVArchiverDataStore(await openTmpStore('archiver_sync_test'), 1000, { epochDuration: 32 });
+    archiverStore = new KVArchiverDataStore(await openTmpStore('archiver_sync_test'), 1000);
 
     const contractAddresses = {
       registryAddress,
@@ -1225,6 +1225,71 @@ describe('Archiver Sync', () => {
     }, 15_000);
   });
 
+  describe('finalized checkpoint', () => {
+    it('reports no finalized blocks before any checkpoint is proven', async () => {
+      fake.setL1BlockNumber(100n);
+      fake.setFinalizedL1BlockNumber(100n);
+      await archiver.syncImmediate();
+
+      const tips = await archiver.getL2Tips();
+      expect(tips.finalized.checkpoint.number).toEqual(CheckpointNumber(0));
+      expect(tips.finalized.block.number).toEqual(BlockNumber(0));
+    });
+
+    it('updates finalized checkpoint when the L1 finalized block is at or past the proven checkpoint L1 block', async () => {
+      const { checkpoint: cp1 } = await fake.addCheckpoint(CheckpointNumber(1), {
+        l1BlockNumber: 70n,
+        messagesL1BlockNumber: 50n,
+        numL1ToL2Messages: 3,
+      });
+
+      // Sync all checkpoints
+      fake.setL1BlockNumber(100n);
+      await archiver.syncImmediate();
+
+      // Mark checkpoint 1 as proven and advance L1 so proven is registered
+      fake.markCheckpointAsProven(CheckpointNumber(1));
+      fake.setL1BlockNumber(101n);
+      await archiver.syncImmediate();
+      expect(await archiver.getProvenCheckpointNumber()).toEqual(CheckpointNumber(1));
+
+      // Finalized L1 block is at or past where checkpoint 1 was published (70)
+      fake.setFinalizedL1BlockNumber(70n);
+      fake.setL1BlockNumber(102n);
+      await archiver.syncImmediate();
+
+      const tips = await archiver.getL2Tips();
+      const lastBlockInCp1 = cp1.blocks.at(-1)!.number;
+      expect(tips.finalized.checkpoint.number).toEqual(CheckpointNumber(1));
+      expect(tips.finalized.block.number).toEqual(lastBlockInCp1);
+    });
+
+    it('does not advance finalized checkpoint when finalized L1 block is before the proven checkpoint', async () => {
+      await fake.addCheckpoint(CheckpointNumber(1), {
+        l1BlockNumber: 70n,
+        messagesL1BlockNumber: 50n,
+        numL1ToL2Messages: 3,
+      });
+
+      fake.setL1BlockNumber(100n);
+      await archiver.syncImmediate();
+
+      fake.markCheckpointAsProven(CheckpointNumber(1));
+      fake.setL1BlockNumber(101n);
+      await archiver.syncImmediate();
+      expect(await archiver.getProvenCheckpointNumber()).toEqual(CheckpointNumber(1));
+
+      // Finalized L1 block is before where checkpoint 1 was published (70)
+      fake.setFinalizedL1BlockNumber(50n);
+      fake.setL1BlockNumber(102n);
+      await archiver.syncImmediate();
+
+      const tips = await archiver.getL2Tips();
+      expect(tips.finalized.checkpoint.number).toEqual(CheckpointNumber(0));
+      expect(tips.finalized.block.number).toEqual(BlockNumber(0));
+    });
+  });
+
   describe('checkpointing local proposed blocks', () => {
     let pruneSpy: jest.Mock;
 

yarn-project/archiver/src/archiver.ts

@@ -492,11 +492,10 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       this.log.info(`Rolling back proven L2 checkpoint to ${targetCheckpointNumber}`);
       await this.updater.setProvenCheckpointNumber(targetCheckpointNumber);
     }
-    // TODO(palla/reorg): Set the finalized block when we add support for it.
-    // const currentFinalizedBlock = currentBlocks.finalized.block.number;
-    // if (targetL2BlockNumber < currentFinalizedBlock) {
-    //   this.log.info(`Rolling back finalized L2 checkpoint to ${targetCheckpointNumber}`);
-    //   await this.updater.setFinalizedCheckpointNumber(targetCheckpointNumber);
-    // }
+    const currentFinalizedBlock = currentBlocks.finalized.block.number;
+    if (targetL2BlockNumber < currentFinalizedBlock) {
+      this.log.info(`Rolling back finalized L2 checkpoint to ${targetCheckpointNumber}`);
+      await this.updater.setFinalizedCheckpointNumber(targetCheckpointNumber);
+    }
   }
 }

yarn-project/archiver/src/factory.ts

@@ -15,7 +15,6 @@ import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/prov
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter } from '@aztec/stdlib/block';
 import { type ContractClassPublicWithCommitment, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { EventEmitter } from 'events';
@@ -33,14 +32,13 @@ export const ARCHIVER_STORE_NAME = 'archiver';
 /** Creates an archiver store. */
 export async function createArchiverStore(
   userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
-  l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
 ) {
   const config = {
     ...userConfig,
     dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
   const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config);
-  return new KVArchiverDataStore(store, config.maxLogs, l1Constants);
+  return new KVArchiverDataStore(store, config.maxLogs);
 }
 
 /**
@@ -55,7 +53,7 @@ export async function createArchiver(
   deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
 ): Promise<Archiver> {
-  const archiverStore = await createArchiverStore(config, { epochDuration: config.aztecEpochDuration });
+  const archiverStore = await createArchiverStore(config);
   await registerProtocolContracts(archiverStore);
 
   // Create Ethereum clients

yarn-project/archiver/src/modules/data_store_updater.test.ts

@@ -42,7 +42,7 @@ describe('ArchiverDataStoreUpdater', () => {
   let instanceAddress: AztecAddress;
 
   beforeEach(async () => {
-    store = new KVArchiverDataStore(await openTmpStore('data_store_updater_test'), 1000, { epochDuration: 32 });
+    store = new KVArchiverDataStore(await openTmpStore('data_store_updater_test'), 1000);
     updater = new ArchiverDataStoreUpdater(store);
 
     // Create contract class log from sample fixture data