@aztec/ethereum 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/deploy_l1_contracts.js

@@ -1,1267 +0,0 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import { getActiveNetworkName } from '@aztec/foundation/config';
-import { keccak256String } from '@aztec/foundation/crypto';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { DateProvider } from '@aztec/foundation/timer';
-import { mkdir, writeFile } from 'fs/promises';
-import { concatHex, encodeAbiParameters, encodeDeployData, encodeFunctionData, getAddress, getContract, getContractAddress, numberToHex, padHex } from 'viem';
-import { foundry } from 'viem/chains';
-import { isAnvilTestChain } from './chain.js';
-import { createExtendedL1Client } from './client.js';
-import { getEntryQueueConfig, getGSEConfiguration, getGovernanceConfiguration, getRewardBoostConfig, getRewardConfig, validateConfig } from './config.js';
-import { GSEContract } from './contracts/gse.js';
-import { deployMulticall3 } from './contracts/multicall.js';
-import { RegistryContract } from './contracts/registry.js';
-import { RollupContract, SlashingProposerType } from './contracts/rollup.js';
-import { CoinIssuerArtifact, FeeAssetArtifact, FeeAssetHandlerArtifact, GSEArtifact, GovernanceArtifact, GovernanceProposerArtifact, MultiAdderArtifact, RegisterNewRollupVersionPayloadArtifact, RegistryArtifact, RollupArtifact, SlashFactoryArtifact, StakingAssetArtifact, StakingAssetHandlerArtifact, l1ArtifactsVerifiers, mockVerifiers } from './l1_artifacts.js';
-import { createL1TxUtilsFromViemWallet, getL1TxUtilsConfigEnvVars } from './l1_tx_utils.js';
-import { formatViemError } from './utils.js';
-import { ZK_PASSPORT_DOMAIN, ZK_PASSPORT_SCOPE, ZK_PASSPORT_VERIFIER_ADDRESS } from './zkPassportVerifierAddress.js';
-export const DEPLOYER_ADDRESS = '0x4e59b44847b379578588920cA78FbF26c0B4956C';
-const networkName = getActiveNetworkName();
-export const deploySharedContracts = async (l1Client, deployer, args, logger)=>{
-    logger.info(`Deploying shared contracts for network configration: ${networkName}`);
-    const txHashes = [];
-    const feeAssetAddress = await deployer.deploy(FeeAssetArtifact, [
-        'FeeJuice',
-        'FEE',
-        l1Client.account.address
-    ]);
-    logger.verbose(`Deployed Fee Asset at ${feeAssetAddress}`);
-    const stakingAssetAddress = await deployer.deploy(StakingAssetArtifact, [
-        'Staking',
-        'STK',
-        l1Client.account.address
-    ]);
-    logger.verbose(`Deployed Staking Asset at ${stakingAssetAddress}`);
-    const gseConfiguration = getGSEConfiguration(networkName);
-    const gseAddress = await deployer.deploy(GSEArtifact, [
-        l1Client.account.address,
-        stakingAssetAddress.toString(),
-        gseConfiguration.activationThreshold,
-        gseConfiguration.ejectionThreshold
-    ]);
-    logger.verbose(`Deployed GSE at ${gseAddress}`);
-    const registryAddress = await deployer.deploy(RegistryArtifact, [
-        l1Client.account.address,
-        feeAssetAddress.toString()
-    ]);
-    logger.verbose(`Deployed Registry at ${registryAddress}`);
-    const governanceProposerAddress = await deployer.deploy(GovernanceProposerArtifact, [
-        registryAddress.toString(),
-        gseAddress.toString(),
-        BigInt(args.governanceProposerQuorum ?? args.governanceProposerRoundSize / 2 + 1),
-        BigInt(args.governanceProposerRoundSize)
-    ]);
-    logger.verbose(`Deployed GovernanceProposer at ${governanceProposerAddress}`);
-    // @note @LHerskind the assets are expected to be the same at some point, but for better
-    // configurability they are different for now.
-    const governanceAddress = await deployer.deploy(GovernanceArtifact, [
-        stakingAssetAddress.toString(),
-        governanceProposerAddress.toString(),
-        gseAddress.toString(),
-        getGovernanceConfiguration(networkName)
-    ]);
-    logger.verbose(`Deployed Governance at ${governanceAddress}`);
-    let needToSetGovernance = false;
-    const existingCode = await l1Client.getCode({
-        address: gseAddress.toString()
-    });
-    if (!existingCode || existingCode === '0x') {
-        needToSetGovernance = true;
-    } else {
-        const gseContract = getContract({
-            address: getAddress(gseAddress.toString()),
-            abi: GSEArtifact.contractAbi,
-            client: l1Client
-        });
-        const existingGovernance = await gseContract.read.getGovernance();
-        if (EthAddress.fromString(existingGovernance).equals(EthAddress.ZERO)) {
-            needToSetGovernance = true;
-        }
-    }
-    if (needToSetGovernance) {
-        const { txHash } = await deployer.sendTransaction({
-            to: gseAddress.toString(),
-            data: encodeFunctionData({
-                abi: GSEArtifact.contractAbi,
-                functionName: 'setGovernance',
-                args: [
-                    governanceAddress.toString()
-                ]
-            })
-        }, {
-            gasLimit: 100_000n
-        });
-        logger.verbose(`Set governance on GSE in ${txHash}`);
-        txHashes.push(txHash);
-    }
-    const coinIssuerAddress = await deployer.deploy(CoinIssuerArtifact, [
-        feeAssetAddress.toString(),
-        1_000_000n * 10n ** 18n,
-        l1Client.account.address
-    ]);
-    logger.verbose(`Deployed CoinIssuer at ${coinIssuerAddress}`);
-    logger.verbose(`Waiting for deployments to complete`);
-    await deployer.waitForDeployments();
-    // Registry ownership will be transferred to governance later, after rollup is added
-    let feeAssetHandlerAddress = undefined;
-    let stakingAssetHandlerAddress = undefined;
-    let zkPassportVerifierAddress = undefined;
-    // Only if not on mainnet will we deploy the handlers
-    if (l1Client.chain.id !== 1) {
-        /* -------------------------------------------------------------------------- */ /*                          CHEAT CODES START HERE                            */ /* -------------------------------------------------------------------------- */ feeAssetHandlerAddress = await deployer.deploy(FeeAssetHandlerArtifact, [
-            l1Client.account.address,
-            feeAssetAddress.toString(),
-            BigInt(1000n * 10n ** 18n)
-        ]);
-        logger.verbose(`Deployed FeeAssetHandler at ${feeAssetHandlerAddress}`);
-        // Only if we are "fresh" will we be adding as a minter, otherwise above will simply get same address
-        if (needToSetGovernance) {
-            const { txHash } = await deployer.sendTransaction({
-                to: feeAssetAddress.toString(),
-                data: encodeFunctionData({
-                    abi: FeeAssetArtifact.contractAbi,
-                    functionName: 'addMinter',
-                    args: [
-                        feeAssetHandlerAddress.toString()
-                    ]
-                })
-            });
-            logger.verbose(`Added fee asset handler ${feeAssetHandlerAddress} as minter on fee asset in ${txHash}`);
-            txHashes.push(txHash);
-        }
-        // Only if on sepolia will we deploy the staking asset handler
-        // Should not be deployed to devnet since it would cause caos with sequencers there etc.
-        if ([
-            11155111,
-            foundry.id
-        ].includes(l1Client.chain.id)) {
-            const AMIN = EthAddress.fromString('0x3b218d0F26d15B36C715cB06c949210a0d630637');
-            zkPassportVerifierAddress = await getZkPassportVerifierAddress(deployer, args);
-            const [domain, scope] = getZkPassportScopes(args);
-            const stakingAssetHandlerDeployArgs = {
-                owner: l1Client.account.address,
-                stakingAsset: stakingAssetAddress.toString(),
-                registry: registryAddress.toString(),
-                withdrawer: AMIN.toString(),
-                mintInterval: BigInt(60 * 60 * 24),
-                depositsPerMint: BigInt(10),
-                depositMerkleRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-                zkPassportVerifier: zkPassportVerifierAddress.toString(),
-                unhinged: [
-                    AMIN.toString()
-                ],
-                // Scopes
-                domain: domain,
-                scope: scope,
-                // Skip checks
-                skipBindCheck: args.zkPassportArgs?.mockZkPassportVerifier ?? false,
-                skipMerkleCheck: true
-            };
-            stakingAssetHandlerAddress = await deployer.deploy(StakingAssetHandlerArtifact, [
-                stakingAssetHandlerDeployArgs
-            ]);
-            logger.verbose(`Deployed StakingAssetHandler at ${stakingAssetHandlerAddress}`);
-            const { txHash: stakingMinterTxHash } = await deployer.sendTransaction({
-                to: stakingAssetAddress.toString(),
-                data: encodeFunctionData({
-                    abi: StakingAssetArtifact.contractAbi,
-                    functionName: 'addMinter',
-                    args: [
-                        stakingAssetHandlerAddress.toString()
-                    ]
-                })
-            });
-            logger.verbose(`Added staking asset handler ${stakingAssetHandlerAddress} as minter on staking asset in ${stakingMinterTxHash}`);
-            txHashes.push(stakingMinterTxHash);
-        }
-    }
-    /* -------------------------------------------------------------------------- */ /*                           CHEAT CODES END HERE                             */ /* -------------------------------------------------------------------------- */ logger.verbose(`Waiting for deployments to complete`);
-    await deployer.waitForDeployments();
-    await Promise.all(txHashes.map((txHash)=>l1Client.waitForTransactionReceipt({
-            hash: txHash
-        })));
-    logger.verbose(`Deployed shared contracts`);
-    const registry = new RegistryContract(l1Client, registryAddress);
-    /* -------------------------------------------------------------------------- */ /*                      FUND REWARD DISTRIBUTOR START                         */ /* -------------------------------------------------------------------------- */ const rewardDistributorAddress = await registry.getRewardDistributor();
-    const blockReward = getRewardConfig(networkName).blockReward;
-    const funding = blockReward * 200000n;
-    const { txHash: fundRewardDistributorTxHash } = await deployer.sendTransaction({
-        to: feeAssetAddress.toString(),
-        data: encodeFunctionData({
-            abi: FeeAssetArtifact.contractAbi,
-            functionName: 'mint',
-            args: [
-                rewardDistributorAddress.toString(),
-                funding
-            ]
-        })
-    });
-    logger.verbose(`Funded reward distributor with ${funding} fee asset in ${fundRewardDistributorTxHash}`);
-    /* -------------------------------------------------------------------------- */ /*                      FUND REWARD DISTRIBUTOR STOP                          */ /* -------------------------------------------------------------------------- */ return {
-        feeAssetAddress,
-        feeAssetHandlerAddress,
-        stakingAssetAddress,
-        stakingAssetHandlerAddress,
-        zkPassportVerifierAddress,
-        registryAddress,
-        gseAddress,
-        governanceAddress,
-        governanceProposerAddress,
-        coinIssuerAddress,
-        rewardDistributorAddress: await registry.getRewardDistributor()
-    };
-};
-const getZkPassportVerifierAddress = async (deployer, args)=>{
-    if (args.zkPassportArgs?.mockZkPassportVerifier) {
-        return await deployer.deploy(mockVerifiers.mockZkPassportVerifier);
-    }
-    return ZK_PASSPORT_VERIFIER_ADDRESS;
-};
-/**
- * Get the zk passport scopes - default to testnet values if not provided
- * @param args - The deployment arguments
- * @returns The zk passport scopes
- */ const getZkPassportScopes = (args)=>{
-    const domain = args.zkPassportArgs?.zkPassportDomain ?? ZK_PASSPORT_DOMAIN;
-    const scope = args.zkPassportArgs?.zkPassportScope ?? ZK_PASSPORT_SCOPE;
-    return [
-        domain,
-        scope
-    ];
-};
-/**
- * Deploys a new rollup, using the existing canonical version to derive certain values (addresses of assets etc).
- * @param clients - The L1 clients.
- * @param args - The deployment arguments.
- * @param registryAddress - The address of the registry.
- * @param logger - The logger.
- * @param txUtilsConfig - The L1 tx utils config.
- */ export const deployRollupForUpgrade = async (extendedClient, args, registryAddress, logger, txUtilsConfig)=>{
-    const deployer = new L1Deployer(extendedClient, args.salt, undefined, args.acceleratedTestDeployments, logger, txUtilsConfig);
-    const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
-    const { rollup, slashFactoryAddress } = await deployRollup(extendedClient, deployer, args, addresses, logger);
-    await deployer.waitForDeployments();
-    return {
-        rollup,
-        slashFactoryAddress
-    };
-};
-export const deploySlashFactory = async (deployer, rollupAddress, logger)=>{
-    const slashFactoryAddress = await deployer.deploy(SlashFactoryArtifact, [
-        rollupAddress
-    ]);
-    logger.verbose(`Deployed SlashFactory at ${slashFactoryAddress}`);
-    return slashFactoryAddress;
-};
-export const deployUpgradePayload = async (deployer, addresses)=>{
-    const payloadAddress = await deployer.deploy(RegisterNewRollupVersionPayloadArtifact, [
-        addresses.registryAddress.toString(),
-        addresses.rollupAddress.toString()
-    ]);
-    return payloadAddress;
-};
-function slasherFlavorToSolidityEnum(flavor) {
-    switch(flavor){
-        case 'none':
-            return SlashingProposerType.None.valueOf();
-        case 'tally':
-            return SlashingProposerType.Tally.valueOf();
-        case 'empire':
-            return SlashingProposerType.Empire.valueOf();
-        default:
-            {
-                const _ = flavor;
-                throw new Error(`Unexpected slasher flavor ${flavor}`);
-            }
-    }
-}
-/**
- * Deploys a new rollup contract, funds and initializes the fee juice portal, and initializes the validator set.
- */ export const deployRollup = async (extendedClient, deployer, args, addresses, logger)=>{
-    if (!addresses.gseAddress) {
-        throw new Error('GSE address is required when deploying');
-    }
-    logger.info(`Deploying rollup using network configuration: ${networkName}`);
-    const txHashes = [];
-    let epochProofVerifier = EthAddress.ZERO;
-    if (args.realVerifier) {
-        epochProofVerifier = await deployer.deploy(l1ArtifactsVerifiers.honkVerifier);
-        logger.verbose(`Rollup will use the real verifier at ${epochProofVerifier}`);
-    } else {
-        epochProofVerifier = await deployer.deploy(mockVerifiers.mockVerifier);
-        logger.verbose(`Rollup will use the mock verifier at ${epochProofVerifier}`);
-    }
-    const rewardConfig = {
-        ...getRewardConfig(networkName),
-        rewardDistributor: addresses.rewardDistributorAddress.toString()
-    };
-    const rollupConfigArgs = {
-        aztecSlotDuration: BigInt(args.aztecSlotDuration),
-        aztecEpochDuration: BigInt(args.aztecEpochDuration),
-        targetCommitteeSize: BigInt(args.aztecTargetCommitteeSize),
-        aztecProofSubmissionEpochs: BigInt(args.aztecProofSubmissionEpochs),
-        slashingQuorum: BigInt(args.slashingQuorum ?? args.slashingRoundSizeInEpochs * args.aztecEpochDuration / 2 + 1),
-        slashingRoundSize: BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration),
-        slashingLifetimeInRounds: BigInt(args.slashingLifetimeInRounds),
-        slashingExecutionDelayInRounds: BigInt(args.slashingExecutionDelayInRounds),
-        slashingVetoer: args.slashingVetoer.toString(),
-        manaTarget: args.manaTarget,
-        provingCostPerMana: args.provingCostPerMana,
-        rewardConfig: rewardConfig,
-        version: 0,
-        rewardBoostConfig: getRewardBoostConfig(networkName),
-        stakingQueueConfig: getEntryQueueConfig(networkName),
-        exitDelaySeconds: BigInt(args.exitDelaySeconds),
-        slasherFlavor: slasherFlavorToSolidityEnum(args.slasherFlavor),
-        slashingOffsetInRounds: BigInt(args.slashingOffsetInRounds),
-        slashAmounts: [
-            args.slashAmountSmall,
-            args.slashAmountMedium,
-            args.slashAmountLarge
-        ]
-    };
-    const genesisStateArgs = {
-        vkTreeRoot: args.vkTreeRoot.toString(),
-        protocolContractTreeRoot: args.protocolContractTreeRoot.toString(),
-        genesisArchiveRoot: args.genesisArchiveRoot.toString()
-    };
-    // Until there is an actual chain-id for the version, we will just draw a random value.
-    // TODO(https://linear.app/aztec-labs/issue/TMNT-139/version-at-deployment)
-    rollupConfigArgs.version = Buffer.from(keccak256String(jsonStringify({
-        rollupConfigArgs,
-        genesisStateArgs
-    }))).readUint32BE(0);
-    logger.verbose(`Rollup config args`, rollupConfigArgs);
-    const rollupArgs = [
-        addresses.feeJuiceAddress.toString(),
-        addresses.stakingAssetAddress.toString(),
-        addresses.gseAddress.toString(),
-        epochProofVerifier.toString(),
-        extendedClient.account.address,
-        genesisStateArgs,
-        rollupConfigArgs
-    ];
-    const rollupAddress = await deployer.deploy(RollupArtifact, rollupArgs, {
-        gasLimit: 15_000_000n
-    });
-    logger.verbose(`Deployed Rollup at ${rollupAddress}`, rollupConfigArgs);
-    const rollupContract = new RollupContract(extendedClient, rollupAddress);
-    await deployer.waitForDeployments();
-    logger.verbose(`All core contracts have been deployed`);
-    if (args.feeJuicePortalInitialBalance && args.feeJuicePortalInitialBalance > 0n) {
-        const feeJuicePortalAddress = await rollupContract.getFeeJuicePortal();
-        // In fast mode, use the L1TxUtils to send transactions with nonce management
-        const { txHash: mintTxHash } = await deployer.sendTransaction({
-            to: addresses.feeJuiceAddress.toString(),
-            data: encodeFunctionData({
-                abi: FeeAssetArtifact.contractAbi,
-                functionName: 'mint',
-                args: [
-                    feeJuicePortalAddress.toString(),
-                    args.feeJuicePortalInitialBalance
-                ]
-            })
-        });
-        logger.verbose(`Funding fee juice portal with ${args.feeJuicePortalInitialBalance} fee juice in ${mintTxHash} (accelerated test deployments)`);
-        txHashes.push(mintTxHash);
-    }
-    const slashFactoryAddress = await deployer.deploy(SlashFactoryArtifact, [
-        rollupAddress.toString()
-    ]);
-    logger.verbose(`Deployed SlashFactory at ${slashFactoryAddress}`);
-    // We need to call a function on the registry to set the various contract addresses.
-    const registryContract = getContract({
-        address: getAddress(addresses.registryAddress.toString()),
-        abi: RegistryArtifact.contractAbi,
-        client: extendedClient
-    });
-    // Only if we are the owner will we be sending these transactions
-    if (await registryContract.read.owner() === getAddress(extendedClient.account.address)) {
-        const version = await rollupContract.getVersion();
-        try {
-            const retrievedRollupAddress = await registryContract.read.getRollup([
-                version
-            ]);
-            logger.verbose(`Rollup ${retrievedRollupAddress} already exists in registry`);
-        } catch  {
-            const { txHash: addRollupTxHash } = await deployer.sendTransaction({
-                to: addresses.registryAddress.toString(),
-                data: encodeFunctionData({
-                    abi: RegistryArtifact.contractAbi,
-                    functionName: 'addRollup',
-                    args: [
-                        getAddress(rollupContract.address)
-                    ]
-                })
-            });
-            logger.verbose(`Adding rollup ${rollupContract.address} to registry ${addresses.registryAddress} in tx ${addRollupTxHash}`);
-            txHashes.push(addRollupTxHash);
-        }
-    } else {
-        logger.verbose(`Not the owner of the registry, skipping rollup addition`);
-    }
-    // We need to call a function on the registry to set the various contract addresses.
-    const gseContract = getContract({
-        address: getAddress(addresses.gseAddress.toString()),
-        abi: GSEArtifact.contractAbi,
-        client: extendedClient
-    });
-    if (await gseContract.read.owner() === getAddress(extendedClient.account.address)) {
-        if (!await gseContract.read.isRollupRegistered([
-            rollupContract.address
-        ])) {
-            const { txHash: addRollupTxHash } = await deployer.sendTransaction({
-                to: addresses.gseAddress.toString(),
-                data: encodeFunctionData({
-                    abi: GSEArtifact.contractAbi,
-                    functionName: 'addRollup',
-                    args: [
-                        getAddress(rollupContract.address)
-                    ]
-                })
-            });
-            logger.verbose(`Adding rollup ${rollupContract.address} to GSE ${addresses.gseAddress} in tx ${addRollupTxHash}`);
-            // wait for this tx to land in case we have to register initialValidators
-            await extendedClient.waitForTransactionReceipt({
-                hash: addRollupTxHash
-            });
-        } else {
-            logger.verbose(`Rollup ${rollupContract.address} is already registered in GSE ${addresses.gseAddress}`);
-        }
-    } else {
-        logger.verbose(`Not the owner of the gse, skipping rollup addition`);
-    }
-    if (args.initialValidators && await gseContract.read.isRollupRegistered([
-        rollupContract.address
-    ])) {
-        await addMultipleValidators(extendedClient, deployer, addresses.gseAddress.toString(), rollupAddress.toString(), addresses.stakingAssetAddress.toString(), args.initialValidators, args.acceleratedTestDeployments, logger);
-    }
-    // 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`);
-    return {
-        rollup: rollupContract,
-        slashFactoryAddress
-    };
-};
-export const handoverToGovernance = async (extendedClient, deployer, registryAddress, gseAddress, coinIssuerAddress, feeAssetAddress, governanceAddress, logger, acceleratedTestDeployments)=>{
-    // We need to call a function on the registry to set the various contract addresses.
-    const registryContract = getContract({
-        address: getAddress(registryAddress.toString()),
-        abi: RegistryArtifact.contractAbi,
-        client: extendedClient
-    });
-    const gseContract = getContract({
-        address: getAddress(gseAddress.toString()),
-        abi: GSEArtifact.contractAbi,
-        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 = [];
-    // If the owner is not the Governance contract, transfer ownership to the Governance contract
-    if (acceleratedTestDeployments || await registryContract.read.owner() !== getAddress(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: registryAddress.toString(),
-            data: encodeFunctionData({
-                abi: RegistryArtifact.contractAbi,
-                functionName: 'transferOwnership',
-                args: [
-                    getAddress(governanceAddress.toString())
-                ]
-            })
-        });
-        logger.verbose(`Transferring the ownership of the registry contract at ${registryAddress} to the Governance ${governanceAddress} in tx ${transferOwnershipTxHash}`);
-        txHashes.push(transferOwnershipTxHash);
-    }
-    // If the owner is not the Governance contract, transfer ownership to the Governance contract
-    if (acceleratedTestDeployments || await gseContract.read.owner() !== getAddress(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: gseContract.address,
-            data: encodeFunctionData({
-                abi: GSEArtifact.contractAbi,
-                functionName: 'transferOwnership',
-                args: [
-                    getAddress(governanceAddress.toString())
-                ]
-            })
-        });
-        logger.verbose(`Transferring the ownership of the gse contract at ${gseAddress} to the Governance ${governanceAddress} in tx ${transferOwnershipTxHash}`);
-        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
-        })));
-};
-/*
- * Adds multiple validators to the rollup
- *
- * @param extendedClient - The L1 clients.
- * @param deployer - The L1 deployer.
- * @param rollupAddress - The address of the rollup.
- * @param stakingAssetAddress - The address of the staking asset.
- * @param validators - The validators to initialize.
- * @param acceleratedTestDeployments - Whether to use accelerated test deployments.
- * @param logger - The logger.
- */ export const addMultipleValidators = async (extendedClient, deployer, gseAddress, rollupAddress, stakingAssetAddress, validators, acceleratedTestDeployments, logger)=>{
-    const rollup = new RollupContract(extendedClient, rollupAddress);
-    const activationThreshold = await rollup.getActivationThreshold();
-    if (validators && validators.length > 0) {
-        // Check if some of the initial validators are already registered, so we support idempotent deployments
-        if (!acceleratedTestDeployments) {
-            const enrichedValidators = await Promise.all(validators.map(async (operator)=>({
-                    operator,
-                    status: await rollup.getStatus(operator.attester)
-                })));
-            const existingValidators = enrichedValidators.filter((v)=>v.status !== 0);
-            if (existingValidators.length > 0) {
-                logger.warn(`Validators ${existingValidators.map((v)=>v.operator.attester).join(', ')} already exist. Skipping from initialization.`);
-            }
-            validators = enrichedValidators.filter((v)=>v.status === 0).map((v)=>v.operator);
-        }
-        if (validators.length > 0) {
-            const gseContract = new GSEContract(extendedClient, gseAddress);
-            const multiAdder = await deployer.deploy(MultiAdderArtifact, [
-                rollupAddress,
-                deployer.client.account.address
-            ]);
-            const makeValidatorTuples = async (validator)=>{
-                const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
-                return {
-                    attester: getAddress(validator.attester.toString()),
-                    withdrawer: getAddress(validator.withdrawer.toString()),
-                    ...registrationTuple
-                };
-            };
-            const validatorsTuples = await Promise.all(validators.map(makeValidatorTuples));
-            // Mint tokens, approve them, use cheat code to initialize validator set without setting up the epoch.
-            const stakeNeeded = activationThreshold * BigInt(validators.length);
-            await deployer.l1TxUtils.sendAndMonitorTransaction({
-                to: stakingAssetAddress,
-                data: encodeFunctionData({
-                    abi: StakingAssetArtifact.contractAbi,
-                    functionName: 'mint',
-                    args: [
-                        multiAdder.toString(),
-                        stakeNeeded
-                    ]
-                })
-            });
-            const entryQueueLengthBefore = await rollup.getEntryQueueLength();
-            const validatorCountBefore = await rollup.getActiveAttesterCount();
-            logger.info(`Adding ${validators.length} validators to the rollup`);
-            // Adding to the queue and flushing need to be done in two transactions
-            // if we are adding many validators.
-            if (validatorsTuples.length > 10) {
-                await deployer.l1TxUtils.sendAndMonitorTransaction({
-                    to: multiAdder.toString(),
-                    data: encodeFunctionData({
-                        abi: MultiAdderArtifact.contractAbi,
-                        functionName: 'addValidators',
-                        args: [
-                            validatorsTuples,
-                            true
-                        ]
-                    })
-                }, {
-                    gasLimit: 40_000_000n
-                });
-                await deployer.l1TxUtils.sendAndMonitorTransaction({
-                    to: rollupAddress,
-                    data: encodeFunctionData({
-                        abi: RollupArtifact.contractAbi,
-                        functionName: 'flushEntryQueue',
-                        args: []
-                    })
-                }, {
-                    gasLimit: 40_000_000n
-                });
-            } else {
-                await deployer.l1TxUtils.sendAndMonitorTransaction({
-                    to: multiAdder.toString(),
-                    data: encodeFunctionData({
-                        abi: MultiAdderArtifact.contractAbi,
-                        functionName: 'addValidators',
-                        args: [
-                            validatorsTuples,
-                            false
-                        ]
-                    })
-                }, {
-                    gasLimit: 45_000_000n
-                });
-            }
-            const entryQueueLengthAfter = await rollup.getEntryQueueLength();
-            const validatorCountAfter = await rollup.getActiveAttesterCount();
-            if (entryQueueLengthAfter + validatorCountAfter < entryQueueLengthBefore + validatorCountBefore + BigInt(validators.length)) {
-                throw new Error(`Failed to add ${validators.length} validators. Active validators: ${validatorCountBefore} -> ${validatorCountAfter}. Queue: ${entryQueueLengthBefore} -> ${entryQueueLengthAfter}`);
-            }
-            logger.info(`Added ${validators.length} validators. Active validators: ${validatorCountBefore} -> ${validatorCountAfter}. Queue: ${entryQueueLengthBefore} -> ${entryQueueLengthAfter}`);
-        }
-    }
-};
-/**
- * Initialize the fee asset handler and make it a minter on the fee asset.
- * @note This function will only be used for testing purposes.
- *
- * @param extendedClient - The L1 clients.
- * @param deployer - The L1 deployer.
- * @param feeAssetAddress - The address of the fee asset.
- * @param logger - The logger.
- */ // eslint-disable-next-line camelcase
-export const cheat_initializeFeeAssetHandler = async (extendedClient, deployer, feeAssetAddress, logger)=>{
-    const feeAssetHandlerAddress = await deployer.deploy(FeeAssetHandlerArtifact, [
-        extendedClient.account.address,
-        feeAssetAddress.toString(),
-        BigInt(1e18)
-    ]);
-    logger.verbose(`Deployed FeeAssetHandler at ${feeAssetHandlerAddress}`);
-    const { txHash } = await deployer.sendTransaction({
-        to: feeAssetAddress.toString(),
-        data: encodeFunctionData({
-            abi: FeeAssetArtifact.contractAbi,
-            functionName: 'addMinter',
-            args: [
-                feeAssetHandlerAddress.toString()
-            ]
-        })
-    });
-    logger.verbose(`Added fee asset handler ${feeAssetHandlerAddress} as minter on fee asset in ${txHash}`);
-    return {
-        feeAssetHandlerAddress,
-        txHash
-    };
-};
-/**
- * Deploys the aztec L1 contracts; Rollup & (optionally) Decoder Helper.
- * @param rpcUrls - List of URLs of the ETH RPC to use for deployment.
- * @param account - Private Key or HD Account that will deploy the contracts.
- * @param chain - The chain instance to deploy to.
- * @param logger - A logger object.
- * @param args - Arguments for initialization of L1 contracts
- * @returns A list of ETH addresses of the deployed contracts.
- */ export const deployL1Contracts = async (rpcUrls, account, chain, logger, args, txUtilsConfig = getL1TxUtilsConfigEnvVars(), createVerificationJson = false)=>{
-    logger.info(`Deploying L1 contracts with config: ${jsonStringify(args)}`);
-    validateConfig(args);
-    const l1Client = createExtendedL1Client(rpcUrls, account, chain);
-    // Deploy multicall3 if it does not exist in this network
-    await deployMulticall3(l1Client, logger);
-    // We are assuming that you are running this on a local anvil node which have 1s block times
-    // To align better with actual deployment, we update the block interval to 12s
-    const rpcCall = async (method, params)=>{
-        logger.info(`Calling ${method} with params: ${JSON.stringify(params)}`);
-        return await l1Client.transport.request({
-            method,
-            params
-        });
-    };
-    if (isAnvilTestChain(chain.id)) {
-        try {
-            await rpcCall('anvil_setBlockTimestampInterval', [
-                args.ethereumSlotDuration
-            ]);
-            logger.warn(`Set block interval to ${args.ethereumSlotDuration}`);
-        } catch (e) {
-            logger.error(`Error setting block interval: ${e}`);
-        }
-    }
-    logger.verbose(`Deploying contracts from ${account.address.toString()}`);
-    const dateProvider = new DateProvider();
-    const deployer = new L1Deployer(l1Client, args.salt, dateProvider, args.acceleratedTestDeployments, logger, txUtilsConfig, !!createVerificationJson);
-    const { feeAssetAddress, feeAssetHandlerAddress, stakingAssetAddress, stakingAssetHandlerAddress, registryAddress, gseAddress, governanceAddress, rewardDistributorAddress, zkPassportVerifierAddress, coinIssuerAddress } = await deploySharedContracts(l1Client, deployer, args, logger);
-    const { rollup, slashFactoryAddress } = await deployRollup(l1Client, deployer, args, {
-        feeJuiceAddress: feeAssetAddress,
-        registryAddress,
-        gseAddress,
-        rewardDistributorAddress,
-        stakingAssetAddress,
-        governanceAddress
-    }, logger);
-    logger.verbose('Waiting for rollup and slash factory to be deployed');
-    await deployer.waitForDeployments();
-    // Now that the rollup has been deployed and added to the registry, transfer ownership to governance
-    await handoverToGovernance(l1Client, deployer, registryAddress, gseAddress, coinIssuerAddress, feeAssetAddress, governanceAddress, logger, args.acceleratedTestDeployments);
-    logger.info(`Handing over to governance complete`);
-    logger.verbose(`All transactions for L1 deployment have been mined`);
-    const l1Contracts = await RegistryContract.collectAddresses(l1Client, registryAddress, 'canonical');
-    logger.info(`Aztec L1 contracts initialized`, l1Contracts);
-    // Write verification data (constructor args + linked libraries) to file for later forge verify
-    if (createVerificationJson) {
-        try {
-            // Add Inbox / Outbox verification records (constructor args are created inside RollupCore)
-            const rollupAddr = l1Contracts.rollupAddress.toString();
-            const inboxAddr = l1Contracts.inboxAddress.toString();
-            const outboxAddr = l1Contracts.outboxAddress.toString();
-            const feeAsset = l1Contracts.feeJuiceAddress.toString();
-            const version = await rollup.getVersion();
-            const inboxCtor = encodeAbiParameters([
-                {
-                    type: 'address'
-                },
-                {
-                    type: 'address'
-                },
-                {
-                    type: 'uint256'
-                },
-                {
-                    type: 'uint256'
-                }
-            ], [
-                rollupAddr,
-                feeAsset,
-                version,
-                BigInt(L1_TO_L2_MSG_SUBTREE_HEIGHT)
-            ]);
-            const outboxCtor = encodeAbiParameters([
-                {
-                    type: 'address'
-                },
-                {
-                    type: 'uint256'
-                }
-            ], [
-                rollupAddr,
-                version
-            ]);
-            deployer.verificationRecords.push({
-                name: 'Inbox',
-                address: inboxAddr,
-                constructorArgsHex: inboxCtor,
-                libraries: []
-            }, {
-                name: 'Outbox',
-                address: outboxAddr,
-                constructorArgsHex: outboxCtor,
-                libraries: []
-            });
-            // Include Slasher and SlashingProposer (if deployed) in verification data
-            try {
-                const slasherAddrHex = await rollup.getSlasher();
-                const slasherAddr = EthAddress.fromString(slasherAddrHex);
-                if (!slasherAddr.isZero()) {
-                    // Slasher constructor: (address _vetoer, address _governance)
-                    const slasherCtor = encodeAbiParameters([
-                        {
-                            type: 'address'
-                        },
-                        {
-                            type: 'address'
-                        }
-                    ], [
-                        args.slashingVetoer.toString(),
-                        l1Client.account.address
-                    ]);
-                    deployer.verificationRecords.push({
-                        name: 'Slasher',
-                        address: slasherAddr.toString(),
-                        constructorArgsHex: slasherCtor,
-                        libraries: []
-                    });
-                    // Proposer address is stored in Slasher.PROPOSER()
-                    const proposerAddr = (await rollup.getSlashingProposerAddress()).toString();
-                    // Compute constructor args matching deployment path in RollupCore
-                    const computedRoundSize = BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration);
-                    const computedQuorum = BigInt(args.slashingQuorum ?? args.slashingRoundSizeInEpochs * args.aztecEpochDuration / 2 + 1);
-                    const lifetimeInRounds = BigInt(args.slashingLifetimeInRounds);
-                    const executionDelayInRounds = BigInt(args.slashingExecutionDelayInRounds);
-                    if (args.slasherFlavor === 'tally') {
-                        const slashAmounts = [
-                            args.slashAmountSmall,
-                            args.slashAmountMedium,
-                            args.slashAmountLarge
-                        ];
-                        const committeeSize = BigInt(args.aztecTargetCommitteeSize);
-                        const epochDuration = BigInt(args.aztecEpochDuration);
-                        const slashOffsetInRounds = BigInt(args.slashingOffsetInRounds);
-                        const proposerCtor = encodeAbiParameters([
-                            {
-                                type: 'address'
-                            },
-                            {
-                                type: 'address'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256[3]'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            }
-                        ], [
-                            rollup.address,
-                            slasherAddr.toString(),
-                            computedQuorum,
-                            computedRoundSize,
-                            lifetimeInRounds,
-                            executionDelayInRounds,
-                            slashAmounts,
-                            committeeSize,
-                            epochDuration,
-                            slashOffsetInRounds
-                        ]);
-                        deployer.verificationRecords.push({
-                            name: 'TallySlashingProposer',
-                            address: proposerAddr,
-                            constructorArgsHex: proposerCtor,
-                            libraries: []
-                        });
-                    } else if (args.slasherFlavor === 'empire') {
-                        const proposerCtor = encodeAbiParameters([
-                            {
-                                type: 'address'
-                            },
-                            {
-                                type: 'address'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            },
-                            {
-                                type: 'uint256'
-                            }
-                        ], [
-                            rollup.address,
-                            slasherAddr.toString(),
-                            computedQuorum,
-                            computedRoundSize,
-                            lifetimeInRounds,
-                            executionDelayInRounds
-                        ]);
-                        deployer.verificationRecords.push({
-                            name: 'EmpireSlashingProposer',
-                            address: proposerAddr,
-                            constructorArgsHex: proposerCtor,
-                            libraries: []
-                        });
-                    }
-                }
-            } catch (e) {
-                logger.warn(`Failed to add Slasher/Proposer verification records: ${String(e)}`);
-            }
-            const date = new Date();
-            const formattedDate = date.toISOString().slice(2, 19).replace(/[-T:]/g, '');
-            // Ensure the verification output directory exists
-            await mkdir(createVerificationJson, {
-                recursive: true
-            });
-            const verificationOutputPath = `${createVerificationJson}/l1-verify-${chain.id}-${formattedDate.slice(0, 6)}-${formattedDate.slice(6)}.json`;
-            const verificationData = {
-                chainId: chain.id,
-                network: networkName,
-                records: deployer.verificationRecords
-            };
-            await writeFile(verificationOutputPath, JSON.stringify(verificationData, null, 2));
-            logger.info(`Wrote L1 verification data to ${verificationOutputPath}`);
-        } catch (e) {
-            logger.warn(`Failed to write L1 verification data file: ${String(e)}`);
-        }
-    }
-    if (isAnvilTestChain(chain.id)) {
-        // @note  We make a time jump PAST the very first slot to not have to deal with the edge case of the first slot.
-        //        The edge case being that the genesis block is already occupying slot 0, so we cannot have another block.
-        try {
-            // Need to get the time
-            const currentSlot = await rollup.getSlotNumber();
-            if (BigInt(currentSlot) === 0n) {
-                const ts = Number(await rollup.getTimestampForSlot(1n));
-                await rpcCall('evm_setNextBlockTimestamp', [
-                    ts
-                ]);
-                await rpcCall('hardhat_mine', [
-                    1
-                ]);
-                const currentSlot = await rollup.getSlotNumber();
-                if (BigInt(currentSlot) !== 1n) {
-                    throw new Error(`Error jumping time: current slot is ${currentSlot}`);
-                }
-                logger.info(`Jumped to slot 1`);
-            }
-        } catch (e) {
-            throw new Error(`Error jumping time: ${e}`);
-        }
-    }
-    return {
-        rollupVersion: Number(await rollup.getVersion()),
-        l1Client: l1Client,
-        l1ContractAddresses: {
-            ...l1Contracts,
-            slashFactoryAddress,
-            feeAssetHandlerAddress,
-            stakingAssetHandlerAddress,
-            zkPassportVerifierAddress,
-            coinIssuerAddress
-        }
-    };
-};
-export class L1Deployer {
-    client;
-    acceleratedTestDeployments;
-    logger;
-    txUtilsConfig;
-    createVerificationJson;
-    salt;
-    txHashes;
-    l1TxUtils;
-    verificationRecords;
-    constructor(client, maybeSalt, dateProvider = new DateProvider(), acceleratedTestDeployments = false, logger = createLogger('L1Deployer'), txUtilsConfig, createVerificationJson = false){
-        this.client = client;
-        this.acceleratedTestDeployments = acceleratedTestDeployments;
-        this.logger = logger;
-        this.txUtilsConfig = txUtilsConfig;
-        this.createVerificationJson = createVerificationJson;
-        this.txHashes = [];
-        this.verificationRecords = [];
-        this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), {
-            size: 32
-        }) : undefined;
-        this.l1TxUtils = createL1TxUtilsFromViemWallet(this.client, this.logger, dateProvider, this.txUtilsConfig, this.acceleratedTestDeployments);
-    }
-    async deploy(params, args, opts = {}) {
-        this.logger.debug(`Deploying ${params.name} contract`, {
-            args
-        });
-        try {
-            const { txHash, address, deployedLibraries } = await deployL1Contract(this.client, params.contractAbi, params.contractBytecode, args ?? [], {
-                salt: this.salt,
-                libraries: params.libraries,
-                logger: this.logger,
-                l1TxUtils: this.l1TxUtils,
-                acceleratedTestDeployments: this.acceleratedTestDeployments,
-                gasLimit: opts.gasLimit
-            });
-            if (txHash) {
-                this.txHashes.push(txHash);
-            }
-            this.logger.debug(`Deployed ${params.name} at ${address}`, {
-                args
-            });
-            if (this.createVerificationJson) {
-                // Encode constructor args for verification
-                let constructorArgsHex = '0x';
-                try {
-                    const abiItem = params.contractAbi.find((x)=>x && x.type === 'constructor');
-                    const inputDefs = abiItem && Array.isArray(abiItem.inputs) ? abiItem.inputs : [];
-                    constructorArgsHex = inputDefs.length > 0 ? encodeAbiParameters(inputDefs, args ?? []) : '0x';
-                } catch  {
-                    constructorArgsHex = '0x';
-                }
-                this.verificationRecords.push({
-                    name: params.name,
-                    address: address.toString(),
-                    constructorArgsHex,
-                    libraries: deployedLibraries ?? []
-                });
-            }
-            return address;
-        } catch (error) {
-            throw new Error(`Failed to deploy ${params.name}`, {
-                cause: formatViemError(error)
-            });
-        }
-    }
-    async waitForDeployments() {
-        if (this.acceleratedTestDeployments) {
-            this.logger.info('Accelerated test deployments - skipping waiting for deployments');
-            return;
-        }
-        if (this.txHashes.length === 0) {
-            return;
-        }
-        this.logger.verbose(`Waiting for ${this.txHashes.length} transactions to be mined`, {
-            txHashes: this.txHashes
-        });
-        const receipts = await Promise.all(this.txHashes.map((txHash)=>this.client.waitForTransactionReceipt({
-                hash: txHash
-            })));
-        const failed = receipts.filter((r)=>r.status !== 'success');
-        if (failed.length > 0) {
-            throw new Error(`Some deployment txs have failed: ${failed.map((f)=>f.transactionHash).join(', ')}`);
-        }
-        this.logger.info('All transactions mined successfully', {
-            txHashes: this.txHashes
-        });
-    }
-    sendTransaction(tx, options) {
-        return this.l1TxUtils.sendTransaction(tx, options);
-    }
-}
-// docs:start:deployL1Contract
-/**
- * Helper function to deploy ETH contracts.
- * @param walletClient - A viem WalletClient.
- * @param publicClient - A viem PublicClient.
- * @param abi - The ETH contract's ABI (as abitype's Abi).
- * @param bytecode  - The ETH contract's bytecode.
- * @param args - Constructor arguments for the contract.
- * @param salt - Optional salt for CREATE2 deployment (does not wait for deployment tx to be mined if set, does not send tx if contract already exists).
- * @returns The ETH address the contract was deployed to.
- */ export async function deployL1Contract(extendedClient, abi, bytecode, args = [], opts = {}) {
-    let txHash = undefined;
-    let resultingAddress = undefined;
-    const deployedLibraries = [];
-    const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments } = opts;
-    let { l1TxUtils } = opts;
-    if (!l1TxUtils) {
-        const config = getL1TxUtilsConfigEnvVars();
-        l1TxUtils = createL1TxUtilsFromViemWallet(extendedClient, logger, undefined, config, acceleratedTestDeployments);
-    }
-    if (libraries) {
-        // Note that this does NOT work well for linked libraries having linked libraries.
-        // Verify that all link references have corresponding code
-        for(const linkRef in libraries.linkReferences){
-            for(const contractName in libraries.linkReferences[linkRef]){
-                if (!libraries.libraryCode[contractName]) {
-                    throw new Error(`Missing library code for ${contractName}`);
-                }
-            }
-        }
-        const replacements = {};
-        const libraryTxs = [];
-        for(const libraryName in libraries?.libraryCode){
-            const lib = libraries.libraryCode[libraryName];
-            const { libraries: _libraries, ...optsWithoutLibraries } = opts;
-            const { address, txHash } = await deployL1Contract(extendedClient, lib.contractAbi, lib.contractBytecode, [], optsWithoutLibraries);
-            // Log deployed library name and address for easier verification/triage
-            logger?.verbose(`Linked library deployed`, {
-                library: libraryName,
-                address: address.toString(),
-                txHash
-            });
-            if (txHash) {
-                libraryTxs.push(txHash);
-            }
-            // Try to find the source file for this library from linkReferences
-            let fileNameForLibrary = undefined;
-            for(const fileName in libraries.linkReferences){
-                if (libraries.linkReferences[fileName] && libraries.linkReferences[fileName][libraryName]) {
-                    fileNameForLibrary = fileName;
-                    break;
-                }
-            }
-            if (fileNameForLibrary) {
-                deployedLibraries.push({
-                    file: fileNameForLibrary,
-                    contract: libraryName,
-                    address: address.toString()
-                });
-            }
-            for(const linkRef in libraries.linkReferences){
-                for(const contractName in libraries.linkReferences[linkRef]){
-                    // If the library name matches the one we just deployed, we replace it.
-                    if (contractName !== libraryName) {
-                        continue;
-                    }
-                    // We read the first instance to figure out what we are to replace.
-                    const start = 2 + 2 * libraries.linkReferences[linkRef][contractName][0].start;
-                    const length = 2 * libraries.linkReferences[linkRef][contractName][0].length;
-                    const toReplace = bytecode.slice(start, start + length);
-                    replacements[toReplace] = address;
-                }
-            }
-        }
-        const escapeRegExp = (s)=>{
-            return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special characters
-        };
-        for(const toReplace in replacements){
-            const replacement = replacements[toReplace].toString().slice(2);
-            bytecode = bytecode.replace(new RegExp(escapeRegExp(toReplace), 'g'), replacement);
-        }
-        // Reth fails gas estimation if the deployed contract attempts to call a library that is not yet deployed,
-        // so we wait for all library deployments to be mined before deploying the contract.
-        // However, if we are in fast mode or using debugMaxGasLimit, we will skip simulation, so we can skip waiting.
-        if (libraryTxs.length > 0 && !acceleratedTestDeployments) {
-            logger?.verbose(`Awaiting for linked libraries to be deployed`);
-            await Promise.all(libraryTxs.map((txHash)=>extendedClient.waitForTransactionReceipt({
-                    hash: txHash
-                })));
-        } else {
-            logger?.verbose(`Skipping waiting for linked libraries to be deployed ${acceleratedTestDeployments ? '(accelerated test deployments)' : ''}`);
-        }
-    }
-    if (saltFromOpts) {
-        logger?.info(`Deploying contract with salt ${saltFromOpts}`);
-        const { address, paddedSalt: salt, calldata } = getExpectedAddress(abi, bytecode, args, saltFromOpts);
-        resultingAddress = address;
-        const existing = await extendedClient.getCode({
-            address: resultingAddress
-        });
-        if (existing === undefined || existing === '0x') {
-            try {
-                await l1TxUtils.simulate({
-                    to: DEPLOYER_ADDRESS,
-                    data: concatHex([
-                        salt,
-                        calldata
-                    ])
-                }, {
-                    gasLimit
-                });
-            } catch (err) {
-                logger?.error(`Failed to simulate deployment tx using universal deployer`, err);
-                await l1TxUtils.simulate({
-                    to: null,
-                    data: encodeDeployData({
-                        abi,
-                        bytecode,
-                        args
-                    })
-                });
-            }
-            const res = await l1TxUtils.sendTransaction({
-                to: DEPLOYER_ADDRESS,
-                data: concatHex([
-                    salt,
-                    calldata
-                ])
-            }, {
-                gasLimit
-            });
-            txHash = res.txHash;
-            logger?.verbose(`Deployed contract with salt ${salt} to address ${resultingAddress} in tx ${txHash}.`);
-        } else {
-            logger?.verbose(`Skipping existing deployment of contract with salt ${salt} to address ${resultingAddress}`);
-        }
-    } else {
-        const deployData = encodeDeployData({
-            abi,
-            bytecode,
-            args
-        });
-        const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
-            to: null,
-            data: deployData
-        });
-        txHash = receipt.transactionHash;
-        resultingAddress = receipt.contractAddress;
-        if (!resultingAddress) {
-            throw new Error(`No contract address found in receipt: ${JSON.stringify(receipt, (_, val)=>typeof val === 'bigint' ? String(val) : val)}`);
-        }
-    }
-    return {
-        address: EthAddress.fromString(resultingAddress),
-        txHash,
-        deployedLibraries
-    };
-}
-export function getExpectedAddress(abi, bytecode, args, salt) {
-    const paddedSalt = padHex(salt, {
-        size: 32
-    });
-    const calldata = encodeDeployData({
-        abi,
-        bytecode,
-        args
-    });
-    const address = getContractAddress({
-        from: DEPLOYER_ADDRESS,
-        salt: paddedSalt,
-        bytecode: calldata,
-        opcode: 'CREATE2'
-    });
-    return {
-        address,
-        paddedSalt,
-        calldata
-    };
-} // docs:end:deployL1Contract