Deployment preparation: Balancer Contract Registry Initializer

README.md

@@ -158,6 +158,7 @@ These are deployments for script-like contracts (often called 'coordinators') wh
 | Timelock authorizer transition permission migration | [`20230130-ta-transition-migrator`](./v2/scripts/20230130-ta-transition-migrator)                       |
 | Coordination of the Gauge Adder migration V3 --> V4 | [`20230519-gauge-adder-migration-v3-to-v4`](./v2/scripts/20230519-gauge-adder-migration-v3-to-v4)       |
 | Protocol Fee Controller Migration                   | [`20250221-protocol-fee-controller-migration`](./v3/scripts/20250221-protocol-fee-controller-migration) |
+| Balancer Contract Registry Initializer              | [`20250314-balancer-registry-initializer`](./v3/scripts/20250314-balancer-registry-initializer)         |
 
 ## Deprecated Deployments
 

v3/scripts/20250314-balancer-registry-initializer/index.ts

@@ -0,0 +1,19 @@
+import { Task, TaskRunOptions } from '@src';
+import { BalancerContractRegistryInitializerDeployment } from './input';
+
+export default async (task: Task, { force, from }: TaskRunOptions = {}): Promise<void> => {
+  const input = task.input() as BalancerContractRegistryInitializerDeployment;
+
+  const args = [
+    input.Vault,
+    input.BalancerContractRegistry,
+    [input.RouterName, input.BatchRouterName, input.BufferRouterName, input.CompositeLiquidityRouterName],
+    [input.Router, input.BatchRouter, input.BufferRouter, input.CompositeLiquidityRouter],
+    [input.WeightedPoolName, input.StablePoolName, input.StableSurgePoolName, input.LBPoolName],
+    [input.WeightedPoolFactory, input.StablePoolFactory, input.StableSurgePoolFactory, input.LBPoolFactory],
+    [input.WeightedPoolAlias, input.StablePoolAlias, input.RouterAlias, input.BatchRouterAlias],
+    [input.WeightedPoolFactory, input.StablePoolFactory, input.Router, input.BatchRouter],
+  ];
+
+  await task.deployAndVerify('BalancerContractRegistryInitializer', args, from, force);
+};

v3/scripts/20250314-balancer-registry-initializer/input.ts

@@ -0,0 +1,77 @@
+import { Task, TaskMode } from '@src';
+
+export type BalancerContractRegistryInitializerDeployment = {
+  Vault: string;
+  BalancerContractRegistry: string;
+  RouterName: string;
+  Router: string;
+  BatchRouterName: string;
+  BatchRouter: string;
+  BufferRouterName: string;
+  BufferRouter: string;
+  CompositeLiquidityRouterName: string;
+  CompositeLiquidityRouter: string;
+  WeightedPoolName: string;
+  WeightedPoolFactory: string;
+  StablePoolName: string;
+  StablePoolFactory: string;
+  StableSurgePoolName: string;
+  StableSurgePoolFactory: string;
+  LBPoolName: string;
+  LBPoolFactory: string;
+  WeightedPoolAlias: string;
+  StablePoolAlias: string;
+  RouterAlias: string;
+  BatchRouterAlias: string;
+};
+
+const RouterName = '20250307-v3-router-v2';
+const BatchRouterName = '20241205-v3-batch-router';
+const BufferRouterName = '20241205-v3-buffer-router';
+const CompositeLiquidityRouterName = '20250123-v3-composite-liquidity-router-v2';
+const WeightedPoolName = '20241205-v3-weighted-pool';
+const StablePoolName = '20241205-v3-stable-pool';
+const StableSurgePoolName = '20250121-v3-stable-surge';
+const LBPoolName = '20250307-v3-liquidity-bootstrapping-pool';
+
+const Vault = new Task('20241204-v3-vault', TaskMode.READ_ONLY);
+const BalancerContractRegistry = new Task('20250117-v3-contract-registry', TaskMode.READ_ONLY);
+
+const Router = new Task(RouterName, TaskMode.READ_ONLY);
+const BatchRouter = new Task(BatchRouterName, TaskMode.READ_ONLY);
+const BufferRouter = new Task(BufferRouterName, TaskMode.READ_ONLY);
+const CompositeLiquidityRouter = new Task(CompositeLiquidityRouterName, TaskMode.READ_ONLY);
+const WeightedPoolFactory = new Task(WeightedPoolName, TaskMode.READ_ONLY);
+const StablePoolFactory = new Task(StablePoolName, TaskMode.READ_ONLY);
+const StableSurgePoolFactory = new Task(StableSurgePoolName, TaskMode.READ_ONLY);
+const LBPoolFactory = new Task(LBPoolName, TaskMode.READ_ONLY);
+
+const WeightedPoolAlias = 'WeightedPool';
+const StablePoolAlias = 'StablePool';
+const RouterAlias = 'Router';
+const BatchRouterAlias = 'BatchRouter';
+
+export default {
+  Vault,
+  BalancerContractRegistry,
+  RouterName,
+  Router,
+  BatchRouterName,
+  BatchRouter,
+  BufferRouterName,
+  BufferRouter,
+  CompositeLiquidityRouterName,
+  CompositeLiquidityRouter,
+  WeightedPoolName,
+  WeightedPoolFactory,
+  StablePoolName,
+  StablePoolFactory,
+  StableSurgePoolName,
+  StableSurgePoolFactory,
+  LBPoolName,
+  LBPoolFactory,
+  WeightedPoolAlias,
+  StablePoolAlias,
+  RouterAlias,
+  BatchRouterAlias,
+};

