chore: check governance

Author: LHerskind

yarn-project/ethereum/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,

yarn-project/ethereum/src/contracts/fee_juice.ts

@@ -9,16 +9,23 @@ 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 });
   }
 
   public get address() {
     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');

yarn-project/ethereum/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.');

yarn-project/ethereum/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 });
   }
 

yarn-project/ethereum/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();

yarn-project/ethereum/src/deploy_l1_contracts.test.ts

@@ -10,6 +10,9 @@ import { type PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
 import { createEthereumChain } from './chain.js';
 import { createExtendedL1Client } from './client.js';
 import { DefaultL1ContractsConfig } from './config.js';
+import { GovernanceContract } from './contracts/governance.js';
+import { GSEContract } from './contracts/gse.js';
+import { RegistryContract } from './contracts/registry.js';
 import { RollupContract } from './contracts/rollup.js';
 import { type DeployL1ContractsArgs, type Operator, deployL1Contracts } from './deploy_l1_contracts.js';
 import { startAnvil } from './test/start_anvil.js';
@@ -159,4 +162,99 @@ describe('deploy_l1_contracts', () => {
       BigInt(initialValidators.length),
     );
   });
+
+  it('ensure governance is the owner', async () => {
+    // Runs the deployment script and checks if we have handed over things correctly to the governance.
+
+    const deployment = await deployL1Contracts(
+      [rpcUrl!],
+      privateKey,
+      createEthereumChain([rpcUrl!], chainId).chainInfo,
+      logger,
+      {
+        ...DefaultL1ContractsConfig,
+        salt: undefined,
+        vkTreeRoot,
+        protocolContractTreeRoot,
+        genesisArchiveRoot,
+        l1TxConfig: { checkIntervalMs: 100 },
+        realVerifier: false,
+      },
+    );
+
+    const governance = new GovernanceContract(deployment.l1ContractAddresses.governanceAddress, client);
+    const registry = new RegistryContract(client, deployment.l1ContractAddresses.registryAddress);
+    const rollup = new RollupContract(client, deployment.l1ContractAddresses.rollupAddress);
+    const gse = new GSEContract(client, await rollup.getGSE());
+
+    // Checking the shared
+    expect(await registry.getOwner()).toEqual(governance.address);
+    expect(await gse.getOwner()).toEqual(governance.address);
+    expect(await gse.getGovernance()).toEqual(governance.address);
+    expect(await getOwner(deployment.l1ContractAddresses.rewardDistributorAddress, 'REGISTRY')).toEqual(
+      registry.address,
+    );
+    expect(await getOwner(deployment.l1ContractAddresses.coinIssuerAddress)).toEqual(governance.address);
+
+    expect(await getOwner(deployment.l1ContractAddresses.feeJuiceAddress)).toEqual(
+      deployment.l1ContractAddresses.coinIssuerAddress,
+    );
+
+    // The rollup contract should be owned by the governance contract as well.
+    expect(await getOwner(EthAddress.fromString(rollup.address))).toEqual(governance.address);
+
+    // Make sure that the fee asset handler is the minter of the fee asset.
+    expect(
+      await isMinter(
+        deployment.l1ContractAddresses.feeJuiceAddress,
+        deployment.l1ContractAddresses.feeAssetHandlerAddress!,
+      ),
+    ).toBeTruthy();
+  });
+
+  const isContract = async (address: EthAddress) => {
+    const bytecode = await client.getBytecode({ address: address.toString() });
+    return bytecode !== undefined && bytecode !== '0x';
+  };
+
+  const getOwner = async (address: EthAddress, name: string = 'owner') => {
+    if (!(await isContract(address))) {
+      throw new Error(`Address ${address} have no bytecode, is it deployed?`);
+    }
+    return EthAddress.fromString(
+      await client.readContract({
+        address: address.toString(),
+        abi: [
+          {
+            name: name,
+            type: 'function',
+            inputs: [],
+            outputs: [{ type: 'address' }],
+            stateMutability: 'view',
+          },
+        ],
+        functionName: name,
+      }),
+    );
+  };
+
+  const isMinter = async (address: EthAddress, minter: EthAddress) => {
+    if (!(await isContract(address))) {
+      throw new Error(`Address ${address} have no bytecode, is it deployed?`);
+    }
+    return await client.readContract({
+      address: address.toString(),
+      abi: [
+        {
+          name: 'minters',
+          type: 'function',
+          inputs: [{ type: 'address' }],
+          outputs: [{ type: 'bool' }],
+          stateMutability: 'view',
+        },
+      ],
+      functionName: 'minters',
+      args: [minter.toString()],
+    });
+  };
 });

