@aztec/ethereum 0.87.2 → 0.87.3-nightly.20250528

package/dest/utils.js

@@ -109,25 +109,6 @@ function getNestedErrorData(error) {
         // Create a clone to avoid modifying the original
         const errorClone = structuredClone(error);
         // Helper function to recursively remove ABI properties
-        const stripAbis = (obj)=>{
-            if (!obj || typeof obj !== 'object') {
-                return;
-            }
-            // Delete ABI property at current level
-            if ('abi' in obj) {
-                delete obj.abi;
-            }
-            // Process cause property
-            if (obj.cause) {
-                stripAbis(obj.cause);
-            }
-            // Process arrays and objects
-            Object.values(obj).forEach((value)=>{
-                if (value && typeof value === 'object') {
-                    stripAbis(value);
-                }
-            });
-        };
         // Strip ABIs from the clone
         stripAbis(errorClone);
         // Use the cleaned clone for further processing
@@ -137,139 +118,6 @@ function getNestedErrorData(error) {
     if (error instanceof Error) {
         return new FormattedViemError(error.message, error?.metaMessages);
     }
-    const truncateHex = (hex, length = 100)=>{
-        if (!hex || typeof hex !== 'string') {
-            return hex;
-        }
-        if (!hex.startsWith('0x')) {
-            return hex;
-        }
-        if (hex.length <= length * 2) {
-            return hex;
-        }
-        // For extremely large hex strings, use more aggressive truncation
-        if (hex.length > 10000) {
-            return `${hex.slice(0, length)}...<${hex.length - length * 2} chars omitted>...${hex.slice(-length)}`;
-        }
-        return `${hex.slice(0, length)}...${hex.slice(-length)}`;
-    };
-    const replaceHexStrings = (text, options = {})=>{
-        const { minLength = 10, maxLength = Infinity, truncateLength = 100, pattern, transform = (hex)=>truncateHex(hex, truncateLength) } = options;
-        const hexRegex = pattern ?? new RegExp(`(0x[a-fA-F0-9]{${minLength},${maxLength}})`, 'g');
-        return text.replace(hexRegex, (match)=>transform(match));
-    };
-    const formatRequestBody = (body)=>{
-        try {
-            // Special handling for eth_sendRawTransaction
-            if (body.includes('"method":"eth_sendRawTransaction"')) {
-                try {
-                    const parsed = JSON.parse(body);
-                    if (parsed.params && Array.isArray(parsed.params) && parsed.params.length > 0) {
-                        // These are likely large transaction hex strings
-                        parsed.params = parsed.params.map((param)=>{
-                            if (typeof param === 'string' && param.startsWith('0x') && param.length > 1000) {
-                                return truncateHex(param, 200);
-                            }
-                            return param;
-                        });
-                    }
-                    return JSON.stringify(parsed, null, 2);
-                } catch  {
-                    // If specific parsing fails, fall back to regex-based truncation
-                    return replaceHexStrings(body, {
-                        pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-                        transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-                    });
-                }
-            }
-            // For extremely large request bodies, use simple truncation instead of parsing
-            if (body.length > 50000) {
-                const jsonStart = body.indexOf('{');
-                const jsonEnd = body.lastIndexOf('}');
-                if (jsonStart >= 0 && jsonEnd > jsonStart) {
-                    return replaceHexStrings(body, {
-                        minLength: 10000,
-                        truncateLength: 200
-                    });
-                }
-            }
-            const parsed = JSON.parse(body);
-            // Recursively process all parameters that might contain hex strings
-            const processParams = (obj)=>{
-                if (Array.isArray(obj)) {
-                    return obj.map((item)=>processParams(item));
-                }
-                if (typeof obj === 'object' && obj !== null) {
-                    const result = {};
-                    for (const [key, value] of Object.entries(obj)){
-                        result[key] = processParams(value);
-                    }
-                    return result;
-                }
-                if (typeof obj === 'string') {
-                    if (obj.startsWith('0x')) {
-                        return truncateHex(obj);
-                    }
-                }
-                return obj;
-            };
-            // Process the entire request body
-            const processed = processParams(parsed);
-            return JSON.stringify(processed, null, 2);
-        } catch  {
-            // If JSON parsing fails, do a simple truncation of any large hex strings
-            return replaceHexStrings(body, {
-                minLength: 1000,
-                truncateLength: 150
-            });
-        }
-    };
-    const extractAndFormatRequestBody = (message)=>{
-        // First check if message is extremely large and contains very large hex strings
-        if (message.length > 50000) {
-            message = replaceHexStrings(message, {
-                minLength: 10000,
-                truncateLength: 200
-            });
-        }
-        // Add a specific check for RPC calls with large params
-        if (message.includes('"method":"eth_sendRawTransaction"')) {
-            message = replaceHexStrings(message, {
-                pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-                transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
-            });
-        }
-        // First handle Request body JSON
-        const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
-        let result = message.replace(requestBodyRegex, (match, body)=>{
-            return `Request body: ${formatRequestBody(body)}\n`;
-        });
-        // Then handle Arguments section
-        const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
-        result = result.replace(argsRegex, (section)=>{
-            const lines = section.split('\n');
-            const processedLines = lines.map((line)=>{
-                // Check if line contains a colon followed by content
-                const colonIndex = line.indexOf(':');
-                if (colonIndex !== -1) {
-                    const [prefix, content] = [
-                        line.slice(0, colonIndex + 1),
-                        line.slice(colonIndex + 1).trim()
-                    ];
-                    // If content contains a hex string, truncate it
-                    if (content.includes('0x')) {
-                        const processedContent = replaceHexStrings(content);
-                        return `${prefix} ${processedContent}`;
-                    }
-                }
-                return line;
-            });
-            return processedLines.join('\n');
-        });
-        // Finally, catch any remaining hex strings in the message
-        result = replaceHexStrings(result);
-        return result;
-    };
     // Extract the actual error message and highlight it for clarity
     let formattedRes = extractAndFormatRequestBody(error?.message || String(error));
     let errorDetail = '';
@@ -299,6 +147,158 @@ function getNestedErrorData(error) {
     }
     return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
 }
+function stripAbis(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return;
+    }
+    // Delete ABI property at current level
+    if ('abi' in obj) {
+        delete obj.abi;
+    }
+    // Process cause property
+    if (obj.cause) {
+        stripAbis(obj.cause);
+    }
+    // Process arrays and objects
+    Object.values(obj).forEach((value)=>{
+        if (value && typeof value === 'object') {
+            stripAbis(value);
+        }
+    });
+}
+function extractAndFormatRequestBody(message) {
+    // First check if message is extremely large and contains very large hex strings
+    if (message.length > 50000) {
+        message = replaceHexStrings(message, {
+            minLength: 10000,
+            truncateLength: 200
+        });
+    }
+    // Add a specific check for RPC calls with large params
+    if (message.includes('"method":"eth_sendRawTransaction"')) {
+        message = replaceHexStrings(message, {
+            pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
+            transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
+        });
+    }
+    // First handle Request body JSON
+    const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
+    let result = message.replace(requestBodyRegex, (match, body)=>{
+        return `Request body: ${formatRequestBody(body)}\n`;
+    });
+    // Then handle Arguments section
+    const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
+    result = result.replace(argsRegex, (section)=>{
+        const lines = section.split('\n');
+        const processedLines = lines.map((line)=>{
+            // Check if line contains a colon followed by content
+            const colonIndex = line.indexOf(':');
+            if (colonIndex !== -1) {
+                const [prefix, content] = [
+                    line.slice(0, colonIndex + 1),
+                    line.slice(colonIndex + 1).trim()
+                ];
+                // If content contains a hex string, truncate it
+                if (content.includes('0x')) {
+                    const processedContent = replaceHexStrings(content);
+                    return `${prefix} ${processedContent}`;
+                }
+            }
+            return line;
+        });
+        return processedLines.join('\n');
+    });
+    // Finally, catch any remaining hex strings in the message
+    result = replaceHexStrings(result);
+    return result;
+}
+function truncateHex(hex, length = 100) {
+    if (!hex || typeof hex !== 'string') {
+        return hex;
+    }
+    if (!hex.startsWith('0x')) {
+        return hex;
+    }
+    if (hex.length <= length * 2) {
+        return hex;
+    }
+    // For extremely large hex strings, use more aggressive truncation
+    if (hex.length > 10000) {
+        return `${hex.slice(0, length)}...<${hex.length - length * 2} chars omitted>...${hex.slice(-length)}`;
+    }
+    return `${hex.slice(0, length)}...${hex.slice(-length)}`;
+}
+function replaceHexStrings(text, options = {}) {
+    const { minLength = 10, maxLength = Infinity, truncateLength = 100, pattern, transform = (hex)=>truncateHex(hex, truncateLength) } = options;
+    const hexRegex = pattern ?? new RegExp(`(0x[a-fA-F0-9]{${minLength},${maxLength}})`, 'g');
+    return text.replace(hexRegex, (match)=>transform(match));
+}
+function formatRequestBody(body) {
+    try {
+        // Special handling for eth_sendRawTransaction
+        if (body.includes('"method":"eth_sendRawTransaction"')) {
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed.params && Array.isArray(parsed.params) && parsed.params.length > 0) {
+                    // These are likely large transaction hex strings
+                    parsed.params = parsed.params.map((param)=>{
+                        if (typeof param === 'string' && param.startsWith('0x') && param.length > 1000) {
+                            return truncateHex(param, 200);
+                        }
+                        return param;
+                    });
+                }
+                return JSON.stringify(parsed, null, 2);
+            } catch  {
+                // If specific parsing fails, fall back to regex-based truncation
+                return replaceHexStrings(body, {
+                    pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
+                    transform: (hex)=>`"params":["${truncateHex(hex, 200)}"]`
+                });
+            }
+        }
+        // For extremely large request bodies, use simple truncation instead of parsing
+        if (body.length > 50000) {
+            const jsonStart = body.indexOf('{');
+            const jsonEnd = body.lastIndexOf('}');
+            if (jsonStart >= 0 && jsonEnd > jsonStart) {
+                return replaceHexStrings(body, {
+                    minLength: 10000,
+                    truncateLength: 200
+                });
+            }
+        }
+        const parsed = JSON.parse(body);
+        // Process the entire request body
+        const processed = processParams(parsed);
+        return JSON.stringify(processed, null, 2);
+    } catch  {
+        // If JSON parsing fails, do a simple truncation of any large hex strings
+        return replaceHexStrings(body, {
+            minLength: 1000,
+            truncateLength: 150
+        });
+    }
+}
+// Recursively process all parameters that might contain hex strings
+function processParams(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map((item)=>processParams(item));
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)){
+            result[key] = processParams(value);
+        }
+        return result;
+    }
+    if (typeof obj === 'string') {
+        if (obj.startsWith('0x')) {
+            return truncateHex(obj);
+        }
+    }
+    return obj;
+}
 export function tryGetCustomErrorName(err) {
     try {
         // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "0.87.2",
+  "version": "0.87.3-nightly.20250528",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -32,9 +32,9 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "0.87.2",
-    "@aztec/foundation": "0.87.2",
-    "@aztec/l1-artifacts": "0.87.2",
+    "@aztec/blob-lib": "0.87.3-nightly.20250528",
+    "@aztec/foundation": "0.87.3-nightly.20250528",
+    "@aztec/l1-artifacts": "0.87.3-nightly.20250528",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "tslib": "^2.4.0",

package/src/config.ts

@@ -44,10 +44,10 @@ export type L1ContractsConfig = {
 
 export const DefaultL1ContractsConfig = {
   ethereumSlotDuration: 12,
-  aztecSlotDuration: 24,
-  aztecEpochDuration: 16,
+  aztecSlotDuration: 36,
+  aztecEpochDuration: 32,
   aztecTargetCommitteeSize: 48,
-  aztecProofSubmissionWindow: 31, // you have a full epoch to submit a proof after the epoch to prove ends
+  aztecProofSubmissionWindow: 64, // you have a full epoch to submit a proof after the epoch to prove ends
   minimumStake: BigInt(100e18),
   slashingQuorum: 6,
   slashingRoundSize: 10,

package/src/contracts/rollup.ts

@@ -5,17 +5,23 @@ import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
 import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
 
-import { type Account, type GetContractReturnType, type Hex, getAddress, getContract } from 'viem';
+import { type Account, type GetContractReturnType, type Hex, encodeFunctionData, getAddress, getContract } from 'viem';
 
 import { getPublicClient } from '../client.js';
 import type { DeployL1ContractsReturnType } from '../deploy_l1_contracts.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import type { L1ReaderConfig } from '../l1_reader.js';
+import type { L1TxUtils } from '../l1_tx_utils.js';
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { SlashingProposerContract } from './slashing_proposer.js';
 import { checkBlockTag } from './utils.js';
 
+export type ViemCommitteeAttestation = {
+  addr: `0x${string}`;
+  signature: ViemSignature;
+};
+
 export type L1RollupContractAddresses = Pick<
   L1ContractAddresses,
   | 'rollupAddress'
@@ -26,13 +32,12 @@ export type L1RollupContractAddresses = Pick<
   | 'stakingAssetAddress'
   | 'rewardDistributorAddress'
   | 'slashFactoryAddress'
+  | 'gseAddress'
 >;
 
 export type EpochProofPublicInputArgs = {
   previousArchive: `0x${string}`;
   endArchive: `0x${string}`;
-  endTimestamp: bigint;
-  outHash: `0x${string}`;
   proverId: `0x${string}`;
 };
 
@@ -279,6 +284,7 @@ export class RollupContract {
       rewardDistributorAddress,
       feeJuiceAddress,
       stakingAssetAddress,
+      gseAddress,
     ] = (
       await Promise.all([
         this.rollup.read.getInbox(),
@@ -287,6 +293,7 @@ export class RollupContract {
         this.rollup.read.getRewardDistributor(),
         this.rollup.read.getFeeAsset(),
         this.rollup.read.getStakingAsset(),
+        this.rollup.read.getGSE(),
       ] as const)
     ).map(EthAddress.fromString);
 
@@ -298,6 +305,7 @@ export class RollupContract {
       feeJuiceAddress,
       stakingAssetAddress,
       rewardDistributorAddress,
+      gseAddress,
     };
   }
 
@@ -318,7 +326,7 @@ export class RollupContract {
   public async validateHeader(
     args: readonly [
       `0x${string}`,
-      ViemSignature[],
+      ViemCommitteeAttestation[],
       `0x${string}`,
       bigint,
       `0x${string}`,
@@ -360,6 +368,7 @@ export class RollupContract {
       slotDuration = BigInt(slotDuration);
     }
     const timeOfNextL1Slot = (await this.client.getBlock()).timestamp + slotDuration;
+
     try {
       const {
         result: [slot, blockNumber],
@@ -429,11 +438,18 @@ export class RollupContract {
     return this.rollup.read.getAttesters();
   }
 
-  getInfo(address: Hex | EthAddress) {
+  getAttesterView(address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    return this.rollup.read.getAttesterView([address]);
+  }
+
+  getStatus(address: Hex | EthAddress) {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
-    return this.rollup.read.getInfo([address]);
+    return this.rollup.read.getStatus([address]);
   }
 
   getBlobPublicInputsHash(blockNumber: bigint) {
@@ -450,4 +466,15 @@ export class RollupContract {
     }
     return this.rollup.read.getProposerForAttester([attester]);
   }
+
+  setupEpoch(l1TxUtils: L1TxUtils) {
+    return l1TxUtils.sendAndMonitorTransaction({
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'setupEpoch',
+        args: [],
+      }),
+    });
+  }
 }

package/src/contracts/slashing_proposer.ts

@@ -1,19 +1,35 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { retryUntil } from '@aztec/foundation/retry';
 import { SlashingProposerAbi } from '@aztec/l1-artifacts/SlashingProposerAbi';
 
-import { type GetContractReturnType, type Hex, getContract } from 'viem';
+import EventEmitter from 'events';
+import {
+  type EncodeFunctionDataParameters,
+  type GetContractReturnType,
+  type Hex,
+  encodeFunctionData,
+  getContract,
+} from 'viem';
 
-import type { L1TxRequest } from '../l1_tx_utils.js';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
 import type { ViemClient } from '../types.js';
+import { FormattedViemError } from '../utils.js';
 import { type IEmpireBase, encodeVote } from './empire_base.js';
 
-export class SlashingProposerContract implements IEmpireBase {
+export class ProposalAlreadyExecutedError extends Error {
+  constructor(round: bigint) {
+    super(`Proposal already executed: ${round}`);
+  }
+}
+
+export class SlashingProposerContract extends EventEmitter implements IEmpireBase {
   private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, ViemClient>;
 
   constructor(
     public readonly client: ViemClient,
     address: Hex,
   ) {
+    super();
     this.proposer = getContract({ address, abi: SlashingProposerAbi, client });
   }
 
@@ -45,10 +61,104 @@ export class SlashingProposerContract implements IEmpireBase {
     };
   }
 
+  public getProposalVotes(rollupAddress: Hex, round: bigint, proposal: Hex): Promise<bigint> {
+    return this.proposer.read.yeaCount([rollupAddress, round, proposal]);
+  }
+
   public createVoteRequest(payload: Hex): L1TxRequest {
     return {
       to: this.address.toString(),
       data: encodeVote(payload),
     };
   }
+
+  public listenToExecutableProposals(callback: (args: { proposal: `0x${string}`; round: bigint }) => unknown) {
+    return this.proposer.watchEvent.ProposalExecutable(
+      {},
+      {
+        onLogs: logs => {
+          for (const payload of logs) {
+            const args = payload.args;
+            if (args.proposal && args.round) {
+              // why compiler can't figure it out? no one knows
+              callback(args as { proposal: `0x${string}`; round: bigint });
+            }
+          }
+        },
+      },
+    );
+  }
+
+  public listenToProposalExecuted(callback: (args: { round: bigint; proposal: `0x${string}` }) => unknown) {
+    return this.proposer.watchEvent.ProposalExecuted(
+      {},
+      {
+        onLogs: logs => {
+          for (const payload of logs) {
+            const args = payload.args;
+            if (args.round && args.proposal) {
+              callback(args as { round: bigint; proposal: `0x${string}` });
+            }
+          }
+        },
+      },
+    );
+  }
+
+  public waitForRound(round: bigint, pollingIntervalSeconds: number = 1) {
+    return retryUntil(
+      async () => {
+        const currentRound = await this.proposer.read.getCurrentRound();
+        return currentRound >= round;
+      },
+      `Waiting for round ${round} to be reached`,
+      0, // no timeout
+      pollingIntervalSeconds,
+    );
+  }
+
+  public async executeRound(txUtils: L1TxUtils, round: bigint | number): Promise<void> {
+    if (typeof round === 'number') {
+      round = BigInt(round);
+    }
+    const args: EncodeFunctionDataParameters<typeof SlashingProposerAbi, 'executeProposal'> = {
+      abi: SlashingProposerAbi,
+      functionName: 'executeProposal',
+      args: [round],
+    };
+    const data = encodeFunctionData(args);
+    const response = await txUtils
+      .sendAndMonitorTransaction(
+        {
+          to: this.address.toString(),
+          data,
+        },
+        {
+          // Gas estimation is more than 20% off for this tx.
+          gasLimitBufferPercentage: 100,
+        },
+      )
+      .catch(err => {
+        if (err instanceof FormattedViemError && err.message.includes('ProposalAlreadyExecuted')) {
+          throw new ProposalAlreadyExecutedError(round);
+        }
+        throw err;
+      });
+
+    if (response.receipt.status === 'reverted') {
+      const error = await txUtils.tryGetErrorFromRevertedTx(
+        data,
+        {
+          ...args,
+          address: this.address.toString(),
+        },
+        undefined,
+        [],
+      );
+      if (error?.includes('ProposalAlreadyExecuted')) {
+        throw new ProposalAlreadyExecutedError(round);
+      }
+      throw new Error(error ?? 'Unknown error');
+    }
+  }
 }