@aztec/ethereum 2.0.0-nightly.20250902 → 3.0.0-canary.a9708bd

package/src/config.ts

@@ -423,78 +423,7 @@ export function validateConfig(config: Omit<L1ContractsConfig, keyof L1TxUtilsCo
 
   // TallySlashingProposer constructor validations
   if (config.slasherFlavor === 'tally') {
-    // From: require(SLASH_OFFSET_IN_ROUNDS > 0, Errors.TallySlashingProposer__SlashOffsetMustBeGreaterThanZero(...));
-    if (config.slashingOffsetInRounds <= 0) {
-      errors.push(`slashingOffsetInRounds (${config.slashingOffsetInRounds}) must be greater than 0`);
-    }
-
-    // From: require(ROUND_SIZE_IN_EPOCHS * _epochDuration == ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeMustBeMultipleOfEpochDuration(...));
-    const roundSizeInSlots = config.slashingRoundSizeInEpochs * config.aztecEpochDuration;
-
-    // From: require(QUORUM > 0, Errors.TallySlashingProposer__QuorumMustBeGreaterThanZero());
-    if (slashingQuorum !== undefined && slashingQuorum <= 0) {
-      errors.push(`slashingQuorum (${slashingQuorum}) must be greater than 0`);
-    }
-
-    // From: require(ROUND_SIZE > 1, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
-    if (roundSizeInSlots <= 1) {
-      errors.push(`slashing round size in slots (${roundSizeInSlots}) must be greater than 1`);
-    }
-
-    // From: require(_slashAmounts[0] <= _slashAmounts[1], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
-    if (config.slashAmountSmall > config.slashAmountMedium) {
-      errors.push(
-        `slashAmountSmall (${config.slashAmountSmall}) must be less than or equal to slashAmountMedium (${config.slashAmountMedium})`,
-      );
-    }
-
-    // From: require(_slashAmounts[1] <= _slashAmounts[2], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
-    if (config.slashAmountMedium > config.slashAmountLarge) {
-      errors.push(
-        `slashAmountMedium (${config.slashAmountMedium}) must be less than or equal to slashAmountLarge (${config.slashAmountLarge})`,
-      );
-    }
-
-    // From: require(LIFETIME_IN_ROUNDS < ROUNDABOUT_SIZE, Errors.TallySlashingProposer__LifetimeMustBeLessThanRoundabout(...));
-    const ROUNDABOUT_SIZE = 128; // Constant from TallySlashingProposer
-    if (config.slashingLifetimeInRounds >= ROUNDABOUT_SIZE) {
-      errors.push(`slashingLifetimeInRounds (${config.slashingLifetimeInRounds}) must be less than ${ROUNDABOUT_SIZE}`);
-    }
-
-    // From: require(ROUND_SIZE_IN_EPOCHS > 0, Errors.TallySlashingProposer__RoundSizeInEpochsMustBeGreaterThanZero(...));
-    if (config.slashingRoundSizeInEpochs <= 0) {
-      errors.push(`slashingRoundSizeInEpochs (${config.slashingRoundSizeInEpochs}) must be greater than 0`);
-    }
-
-    // From: require(ROUND_SIZE < MAX_ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeTooLarge(ROUND_SIZE, MAX_ROUND_SIZE));
-    const MAX_ROUND_SIZE = 1024; // Constant from TallySlashingProposer
-    if (roundSizeInSlots >= MAX_ROUND_SIZE) {
-      errors.push(`slashing round size in slots (${roundSizeInSlots}) must be less than ${MAX_ROUND_SIZE}`);
-    }
-
-    // From: require(COMMITTEE_SIZE > 0, Errors.TallySlashingProposer__CommitteeSizeMustBeGreaterThanZero(COMMITTEE_SIZE));
-    if (config.aztecTargetCommitteeSize <= 0) {
-      errors.push(`aztecTargetCommitteeSize (${config.aztecTargetCommitteeSize}) must be greater than 0`);
-    }
-
-    // From: require(voteSize <= 128, Errors.TallySlashingProposer__VoteSizeTooBig(voteSize, 128));
-    // voteSize = COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS / 4
-    const voteSize = (config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) / 4;
-    if (voteSize > 128) {
-      errors.push(`vote size (${voteSize}) must be <= 128 (committee size * round size in epochs / 4)`);
-    }
-
-    // From: require(COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS % 4 == 0, Errors.TallySlashingProposer__InvalidCommitteeAndRoundSize(...));
-    if ((config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) % 4 !== 0) {
-      errors.push(
-        `aztecTargetCommitteeSize * slashingRoundSizeInEpochs (${config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs}) must be divisible by 4`,
-      );
-    }
-
-    // Slashing offset validation: should be positive to allow proper slashing timing
-    if (config.slashingOffsetInRounds < 0) {
-      errors.push('slashingOffsetInRounds cannot be negative');
-    }
+    validateTallySlasherConfig(config, errors);
   }
 
   // Epoch and slot duration validations
@@ -541,3 +470,83 @@ export function validateConfig(config: Omit<L1ContractsConfig, keyof L1TxUtilsCo
     );
   }
 }
