Contract addresses change across toolchain upgrades due to artifact drift

[infrmtcs]

What are you trying to do?

Use a previously deployed contract after upgrading the Aztec toolchain version.

Current Behavior

When the Aztec toolchain is upgraded, the Noir compiler produces different artifacts for the same contract source code. This leads to a cascading mismatch:

1. Different artifact → different contract class ID
2. Different contract class ID → different partial address
3. Different partial address → different complete address

Since APIs like wallet.createSchnorrAccount always resolve to the latest bundled artifact, they compute a different address for the same inputs on the same network. This means:

• The wallet can no longer match the contract originally deployed on-chain
• Transaction building fails because the computed address doesn't correspond to any deployed contract
• Users effectively lose access to their accounts after a toolchain upgrade

This affects any contract whose artifact is bundled with the toolchain — account contracts (e.g., Schnorr), token contracts, etc.

Steps to Reproduce

1. Deploy a contract (e.g., a Schnorr account) using toolchain version A
2. Upgrade the Aztec toolchain to version B
3. Instantiate the same contract with the same inputs (e.g., wallet.createSchnorrAccount with the same secret key)
4. Observe that the resolved complete address differs from the one deployed in step 1
5. Attempting to build transactions against this contract fails

Questions

• Is there a recommended way to handle contracts deployed with a previous toolchain version?
• Should artifact stability across compiler versions be a guarantee, or is this expected to break?
• What is the intended migration path for users/applications when the toolchain is upgraded?

[shiqicao]

Should artifact stability across compiler versions be a guarantee, or is this expected to break?

This is by design, given contract class id and address is derived from contract artifact. Noir compiler is evolving and no guarantee that same noir code always produces the same circuit. For example compiler can optimize gates generation very new release, just like your Rust compiler doesn't promise same native code.

Is there a recommended way to handle contracts deployed with a previous toolchain version?

Artifacts should be kept along with noir code, even record toolchain version, the most extreme action is to even clone the toolchain repo.

What is the intended migration path for users/applications when the toolchain is upgraded?

Users/App shouldn't be re-built with updated toolchain, deployed contract should always use committed artifacts.

[TomAFrench]

Yes, this is correct. We don't expect the same ACIR to be produced when compiling the same noir source using different versions of the noir compiler as we add more optimizations/fixes. I'd recommend pinning your artifacts if you have a deployed circuit/contract which you need to work with.