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

package/dest/deploy_l1_contracts.js

@@ -1,10 +1,12 @@
+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 { concatHex, encodeDeployData, encodeFunctionData, getAddress, getContract, getContractAddress, numberToHex, padHex } from 'viem';
+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';
@@ -98,35 +100,12 @@ export const deploySharedContracts = async (l1Client, deployer, args, logger)=>{
     }
     const coinIssuerAddress = await deployer.deploy(CoinIssuerArtifact, [
         feeAssetAddress.toString(),
-        1n * 10n ** 18n,
-        governanceAddress.toString()
+        1_000_000n * 10n ** 18n,
+        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 = undefined;
     let stakingAssetHandlerAddress = undefined;
@@ -136,21 +115,24 @@ export const deploySharedContracts = async (l1Client, deployer, args, logger)=>{
         /* -------------------------------------------------------------------------- */ /*                          CHEAT CODES START HERE                            */ /* -------------------------------------------------------------------------- */ feeAssetHandlerAddress = await deployer.deploy(FeeAssetHandlerArtifact, [
             l1Client.account.address,
             feeAssetAddress.toString(),
-            BigInt(1e18)
+            BigInt(1000n * 10n ** 18n)
         ]);
         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}`);
-        txHashes.push(txHash);
+        // 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 ([
@@ -458,6 +440,23 @@ function slasherFlavorToSolidityEnum(flavor) {
     ])) {
         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
@@ -468,7 +467,7 @@ function slasherFlavorToSolidityEnum(flavor) {
         slashFactoryAddress
     };
 };
-export const handoverToGovernance = async (extendedClient, deployer, registryAddress, gseAddress, governanceAddress, logger, acceleratedTestDeployments)=>{
+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()),
@@ -480,6 +479,16 @@ export const handoverToGovernance = async (extendedClient, deployer, registryAdd
         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())) {
@@ -513,6 +522,48 @@ export const handoverToGovernance = async (extendedClient, deployer, registryAdd
         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({
@@ -576,18 +627,47 @@ export const handoverToGovernance = async (extendedClient, deployer, registryAdd
             const entryQueueLengthBefore = await rollup.getEntryQueueLength();
             const validatorCountBefore = await rollup.getActiveAttesterCount();
             logger.info(`Adding ${validators.length} validators to the rollup`);
-            await deployer.l1TxUtils.sendAndMonitorTransaction({
-                to: multiAdder.toString(),
-                data: encodeFunctionData({
-                    abi: MultiAdderArtifact.contractAbi,
-                    functionName: 'addValidators',
-                    args: [
-                        validatorsTuples
-                    ]
-                })
-            }, {
-                gasLimit: 45_000_000n
-            });
+            // 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)) {
@@ -637,7 +717,8 @@ export const cheat_initializeFeeAssetHandler = async (extendedClient, deployer,
  * @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())=>{
+ */ 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
@@ -663,23 +744,219 @@ export const cheat_initializeFeeAssetHandler = async (extendedClient, deployer,
     }
     logger.verbose(`Deploying contracts from ${account.address.toString()}`);
     const dateProvider = new DateProvider();
-    const deployer = new L1Deployer(l1Client, args.salt, dateProvider, args.acceleratedTestDeployments, logger, txUtilsConfig);
-    const { feeAssetAddress, feeAssetHandlerAddress, stakingAssetAddress, stakingAssetHandlerAddress, registryAddress, gseAddress, governanceAddress, rewardDistributorAddress, zkPassportVerifierAddress } = await deploySharedContracts(l1Client, deployer, args, logger);
+    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
+        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, governanceAddress, logger, args.acceleratedTestDeployments);
+    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.
@@ -712,7 +989,8 @@ export const cheat_initializeFeeAssetHandler = async (extendedClient, deployer,
             slashFactoryAddress,
             feeAssetHandlerAddress,
             stakingAssetHandlerAddress,
-            zkPassportVerifierAddress
+            zkPassportVerifierAddress,
+            coinIssuerAddress
         }
     };
 };
@@ -721,15 +999,19 @@ export class L1Deployer {
     acceleratedTestDeployments;
     logger;
     txUtilsConfig;
+    createVerificationJson;
     salt;
     txHashes;
     l1TxUtils;
-    constructor(client, maybeSalt, dateProvider = new DateProvider(), acceleratedTestDeployments = false, logger = createLogger('L1Deployer'), txUtilsConfig){
+    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;
@@ -740,7 +1022,7 @@ export class L1Deployer {
             args
         });
         try {
-            const { txHash, address } = await deployL1Contract(this.client, params.contractAbi, params.contractBytecode, args ?? [], {
+            const { txHash, address, deployedLibraries } = await deployL1Contract(this.client, params.contractAbi, params.contractBytecode, args ?? [], {
                 salt: this.salt,
                 libraries: params.libraries,
                 logger: this.logger,
@@ -754,6 +1036,23 @@ export class L1Deployer {
             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}`, {
@@ -800,6 +1099,7 @@ export class L1Deployer {
  */ 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) {
@@ -822,9 +1122,30 @@ export class L1Deployer {
             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.
@@ -919,7 +1240,8 @@ export class L1Deployer {
     }
     return {
         address: EthAddress.fromString(resultingAddress),
-        txHash
+        txHash,
+        deployedLibraries
     };
 }
 export function getExpectedAddress(abi, bytecode, args, salt) {