@aztec/cli 0.0.1-commit.b33fc05d0 → 0.0.1-commit.b3d3157a

package/src/cmds/aztec_node/get_logs.ts

@@ -1,22 +1,47 @@
 import type { AztecAddress } from '@aztec/aztec.js/addresses';
-import type { LogFilter, LogId } from '@aztec/aztec.js/log';
 import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import type { TxHash } from '@aztec/aztec.js/tx';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { LogFn } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
+import {
+  LogCursor,
+  type PublicLogsQuery,
+  type Tag,
+  logResultToHumanReadable,
+  queryAllPublicLogsByTags,
+} from '@aztec/stdlib/logs';
 
-export async function getLogs(
-  txHash: TxHash,
-  fromBlock: BlockNumber,
-  toBlock: BlockNumber,
-  afterLog: LogId,
-  contractAddress: AztecAddress,
-  nodeUrl: string,
-  follow: boolean,
-  log: LogFn,
-) {
-  const node = createAztecNodeClient(nodeUrl);
+/** Options for the `get-logs` CLI command. */
+export type GetLogsOptions = {
+  /** Contract address that emitted the logs (required). */
+  contractAddress: AztecAddress;
+  /** Tag to filter logs by (required). */
+  tag: Tag;
+  /** Restrict the search to this tx hash. Mutually exclusive with `fromBlock`/`toBlock`. */
+  txHash?: TxHash;
+  /** Lower block bound, inclusive. */
+  fromBlock?: BlockNumber;
+  /** Upper block bound, exclusive. */
+  toBlock?: BlockNumber;
+  /** Log cursor to resume pagination strictly after a previously-seen log. */
+  afterLog?: LogCursor;
+  /** Node RPC URL. */
+  nodeUrl: string;
+  /** When set, polls indefinitely for new logs. Incompatible with `txHash` and `toBlock`. */
+  follow: boolean;
+  /** Log function. */
+  log: LogFn;
+};
+
+/**
+ * Fetches public logs for a (contract, tag) pair, draining all pages via the stdlib pagination helper.
+ * In `--follow` mode, polls indefinitely: each round drains all currently-available logs, then sleeps
+ * until the next poll if nothing new was found.
+ */
+export async function getLogs(options: GetLogsOptions): Promise<void> {
+  const { txHash, fromBlock, toBlock, contractAddress, tag, nodeUrl, follow, log } = options;
+  let afterLog = options.afterLog;
 
   if (follow) {
     if (txHash) {
@@ -26,43 +51,50 @@ export async function getLogs(
       throw Error('Cannot use --follow with --to-block');
     }
   }
+  if (txHash !== undefined && (fromBlock !== undefined || toBlock !== undefined)) {
+    throw Error('Cannot combine --tx-hash with --from-block / --to-block');
+  }
 
-  const filter: LogFilter = { txHash, fromBlock, toBlock, afterLog, contractAddress };
-
-  const fetchLogs = async () => {
-    const response = await node.getPublicLogs(filter);
-    const logs = response.logs;
+  const node = createAztecNodeClient(nodeUrl);
 
-    if (!logs.length) {
-      const filterOptions = Object.entries(filter)
-        .filter(([, value]) => value !== undefined)
-        .map(([key, value]) => `${key}: ${value}`)
-        .join(', ');
-      if (!follow) {
-        log(`No logs found for filter: {${filterOptions}}`);
-      }
-    } else {
-      if (!follow && !filter.afterLog) {
-        log('Logs found: \n');
-      }
-      logs.forEach(publicLog => log(publicLog.toHumanReadable()));
-      // Set the continuation parameter for the following requests
-      filter.afterLog = logs[logs.length - 1].id;
+  const drainLogs = async () => {
+    const query: PublicLogsQuery = {
+      contractAddress,
+      tags: [afterLog !== undefined ? { tag, afterLog } : tag],
+      fromBlock,
+      toBlock,
+      txHash,
+    };
+    const [logsForTag] = await queryAllPublicLogsByTags(node, query);
+    if (logsForTag.length > 0) {
+      afterLog = LogCursor.fromLog(logsForTag[logsForTag.length - 1]);
     }
-    return response.maxLogsHit;
+    return logsForTag;
   };
 
   if (follow) {
     log('Fetching logs...');
     while (true) {
-      const maxLogsHit = await fetchLogs();
-      if (!maxLogsHit) {
+      const results = await drainLogs();
+      if (results.length === 0) {
         await sleep(1000);
+      } else {
+        results.forEach(r => log(logResultToHumanReadable(r)));
       }
     }
   } else {
-    while (await fetchLogs()) {
-      // Keep fetching logs until we reach the end.
+    const results = await drainLogs();
+    if (results.length === 0) {
+      log(
+        `No logs found for {contractAddress: ${contractAddress.toString()}, tag: ${tag.toString()}` +
+          `${txHash ? `, txHash: ${txHash.toString()}` : ''}` +
+          `${fromBlock !== undefined ? `, fromBlock: ${fromBlock}` : ''}` +
+          `${toBlock !== undefined ? `, toBlock: ${toBlock}` : ''}` +
+          `${afterLog ? `, afterLog: ${afterLog.toString()}` : ''}}`,
+      );
+    } else {
+      log('Logs found: \n');
+      results.forEach(r => log(logResultToHumanReadable(r)));
     }
   }
 }

package/src/cmds/aztec_node/get_node_info.ts

@@ -23,7 +23,6 @@ export async function getNodeInfo(nodeUrl: string, json: boolean, log: LogFn, lo
         rewardDistributor: info.l1ContractAddresses.rewardDistributorAddress.toString(),
         governanceProposer: info.l1ContractAddresses.governanceProposerAddress.toString(),
         governance: info.l1ContractAddresses.governanceAddress.toString(),
-        slashFactory: info.l1ContractAddresses.slashFactoryAddress?.toString(),
         feeAssetHandler: info.l1ContractAddresses.feeAssetHandlerAddress?.toString(),
         stakingAssetHandler: info.l1ContractAddresses.stakingAssetHandlerAddress?.toString(),
       },
@@ -51,7 +50,6 @@ export async function getNodeInfo(nodeUrl: string, json: boolean, log: LogFn, lo
     log(` RewardDistributor Address: ${info.l1ContractAddresses.rewardDistributorAddress.toString()}`);
     log(` GovernanceProposer Address: ${info.l1ContractAddresses.governanceProposerAddress.toString()}`);
     log(` Governance Address: ${info.l1ContractAddresses.governanceAddress.toString()}`);
-    log(` SlashFactory Address: ${info.l1ContractAddresses.slashFactoryAddress?.toString()}`);
     log(` FeeAssetHandler Address: ${info.l1ContractAddresses.feeAssetHandlerAddress?.toString()}`);
     log(` StakingAssetHandler Address: ${info.l1ContractAddresses.stakingAssetHandlerAddress?.toString()}`);
     log(`L2 Contract Addresses:`);

package/src/cmds/aztec_node/index.ts

@@ -7,10 +7,10 @@ import {
   nodeOption,
   parseAztecAddress,
   parseField,
-  parseOptionalAztecAddress,
   parseOptionalInteger,
-  parseOptionalLogId,
+  parseOptionalLogCursor,
   parseOptionalTxHash,
+  parseTag,
 } from '../../utils/commands.js';
 
 export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
@@ -47,21 +47,26 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
 
   program
     .command('get-logs')
-    .description('Gets all the public logs from an intersection of all the filter params.')
-    .option('-tx, --tx-hash <txHash>', 'A transaction hash to get the receipt for.', parseOptionalTxHash)
+    .description('Gets public logs for a contract and tag, optionally restricted by block range or tx hash.')
+    .requiredOption('-ca, --contract-address <address>', 'Contract address that emitted the logs.', parseAztecAddress)
+    .requiredOption('--tag <tag>', 'Tag (Fr value) to filter logs by.', parseTag)
+    .option('-tx, --tx-hash <txHash>', 'A transaction hash to restrict the search to.', parseOptionalTxHash)
     .option(
       '-fb, --from-block <blockNum>',
       'Initial block number for getting logs (defaults to 1).',
       parseOptionalInteger,
     )
     .option('-tb, --to-block <blockNum>', 'Up to which block to fetch logs (defaults to latest).', parseOptionalInteger)
-    .option('-al --after-log <logId>', 'ID of a log after which to fetch the logs.', parseOptionalLogId)
-    .option('-ca, --contract-address <address>', 'Contract address to filter logs by.', parseOptionalAztecAddress)
+    .option(
+      '-al --after-log <cursor>',
+      'Log cursor of the form <blockNumber>-<txIndexWithinBlock>-<logIndexWithinTx> to resume pagination after.',
+      parseOptionalLogCursor,
+    )
     .addOption(nodeOption)
     .option('--follow', 'If set, will keep polling for new logs until interrupted.')
-    .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, aztecNodeRpcUrl: nodeUrl, follow }) => {
+    .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, tag, nodeUrl, follow }) => {
       const { getLogs } = await import('./get_logs.js');
-      await getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, nodeUrl, follow, log);
+      await getLogs({ txHash, fromBlock, toBlock, afterLog, contractAddress, tag, nodeUrl, follow, log });
     });
 
   program

package/src/cmds/infrastructure/setup_l2_contract.ts

@@ -2,6 +2,7 @@ import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { WaitOpts } from '@aztec/aztec.js/contracts';
 import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { TxStatus } from '@aztec/aztec.js/tx';
 import { AccountManager } from '@aztec/aztec.js/wallet';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { LogFn } from '@aztec/foundation/log';
@@ -13,6 +14,9 @@ export async function setupL2Contracts(nodeUrl: string, testAccounts: boolean, j
   const waitOpts: WaitOpts = {
     timeout: 180,
     interval: 1,
+    // The embedded wallet defaults to PROPOSED, which can be dropped if its proposed block is pruned
+    // before the checkpoint lands. Wait for the checkpoint so serial setup is reliable.
+    waitForStatus: TxStatus.CHECKPOINTED,
   };
   log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
   log('setupL2Contracts: Creating PXE client...');

package/src/cmds/l1/deploy_l1_contracts_cmd.ts

@@ -96,7 +96,6 @@ export async function deployL1ContractsCmd(
     log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
     log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
     log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
-    log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress?.toString()}`);
     log(`FeeAssetHandler Address: ${l1ContractAddresses.feeAssetHandlerAddress?.toString()}`);
     log(`StakingAssetHandler Address: ${l1ContractAddresses.stakingAssetHandlerAddress?.toString()}`);
     log(`ZK Passport Verifier Address: ${l1ContractAddresses.zkPassportVerifierAddress?.toString()}`);

package/src/cmds/l1/deploy_new_rollup.ts

@@ -29,7 +29,7 @@ export async function deployNewRollup(
   const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
   const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
 
-  const { rollup, slashFactoryAddress } = await deployNewRollupContracts(
+  const { rollup } = await deployNewRollupContracts(
     registryAddress,
     rpcUrls,
     privateKey,
@@ -51,7 +51,6 @@ export async function deployNewRollup(
           initialFundedAccounts: initialFundedAccounts.map(a => a.toString()),
           initialValidators: initialValidators.map(a => a.attester.toString()),
           genesisArchiveRoot: genesisArchiveRoot.toString(),
-          slashFactoryAddress: slashFactoryAddress.toString(),
         },
         null,
         2,
@@ -62,6 +61,5 @@ export async function deployNewRollup(
     log(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
     log(`Initial validators: ${initialValidators.map(a => a.attester.toString()).join(', ')}`);
     log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
-    log(`Slash Factory Address: ${slashFactoryAddress.toString()}`);
   }
 }

package/src/cmds/l1/update_l1_validators.ts

@@ -38,7 +38,6 @@ export interface LoggerArgs {
 export function generateL1Account() {
   const privateKey = generatePrivateKey();
   const account = privateKeyToAccount(privateKey);
-  account.address;
   return {
     privateKey,
     address: account.address,

package/src/config/generated/networks.ts

@@ -14,7 +14,7 @@ export const devnetConfig = {
   AZTEC_MANA_TARGET: 100000000,
   AZTEC_PROVING_COST_PER_MANA: 100,
   AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHER_ENABLED: true,
   AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
   AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
   AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
@@ -24,11 +24,10 @@ export const devnetConfig = {
   AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
   AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
-  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
-  SLASH_MAX_PENALTY_PERCENTAGE: 2,
   SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
   SLASH_MAX_PAYLOAD_SIZE: 80,
   SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
   P2P_ENABLED: true,
   BOOTSTRAP_NODES: '',
   SEQ_MIN_TX_PER_BLOCK: 1,
@@ -61,7 +60,6 @@ export const devnetConfig = {
   PUBLIC_OTEL_OPT_OUT: true,
   PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
   PUBLIC_OTEL_COLLECT_FROM: '',
-  SLASH_PRUNE_PENALTY: 10000000000000000000,
   SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
   SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
   SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
@@ -69,9 +67,11 @@ export const devnetConfig = {
   SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
   SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
   SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
-  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000,
   SLASH_UNKNOWN_PENALTY: 10000000000000000000,
   SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
   SLASH_GRACE_PERIOD_L2_SLOTS: 0,
   ENABLE_VERSION_CHECK: true,
 } as const;
@@ -86,16 +86,15 @@ export const testnetConfig = {
   AZTEC_INBOX_LAG: 1,
   AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
   AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHER_ENABLED: true,
   AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
   AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
   AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
   AZTEC_SLASHING_DISABLE_DURATION: 432000,
-  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
-  SLASH_MAX_PENALTY_PERCENTAGE: 2,
   SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
   SLASH_MAX_PAYLOAD_SIZE: 80,
   SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
   P2P_ENABLED: true,
   BOOTSTRAP_NODES: '',
   SEQ_MIN_TX_PER_BLOCK: 1,
@@ -119,10 +118,10 @@ export const testnetConfig = {
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100,
   AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60,
   AZTEC_MANA_TARGET: 75000000,
-  AZTEC_PROVING_COST_PER_MANA: 25000000,
+  AZTEC_PROVING_COST_PER_MANA: 12500000,
   AZTEC_SLASH_AMOUNT_SMALL: 1E+23,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 1E+23,
-  AZTEC_SLASH_AMOUNT_LARGE: 1E+23,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 2.5E+23,
+  AZTEC_SLASH_AMOUNT_LARGE: 2.5E+23,
   L1_CHAIN_ID: 11155111,
   TEST_ACCOUNTS: false,
   SPONSORED_FPC: false,
@@ -131,17 +130,18 @@ export const testnetConfig = {
   PROVER_REAL_PROOFS: true,
   P2P_MAX_PENDING_TX_COUNT: 1000,
   P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
-  SLASH_PRUNE_PENALTY: 10000000000000000000,
-  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_PENALTY: 0,
   SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
   SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
-  SLASH_INACTIVITY_PENALTY: 10000000000000000000,
-  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
-  SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
-  SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
-  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
-  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
-  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_INACTIVITY_PENALTY: 1E+23,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 1E+23,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 2.5E+23,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 2.5E+23,
+  SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 0,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
+  SLASH_UNKNOWN_PENALTY: 1E+23,
+  SLASH_INVALID_BLOCK_PENALTY: 1E+23,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 1E+23,
   SLASH_GRACE_PERIOD_L2_SLOTS: 64,
   ENABLE_VERSION_CHECK: true,
 } as const;
@@ -155,14 +155,13 @@ export const mainnetConfig = {
   AZTEC_INBOX_LAG: 1,
   AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
   AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHER_ENABLED: true,
   AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
   AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
-  SLASH_MAX_PENALTY_PERCENTAGE: 2,
   SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
   SLASH_MAX_PAYLOAD_SIZE: 80,
   SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
   P2P_ENABLED: true,
   BOOTSTRAP_NODES: '',
   SEQ_MIN_TX_PER_BLOCK: 1,
@@ -181,8 +180,8 @@ export const mainnetConfig = {
   AZTEC_EJECTION_THRESHOLD: 1E+23,
   AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9E+23,
   AZTEC_SLASH_AMOUNT_SMALL: 2E+21,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 2E+21,
-  AZTEC_SLASH_AMOUNT_LARGE: 2E+21,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 5E+21,
+  AZTEC_SLASH_AMOUNT_LARGE: 5E+21,
   AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 34,
   AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 28,
   AZTEC_SLASHING_VETOER: '0xBbB4aF368d02827945748b28CD4b2D42e4A37480',
@@ -190,7 +189,7 @@ export const mainnetConfig = {
   AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600,
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000,
   AZTEC_MANA_TARGET: 75000000,
-  AZTEC_PROVING_COST_PER_MANA: 25000000,
+  AZTEC_PROVING_COST_PER_MANA: 12500000,
   AZTEC_EXIT_DELAY_SECONDS: 345600,
   AZTEC_SLASHING_DISABLE_DURATION: 259200,
   AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500,
@@ -204,24 +203,24 @@ export const mainnetConfig = {
   TRANSACTIONS_DISABLED: false,
   SEQ_MAX_TX_PER_CHECKPOINT: 72,
   PROVER_REAL_PROOFS: true,
-  SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
   BLOB_ALLOW_EMPTY_SOURCES: true,
   P2P_MAX_PENDING_TX_COUNT: 1000,
   P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
   PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
   PUBLIC_OTEL_COLLECT_FROM: '',
   ENABLE_VERSION_CHECK: false,
-  SLASH_PRUNE_PENALTY: 0,
   SLASH_DATA_WITHHOLDING_PENALTY: 0,
   SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
   SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
   SLASH_INACTIVITY_PENALTY: 2E+21,
   SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2E+21,
-  SLASH_DUPLICATE_PROPOSAL_PENALTY: 2E+21,
-  SLASH_DUPLICATE_ATTESTATION_PENALTY: 2E+21,
-  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2E+21,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 5E+21,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 5E+21,
+  SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 0,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
   SLASH_UNKNOWN_PENALTY: 2E+21,
   SLASH_INVALID_BLOCK_PENALTY: 2E+21,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 2E+21,
   SLASH_GRACE_PERIOD_L2_SLOTS: 1200,
 } as const;
 

package/src/config/network_config.ts

@@ -139,6 +139,9 @@ export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNam
   if (networkConfig.blobFileStoreUrls?.length) {
     enrichVar('BLOB_FILE_STORE_URLS', networkConfig.blobFileStoreUrls.join(','));
   }
+  if (networkConfig.txCollectionFileStoreUrls?.length) {
+    enrichVar('TX_COLLECTION_FILE_STORE_URLS', networkConfig.txCollectionFileStoreUrls.join(','));
+  }
   if (networkConfig.blockDurationMs !== undefined) {
     enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
   }

package/src/utils/aztec.ts

@@ -49,7 +49,7 @@ export async function deployNewRollupContracts(
   feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
   realVerifier: boolean,
-): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
+): Promise<{ rollup: RollupContract }> {
   const { deployRollupForUpgrade } = await import('@aztec/ethereum/deploy-aztec-l1-contracts');
   const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
   const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
@@ -80,23 +80,17 @@ export async function deployNewRollupContracts(
     logger.info('Initializing new rollup with old attesters', { initialValidators });
   }
 
-  const { rollup, slashFactoryAddress } = await deployRollupForUpgrade(
-    privateKey as Hex,
-    rpcUrls[0],
-    chainId,
-    registryAddress,
-    {
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractsHash,
-      genesisArchiveRoot,
-      initialValidators,
-      feeJuicePortalInitialBalance,
-      realVerifier,
-      ...config,
-    },
-  );
-
-  return { rollup, slashFactoryAddress: EthAddress.fromString(slashFactoryAddress!) };
+  const { rollup } = await deployRollupForUpgrade(privateKey as Hex, rpcUrls[0], chainId, registryAddress, {
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot,
+    initialValidators,
+    feeJuicePortalInitialBalance,
+    realVerifier,
+    ...config,
+  });
+
+  return { rollup };
 }
 
 /**

package/src/utils/commands.ts

@@ -5,13 +5,15 @@ import type { PXE } from '@aztec/pxe/server';
 import { FunctionSelector } from '@aztec/stdlib/abi/function-selector';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
-import { LogId } from '@aztec/stdlib/logs/log-id';
+import { LogCursor, Tag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx/tx-hash';
 
 import { type Command, CommanderError, InvalidArgumentError, Option } from 'commander';
 import { lookup } from 'dns/promises';
 import { rename, writeFile } from 'fs/promises';
 
+export { LogCursor };
+
 /**
  * If we can successfully resolve 'host.docker.internal', then we are running in a container, and we should treat
  * localhost as being host.docker.internal.
@@ -227,16 +229,27 @@ export function parseOptionalAztecAddress(address: string): AztecAddress | undef
 }
 
 /**
- * Parses an optional log ID string into a LogId object.
- *
- * @param logId - The log ID string to parse.
- * @returns The parsed LogId object, or undefined if the log ID is missing or empty.
+ * Parses an optional `<blockNumber>-<txIndexWithinBlock>-<logIndexWithinTx>` triple into a {@link LogCursor},
+ * used as the `--after-log` argument of `get-logs` to resume pagination strictly after a previously-seen log.
+ * Thin wrapper over {@link LogCursor.parseOptional} that surfaces parse errors as commander's
+ * {@link InvalidArgumentError}.
  */
-export function parseOptionalLogId(logId: string): LogId | undefined {
-  if (!logId) {
-    return undefined;
+export function parseOptionalLogCursor(value: string): LogCursor | undefined {
+  try {
+    return LogCursor.parseOptional(value);
+  } catch (err) {
+    throw new InvalidArgumentError(err instanceof Error ? err.message : String(err));
   }
-  return LogId.fromString(logId);
+}
+
+/**
+ * Parses a log tag from a string. Tags are field-element values; we delegate to the {@link parseField} parser.
+ *
+ * @param tag - A hex string, integer, or boolean string representing the tag.
+ * @returns A {@link Tag} wrapping the parsed field.
+ */
+export function parseTag(tag: string): Tag {
+  return new Tag(parseField(tag));
 }
 
 /**

package/src/utils/inspect.ts

@@ -9,14 +9,13 @@ export async function inspectBlock(
   log: LogFn,
   opts: { showTxs?: boolean } = {},
 ) {
-  const block = await aztecNode.getBlock(blockNumber);
+  const block = await aztecNode.getBlock(blockNumber, { includeTransactions: opts.showTxs });
   if (!block) {
     log(`No block found for block number ${blockNumber}`);
     return;
   }
 
-  const blockHash = await block.hash();
-  log(`Block ${blockNumber} (${blockHash.toString()})`);
+  log(`Block ${blockNumber} (${block.hash.toString()})`);
   log(` Total fees: ${block.header.totalFees.toBigInt()}`);
   log(` Total mana used: ${block.header.totalManaUsed.toBigInt()}`);
   log(
@@ -25,12 +24,12 @@ export async function inspectBlock(
   log(` Coinbase: ${block.header.globalVariables.coinbase}`);
   log(` Fee recipient: ${block.header.globalVariables.feeRecipient}`);
   log(` Timestamp: ${new Date(Number(block.header.globalVariables.timestamp) * 500)}`);
-  if (opts.showTxs) {
+  if (opts.showTxs && block.body) {
     log(``);
     for (const txHash of block.body.txEffects.map(tx => tx.txHash)) {
       await inspectTx(aztecNode, txHash, log, { includeBlockInfo: false });
     }
-  } else {
+  } else if (block.body) {
     log(` Transactions: ${block.body.txEffects.length}`);
   }
 }
@@ -41,7 +40,7 @@ export async function inspectTx(
   log: LogFn,
   opts: { includeBlockInfo?: boolean } = {},
 ) {
-  const [receipt, effectsInBlock] = await Promise.all([aztecNode.getTxReceipt(txHash), aztecNode.getTxEffect(txHash)]);
+  const receipt = await aztecNode.getTxReceipt(txHash, { includeTxEffect: true });
   // Base tx data
   log(`Tx ${txHash.toString()}`);
   log(` Status: ${receipt.status}`);
@@ -52,11 +51,11 @@ export async function inspectTx(
     log(` Error: ${receipt.error}`);
   }
 
-  if (!effectsInBlock) {
+  if (!receipt.isMined() || !receipt.txEffect) {
     return;
   }
 
-  const effects = effectsInBlock.data;
+  const effects = receipt.txEffect;
 
   if (opts.includeBlockInfo) {
     log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);