[Deployment] Where arefactory_deps stored when deployed as a contract?

[PatrickAlphaC]

Environment

Mainnet

zkSolc Version

N/A

zksync-ethers Version

N/A

Hardhat.config.ts

N/A

Deployment Script (WITHOUT PRIVATE KEY)

N/A

Package.json

N/A

Contract Code

N/A

Does this work on other EVMs? (If yes, please list at least 1 of them)

N/A

Description of What Your Contract Does

N/A

Repo Link (Optional)

No response

Additional Details

When a user deploys a smart contract the docs say that the smart contract is deployed to the L1

However, for contract deployment to succeed, the operator needs to know the bytecode. The factory_deps field of the transaction is used for this reason: it contains the bytecodes that should be known to the operator for this transaction to succeed. Once the transaction succeeds, these bytecodes are published on L1 and are considered "known" to the operator forever.

On zkSync, factories (i.e. contracts that can deploy other contracts) do not store bytecodes of their dependencies, i.e. contracts that they can deploy. They only store their hashes. That's why you need to include all the bytecodes of the dependencies in the factory_deps field.

So a few questions:

1. Where are these hashes stored?
2. Where is an example transaction that deploys this contract to the L1? Can we see an example flow?

[PatrickAlphaC]

I got it.

1. Where are these hashes stored?

There is a contract called KnownCodeStorage that keeps track of all the hashes. When you look to deploy a smart contract, the ContractDeployer contract checks this contract to see if a contract has been deployed. This means this contract must keep track of every single contract ever deployed on zkSync.

You'd think contract verification would, therefore, be easier.

2. Where is an example transaction that deploys this contract to the L1? Can we see an example flow?

https://sepolia.explorer.zksync.io/tx/0x34d82e834be6c0bdfe0a5fa8a6d0ada8232494f76ee1b0a438092a5b3a11aba0

This transaction deploys a zkSync minimal account abstraction account. You can see in the logs it emits and event called L1MessageSent , with a huuuggeeeee message. The message is the bytecode of the contract. Now this data is not stored on zkSync itself, only it's hash. If you were to deploy this same contract again to zkSync, you'd get fewer logs, because since the hash is known, it wouldn't re-deploy the bytecode to the L1.

I guess the part that I'm confused on now, is the transaction life cycle.

This leads to this question:

Is a zkSync node reading the contract data from the L1 in order to process a transaction?

[bxpana]

Correction:
No, the L2 nodes cache the address’s bytecode and stores it as a hash at that address in the account code storage contract to prevent the wrong bytecode from being run

[PatrickAlphaC]

So is it cacheing _every single address bytecode_ then? If I make a TX for a contract the node didn't deploy, it would have to read from the L1 yes?