yarn-project/ethereum/src/deploy_l1_contracts.ts

@@ -247,36 +247,14 @@ export const deploySharedContracts = async (
 
   const coinIssuerAddress = await deployer.deploy(CoinIssuerArtifact, [
     feeAssetAddress.toString(),
-    1n * 10n ** 18n, // @todo  #8084
-    governanceAddress.toString(),
+    1_000_000n * 10n ** 18n, // @todo  #8084
+    l1Client.account.address,
   ]);
   logger.verbose(`Deployed CoinIssuer at ${coinIssuerAddress}`);
 
-  const feeAsset = getContract({
-    address: feeAssetAddress.toString(),
-    abi: FeeAssetArtifact.contractAbi,
-    client: l1Client,
-  });
-
   logger.verbose(`Waiting for deployments to complete`);
   await deployer.waitForDeployments();
 
-  if (args.acceleratedTestDeployments || !(await feeAsset.read.minters([coinIssuerAddress.toString()]))) {
-    const { txHash } = await deployer.sendTransaction(
-      {
-        to: feeAssetAddress.toString(),
-        data: encodeFunctionData({
-          abi: FeeAssetArtifact.contractAbi,
-          functionName: 'addMinter',
-          args: [coinIssuerAddress.toString()],
-        }),
-      },
-      { gasLimit: 100_000n },
-    );
-    logger.verbose(`Added coin issuer ${coinIssuerAddress} as minter on fee asset in ${txHash}`);
-    txHashes.push(txHash);
-  }
-
   // Registry ownership will be transferred to governance later, after rollup is added
 
   let feeAssetHandlerAddress: EthAddress | undefined = undefined;
@@ -500,7 +478,12 @@ export const deployRollup = async (
   >,
   addresses: Pick<
     L1ContractAddresses,
-    'feeJuiceAddress' | 'registryAddress' | 'rewardDistributorAddress' | 'stakingAssetAddress' | 'gseAddress'
+    | 'feeJuiceAddress'
+    | 'registryAddress'
+    | 'rewardDistributorAddress'
+    | 'stakingAssetAddress'
+    | 'gseAddress'
+    | 'governanceAddress'
   >,
   logger: Logger,
 ) => {
@@ -678,6 +661,24 @@ export const deployRollup = async (
     );
   }
 
+  // If the owner is not the Governance contract, transfer ownership to the Governance contract
+  logger.verbose(addresses.governanceAddress.toString());
+  if (getAddress(await rollupContract.getOwner()) !== getAddress(addresses.governanceAddress.toString())) {
+    // TODO(md): add send transaction to the deployer such that we do not need to manage tx hashes here
+    const { txHash: transferOwnershipTxHash } = await deployer.sendTransaction({
+      to: rollupContract.address,
+      data: encodeFunctionData({
+        abi: RegistryArtifact.contractAbi,
+        functionName: 'transferOwnership',
+        args: [getAddress(addresses.governanceAddress.toString())],
+      }),
+    });
+    logger.verbose(
+      `Transferring the ownership of the rollup contract at ${rollupContract.address} to the Governance ${addresses.governanceAddress} in tx ${transferOwnershipTxHash}`,
+    );
+    txHashes.push(transferOwnershipTxHash);
+  }
+
   await deployer.waitForDeployments();
   await Promise.all(txHashes.map(txHash => extendedClient.waitForTransactionReceipt({ hash: txHash })));
   logger.verbose(`Rollup deployed`);
@@ -690,6 +691,8 @@ export const handoverToGovernance = async (
   deployer: L1Deployer,
   registryAddress: EthAddress,
   gseAddress: EthAddress,
+  coinIssuerAddress: EthAddress,
+  feeAssetAddress: EthAddress,
   governanceAddress: EthAddress,
   logger: Logger,
   acceleratedTestDeployments: boolean | undefined,
@@ -707,6 +710,18 @@ export const handoverToGovernance = async (
     client: extendedClient,
   });
 
+  const coinIssuerContract = getContract({
+    address: getAddress(coinIssuerAddress.toString()),
+    abi: CoinIssuerArtifact.contractAbi,
+    client: extendedClient,
+  });
+
+  const feeAsset = getContract({
+    address: getAddress(feeAssetAddress.toString()),
+    abi: FeeAssetArtifact.contractAbi,
+    client: extendedClient,
+  });
+
   const txHashes: Hex[] = [];
 
   // If the owner is not the Governance contract, transfer ownership to the Governance contract
@@ -746,6 +761,54 @@ export const handoverToGovernance = async (
     txHashes.push(transferOwnershipTxHash);
   }
 
+  if (acceleratedTestDeployments || (await feeAsset.read.owner()) !== coinIssuerAddress.toString()) {
+    const { txHash } = await deployer.sendTransaction(
+      {
+        to: feeAssetAddress.toString(),
+        data: encodeFunctionData({
+          abi: FeeAssetArtifact.contractAbi,
+          functionName: 'transferOwnership',
+          args: [coinIssuerAddress.toString()],
+        }),
+      },
+      { gasLimit: 500_000n },
+    );
+    logger.verbose(`Transfer ownership of fee asset to coin issuer ${coinIssuerAddress} in ${txHash}`);
+    txHashes.push(txHash);
+
+    const { txHash: acceptTokenOwnershipTxHash } = await deployer.sendTransaction(
+      {
+        to: coinIssuerAddress.toString(),
+        data: encodeFunctionData({
+          abi: CoinIssuerArtifact.contractAbi,
+          functionName: 'acceptTokenOwnership',
+        }),
+      },
+      { gasLimit: 500_000n },
+    );
+    logger.verbose(`Accept ownership of fee asset in ${acceptTokenOwnershipTxHash}`);
+    txHashes.push(acceptTokenOwnershipTxHash);
+  }
+
+  // If the owner is not the Governance contract, transfer ownership to the Governance contract
+  if (
+    acceleratedTestDeployments ||
+    (await coinIssuerContract.read.owner()) !== getAddress(governanceAddress.toString())
+  ) {
+    const { txHash: transferOwnershipTxHash } = await deployer.sendTransaction({
+      to: coinIssuerContract.address,
+      data: encodeFunctionData({
+        abi: CoinIssuerArtifact.contractAbi,
+        functionName: 'transferOwnership',
+        args: [getAddress(governanceAddress.toString())],
+      }),
+    });
+    logger.verbose(
+      `Transferring the ownership of the coin issuer contract at ${coinIssuerAddress} to the Governance ${governanceAddress} in tx ${transferOwnershipTxHash}`,
+    );
+    txHashes.push(transferOwnershipTxHash);
+  }
+
   // Wait for all actions to be mined
   await deployer.waitForDeployments();
   await Promise.all(txHashes.map(txHash => extendedClient.waitForTransactionReceipt({ hash: txHash })));
@@ -964,6 +1027,7 @@ export const deployL1Contracts = async (
     governanceAddress,
     rewardDistributorAddress,
     zkPassportVerifierAddress,
+    coinIssuerAddress,
   } = await deploySharedContracts(l1Client, deployer, args, logger);
   const { rollup, slashFactoryAddress } = await deployRollup(
     l1Client,
@@ -975,6 +1039,7 @@ export const deployL1Contracts = async (
       gseAddress,
       rewardDistributorAddress,
       stakingAssetAddress,
+      governanceAddress,
     },
     logger,
   );
@@ -988,6 +1053,8 @@ export const deployL1Contracts = async (
     deployer,
     registryAddress,
     gseAddress,
+    coinIssuerAddress,
+    feeAssetAddress,
     governanceAddress,
     logger,
     args.acceleratedTestDeployments,
@@ -1032,6 +1099,7 @@ export const deployL1Contracts = async (
       feeAssetHandlerAddress,
       stakingAssetHandlerAddress,
       zkPassportVerifierAddress,
+      coinIssuerAddress,
     },
   };
 };