v3/scripts/20250314-balancer-registry-initializer/readme.md

@@ -0,0 +1,8 @@
+# 2025-03-14 - V3 Balancer Contract Registry Initializer
+
+Deployment of the `BalancerContractRegistryInitializer`, responsible for populating the registry with routers and pool factories (and initial aliases).
+
+## Useful Files
+
+- [Code](https://github.com/balancer/balancer-v3-monorepo/commit/e1ae7f091244ae20e5c1add3e7f89b6d33f48d23).
+- [`BalancerContractRegistryInitializer` artifact](./artifact/BalancerContractRegistryInitializer.json)

v3/scripts/20250314-balancer-registry-initializer/test/task.fork.ts

@@ -0,0 +1,156 @@
+import hre from 'hardhat';
+import { expect } from 'chai';
+import { Contract } from 'ethers';
+
+import { fp } from '@helpers/numbers';
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/dist/src/signer-with-address';
+
+import { describeForkTest } from '@src';
+import { Task, TaskMode } from '@src';
+import { getForkedNetwork } from '@src';
+import { impersonate } from '@src';
+import { actionId } from '@helpers/models/misc/actions';
+
+describeForkTest('BalancerContractRegistryInitializer', 'mainnet', 21862412, function () {
+  let govMultisig: SignerWithAddress;
+  let registryInitializer: Contract;
+  let registry: Contract;
+
+  let authorizer: Contract;
+  let router: Contract;
+  let batchRouter: Contract;
+  let bufferRouter: Contract;
+  let compositeLiquidityRouter: Contract;
+  let weightedPoolFactory: Contract;
+  let stablePoolFactory: Contract;
+  let stableSurgePoolFactory: Contract;
+  let lbpFactory: Contract;
+
+  let task: Task;
+
+  const GOV_MULTISIG = '0x10A19e7eE7d7F8a52822f6817de8ea18204F2e4f';
+
+  enum ContractType {
+    OTHER, // a blank entry will have a 0-value type, and it's safest to return this in that case
+    POOL_FACTORY,
+    ROUTER,
+    HOOK,
+    ERC4626,
+  }
+
+  before('run task', async () => {
+    task = new Task('20250314-balancer-registry-initializer', TaskMode.TEST, getForkedNetwork(hre));
+    await task.run({ force: true });
+    registryInitializer = await task.deployedInstance('BalancerContractRegistryInitializer');
+  });
+
+  before('setup contracts', async () => {
+    const authorizerTask = new Task('20210418-authorizer', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    authorizer = await authorizerTask.deployedInstance('Authorizer');
+
+    const registryTask = new Task('20250117-v3-contract-registry', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    registry = await registryTask.deployedInstance('BalancerContractRegistry');
+
+    const routerTask = new Task('20250307-v3-router-v2', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    router = await routerTask.deployedInstance('Router');
+
+    const batchRouterTask = new Task('20241205-v3-batch-router', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    batchRouter = await batchRouterTask.deployedInstance('BatchRouter');
+
+    const bufferRouterTask = new Task('20241205-v3-buffer-router', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    bufferRouter = await bufferRouterTask.deployedInstance('BufferRouter');
+
+    const clrTask = new Task('20250123-v3-composite-liquidity-router-v2', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    compositeLiquidityRouter = await clrTask.deployedInstance('CompositeLiquidityRouter');
+
+    const weightedPoolTask = new Task('20241205-v3-weighted-pool', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    weightedPoolFactory = await weightedPoolTask.deployedInstance('WeightedPoolFactory');
+
+    const stablePoolTask = new Task('20241205-v3-stable-pool', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    stablePoolFactory = await stablePoolTask.deployedInstance('StablePoolFactory');
+
+    const stableSurgePoolTask = new Task('20250121-v3-stable-surge', TaskMode.READ_ONLY, getForkedNetwork(hre));
+    stableSurgePoolFactory = await stableSurgePoolTask.deployedInstance('StableSurgePoolFactory');
+
+    const lbpFactoryTask = new Task(
+      '20250307-v3-liquidity-bootstrapping-pool',
+      TaskMode.READ_ONLY,
+      getForkedNetwork(hre)
+    );
+    lbpFactory = await lbpFactoryTask.deployedInstance('LBPoolFactory');
+  });
+
+  before('grant permissions', async () => {
+    govMultisig = await impersonate(GOV_MULTISIG, fp(100));
+
+    await authorizer.connect(govMultisig).grantRole(await authorizer.DEFAULT_ADMIN_ROLE(), registryInitializer.address);
+  });
+
+  it('is initializing the correct registry', async () => {
+    expect(await registryInitializer.balancerContractRegistry()).to.eq(registry.address);
+  });
+
+  it('perform registry initialization', async () => {
+    await registryInitializer.initializeBalancerContractRegistry();
+  });
+
+  it('cannot initialize twice', async () => {
+    await expect(registryInitializer.initializeBalancerContractRegistry()).to.be.reverted;
+  });
+
+  it('does not hold permission to register contracts', async () => {
+    const permission = await actionId(registry, 'registerBalancerContract');
+    expect(await authorizer.hasRole(permission, registryInitializer.address)).to.be.false;
+  });
+
+  it('does not hold permission to add aliases', async () => {
+    const permission = await actionId(registry, 'addOrUpdateBalancerContractAlias');
+    expect(await authorizer.hasRole(permission, registryInitializer.address)).to.be.false;
+  });
+
+  it('renounces the admin role', async () => {
+    expect(await authorizer.hasRole(await authorizer.DEFAULT_ADMIN_ROLE(), registryInitializer.address)).to.be.false;
+  });
+
+  it('has registered the routers', async () => {
+    expect(await registry.isTrustedRouter(router.address)).to.be.true;
+    expect(await registry.isTrustedRouter(batchRouter.address)).to.be.true;
+    expect(await registry.isTrustedRouter(bufferRouter.address)).to.be.true;
+    expect(await registry.isTrustedRouter(compositeLiquidityRouter.address)).to.be.true;
+  });
+
+  it('has registered the pool factories', async () => {
+    let info = await registry.getBalancerContractInfo(weightedPoolFactory.address);
+    _validateInfo(info);
+
+    info = await registry.getBalancerContractInfo(stablePoolFactory.address);
+    _validateInfo(info);
+
+    info = await registry.getBalancerContractInfo(stableSurgePoolFactory.address);
+    _validateInfo(info);
+
+    info = await registry.getBalancerContractInfo(lbpFactory.address);
+    _validateInfo(info);
+  });
+
+  it('has registered the aliases', async () => {
+    let [contractAddress, isActive] = await registry.getBalancerContract(ContractType.POOL_FACTORY, 'WeightedPool');
+    expect(contractAddress).to.eq(weightedPoolFactory.address);
+    expect(isActive).to.be.true;
+
+    [contractAddress, isActive] = await registry.getBalancerContract(ContractType.POOL_FACTORY, 'StablePool');
+    expect(contractAddress).to.eq(stablePoolFactory.address);
+    expect(isActive).to.be.true;
+
+    [contractAddress, isActive] = await registry.getBalancerContract(ContractType.ROUTER, 'Router');
+    expect(contractAddress).to.eq(router.address);
+    expect(isActive).to.be.true;
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _validateInfo(info: any) {
+    expect(info.contractType).to.eq(ContractType.POOL_FACTORY);
+    expect(info.isRegistered).to.be.true;
+    expect(info.isActive).to.be.true;
+  }
+});