+
+function validateTallySlasherConfig(config: L1ContractsConfig, errors: string[]) {
+  if (config.slasherFlavor !== 'tally') {
+    return;
+  }
+
+  // From: require(SLASH_OFFSET_IN_ROUNDS > 0, Errors.TallySlashingProposer__SlashOffsetMustBeGreaterThanZero(...));
+  if (config.slashingOffsetInRounds <= 0) {
+    errors.push(`slashingOffsetInRounds (${config.slashingOffsetInRounds}) must be greater than 0`);
+  }
+
+  // From: require(ROUND_SIZE_IN_EPOCHS * _epochDuration == ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeMustBeMultipleOfEpochDuration(...));
+  const roundSizeInSlots = config.slashingRoundSizeInEpochs * config.aztecEpochDuration;
+
+  // From: require(QUORUM > 0, Errors.TallySlashingProposer__QuorumMustBeGreaterThanZero());
+  const { slashingQuorum } = config;
+  if (slashingQuorum !== undefined && slashingQuorum <= 0) {
+    errors.push(`slashingQuorum (${slashingQuorum}) must be greater than 0`);
+  }
+
+  // From: require(ROUND_SIZE > 1, Errors.TallySlashingProposer__InvalidQuorumAndRoundSize(QUORUM, ROUND_SIZE));
+  if (roundSizeInSlots <= 1) {
+    errors.push(`slashing round size in slots (${roundSizeInSlots}) must be greater than 1`);
+  }
+
+  // From: require(_slashAmounts[0] <= _slashAmounts[1], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
+  if (config.slashAmountSmall > config.slashAmountMedium) {
+    errors.push(
+      `slashAmountSmall (${config.slashAmountSmall}) must be less than or equal to slashAmountMedium (${config.slashAmountMedium})`,
+    );
+  }
+
+  // From: require(_slashAmounts[1] <= _slashAmounts[2], Errors.TallySlashingProposer__InvalidSlashAmounts(_slashAmounts));
+  if (config.slashAmountMedium > config.slashAmountLarge) {
+    errors.push(
+      `slashAmountMedium (${config.slashAmountMedium}) must be less than or equal to slashAmountLarge (${config.slashAmountLarge})`,
+    );
+  }
+
+  // From: require(LIFETIME_IN_ROUNDS < ROUNDABOUT_SIZE, Errors.TallySlashingProposer__LifetimeMustBeLessThanRoundabout(...));
+  const ROUNDABOUT_SIZE = 128; // Constant from TallySlashingProposer
+  if (config.slashingLifetimeInRounds >= ROUNDABOUT_SIZE) {
+    errors.push(`slashingLifetimeInRounds (${config.slashingLifetimeInRounds}) must be less than ${ROUNDABOUT_SIZE}`);
+  }
+
+  // From: require(ROUND_SIZE_IN_EPOCHS > 0, Errors.TallySlashingProposer__RoundSizeInEpochsMustBeGreaterThanZero(...));
+  if (config.slashingRoundSizeInEpochs <= 0) {
+    errors.push(`slashingRoundSizeInEpochs (${config.slashingRoundSizeInEpochs}) must be greater than 0`);
+  }
+
+  // From: require(ROUND_SIZE < MAX_ROUND_SIZE, Errors.TallySlashingProposer__RoundSizeTooLarge(ROUND_SIZE, MAX_ROUND_SIZE));
+  const MAX_ROUND_SIZE = 1024; // Constant from TallySlashingProposer
+  if (roundSizeInSlots >= MAX_ROUND_SIZE) {
+    errors.push(`slashing round size in slots (${roundSizeInSlots}) must be less than ${MAX_ROUND_SIZE}`);
+  }
+
+  // From: require(COMMITTEE_SIZE > 0, Errors.TallySlashingProposer__CommitteeSizeMustBeGreaterThanZero(COMMITTEE_SIZE));
+  if (config.aztecTargetCommitteeSize <= 0) {
+    errors.push(`aztecTargetCommitteeSize (${config.aztecTargetCommitteeSize}) must be greater than 0`);
+  }
+
+  // From: require(voteSize <= 128, Errors.TallySlashingProposer__VoteSizeTooBig(voteSize, 128));
+  // voteSize = COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS / 4
+  const voteSize = (config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) / 4;
+  if (voteSize > 128) {
+    errors.push(`vote size (${voteSize}) must be <= 128 (committee size * round size in epochs / 4)`);
+  }
+
+  // From: require(COMMITTEE_SIZE * ROUND_SIZE_IN_EPOCHS % 4 == 0, Errors.TallySlashingProposer__InvalidCommitteeAndRoundSize(...));
+  if ((config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs) % 4 !== 0) {
+    errors.push(
+      `aztecTargetCommitteeSize * slashingRoundSizeInEpochs (${config.aztecTargetCommitteeSize * config.slashingRoundSizeInEpochs}) must be divisible by 4`,
+    );
+  }
+
+  // Slashing offset validation: should be positive to allow proper slashing timing
+  if (config.slashingOffsetInRounds < 0) {
+    errors.push('slashingOffsetInRounds cannot be negative');
+  }
+}

package/src/contracts/fee_asset_handler.ts

@@ -9,12 +9,24 @@ export class FeeAssetHandlerContract {
   public address: EthAddress;
 
   constructor(
-    address: Hex,
+    address: Hex | EthAddress,
     public readonly txUtils: L1TxUtils,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.address = EthAddress.fromString(address);
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    const contract = getContract({
+      abi: FeeAssetHandlerAbi,
+      address: this.address.toString(),
+      client: this.txUtils.client,
+    });
+    return EthAddress.fromString(await contract.read.owner());
+  }
+
   public getMintAmount() {
     const contract = getContract({
       abi: FeeAssetHandlerAbi,
@@ -24,7 +36,10 @@ export class FeeAssetHandlerContract {
     return contract.read.mintAmount();
   }
 
-  public mint(recipient: Hex) {
+  public mint(recipient: Hex | EthAddress) {
+    if (recipient instanceof EthAddress) {
+      recipient = recipient.toString();
+    }
     return this.txUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
       data: encodeFunctionData({

package/src/contracts/fee_juice.ts

@@ -9,9 +9,12 @@ export class FeeJuiceContract {
   private readonly feeJuiceContract: GetContractReturnType<typeof FeeJuiceAbi, ViemClient>;
 
   constructor(
-    address: Hex,
+    address: Hex | EthAddress,
     public readonly client: ViemClient,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.feeJuiceContract = getContract({ address, abi: FeeJuiceAbi, client });
   }
 
@@ -19,6 +22,10 @@ export class FeeJuiceContract {
     return EthAddress.fromString(this.feeJuiceContract.address);
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.feeJuiceContract.read.owner());
+  }
+
   private assertWalletFeeJuice(): GetContractReturnType<typeof FeeJuiceAbi, ExtendedViemWalletClient> {
     if (!isExtendedClient(this.client)) {
       throw new Error('Wallet client is required for this operation');

package/src/contracts/governance.ts

@@ -136,9 +136,12 @@ export class GovernanceContract extends ReadOnlyGovernanceContract {
   protected override readonly governanceContract: GetContractReturnType<typeof GovernanceAbi, ExtendedViemWalletClient>;
 
   constructor(
-    address: Hex,
+    address: Hex | EthAddress,
     public override readonly client: ExtendedViemWalletClient,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     super(address, client);
     if (!isExtendedClient(client)) {
       throw new Error('GovernanceContract has to be instantiated with a wallet client.');

package/src/contracts/governance_proposer.ts

@@ -21,8 +21,11 @@ export class GovernanceProposerContract implements IEmpireBase {
 
   constructor(
     public readonly client: ViemClient,
-    address: Hex,
+    address: Hex | EthAddress,
   ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.proposer = getContract({ address, abi: GovernanceProposerAbi, client });
   }
 

package/src/contracts/gse.ts

@@ -39,6 +39,14 @@ export class GSEContract {
     this.gse = getContract({ address, abi: GSEAbi, client });
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.gse.read.owner());
+  }
+
+  public async getGovernance(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.gse.read.getGovernance());
+  }
+
   getAttestersFromIndicesAtTime(instance: Hex | EthAddress, ts: bigint, indices: bigint[]) {
     if (instance instanceof EthAddress) {
       instance = instance.toString();