feat: deploy method refactor 2 (#23033)

## Summary

Splits `DeployMethod` into an abstract umbrella type plus three concrete
flavors that encode the deployer-lock state at the type level instead of
branching on a nullable field.

- `DeployMethod<T>` — abstract base, the type consumers use generically
(`let d: DeployMethod<MyContract> = ...`).
- `BoundDeployMethod` — locked to a concrete `deployer`.
- `UniversalDeployMethod` — locked to `AztecAddress.ZERO` (any sender).
- `PendingDeployMethod` — promotes into a `Bound`/`Universal` sibling on
the first `send` / `simulate` / `profile` call.

The three flavor-specific decisions (`getDeployerAddress`,
`lockOrAssertDeployer`, `cloneInstantiation`) are now abstract methods
rather than `if (this.deployer === undefined / equals(ZERO) / else)`
branches in the base.

## Compile-time guarantees

Each subclass takes a narrowed instantiation type:

- `BoundInstantiationOptions` — `deployer` required, `universalDeploy:
never`.
- `UniversalInstantiationOptions` — `universalDeploy: true` required,
`deployer: never`.
- `PendingInstantiationOptions` — both `never`.

`new BoundDeployMethod(..., { universalDeploy: true })` is now a
TypeScript error. The runtime mutual-exclusion checks in subclass
constructors are gone; the only runtime guard left is
`BoundDeployMethod` rejecting `AztecAddress.ZERO` (a value-level
invariant the type system can't model).

## Constructor shape

Subclass constructors take named bundles instead of 9 positionals:

```ts
new BoundDeployMethod(wallet, contract, instantiation, payload?)
//                            ^               ^             ^
//   { artifact, postDeployCtor, args, constructorNameOrArtifact }
//                            { salt, publicKeys, deployer }
//                            { authWitnesses, capsules, extraHashedArgs }
```

`DeployMethod.create` follows the same shape. `Contract.deploy(wallet,
artifact, args, constructorName, instantiation)` and
`MyContract.deploy(wallet, ...args, instantiation?)` (codegen) are
**unchanged** — the bundle reshape stops at the `create` boundary.

## Other changes

- `DeployAccountMethod` now extends `UniversalDeployMethod` (account
contracts are always universal).

Author: Thunkar

playground/src/components/contract/components/CreateContractDialog.tsx

@@ -115,11 +115,16 @@ export function CreateContractDialog({
       if (publiclyDeploy) {
         const postDeployCtor = (instance: ContractInstanceWithAddress, wallet: Wallet) =>
           Contract.at(instance.address, contractArtifact, wallet);
-        deployMethod = new DeployMethod(wallet, contractArtifact, postDeployCtor, parameters, initializer?.name, {
-          publicKeys: contract.publicKeys,
-          salt: contract.salt,
-          deployer: from,
-        });
+        deployMethod = DeployMethod.create(
+          wallet,
+          {
+            artifact: contractArtifact,
+            postDeployCtor,
+            args: parameters,
+            constructorNameOrArtifact: initializer?.name,
+          },
+          { publicKeys: contract.publicKeys, salt: contract.salt, deployer: from },
+        );
         opts = {
           from,
           fee: { paymentMethod: feePaymentMethod },

yarn-project/aztec.js/src/api/contract.ts

@@ -71,6 +71,7 @@ export {
   DeployMethod,
   type RequestDeployOptions,
   type SimulateDeployOptions,
+  UniversalDeployMethod,
 } from '../contract/deploy_method.js';
 export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
 export { getGasLimits } from '../contract/get_gas_limits.js';

yarn-project/aztec.js/src/contract/contract.ts

@@ -43,6 +43,10 @@ export class Contract extends ContractBase {
   ) {
     const postDeployCtor = (instance: ContractInstanceWithAddress, wallet: Wallet) =>
       Contract.at(instance.address, artifact, wallet);
-    return new DeployMethod(wallet, artifact, postDeployCtor, args, constructorName, instantiation);
+    return DeployMethod.create(
+      wallet,
+      { artifact, postDeployCtor, args, constructorNameOrArtifact: constructorName },
+      instantiation,
+    );
   }
 }

yarn-project/aztec.js/src/contract/deploy_method.test.ts

@@ -14,7 +14,6 @@ import { NO_FROM } from './interaction_options.js';
 
 describe('DeployMethod', () => {
   let wallet: MockProxy<Wallet>;
-
   beforeEach(() => {
     wallet = mock<Wallet>();
     wallet.registerContract.mockResolvedValue({} as ContractInstanceWithAddress);
@@ -27,14 +26,10 @@ describe('DeployMethod', () => {
     const txSimResult = mock<TxSimulationResultWithAppOffset>();
     Object.defineProperty(txSimResult, 'offchainEffects', { value: offchainEffects });
     Object.defineProperty(txSimResult, 'publicInputs', {
-      value: {
-        constants: { anchorBlockHeader: { globalVariables: { timestamp: anchorBlockTimestamp } } },
-      },
+      value: { constants: { anchorBlockHeader: { globalVariables: { timestamp: anchorBlockTimestamp } } } },
     });
     Object.defineProperty(txSimResult, 'stats', { value: {} });
-    Object.defineProperty(txSimResult, 'gasUsed', {
-      value: { totalGas: Gas.empty(), teardownGas: Gas.empty() },
-    });
+    Object.defineProperty(txSimResult, 'gasUsed', { value: { totalGas: Gas.empty(), teardownGas: Gas.empty() } });
     return txSimResult;
   };
 
@@ -43,19 +38,12 @@ describe('DeployMethod', () => {
     const contractAddress = await AztecAddress.random();
     const msgPayload = [Fr.random(), Fr.random()];
     const anchorBlockTimestamp = 42000n;
-
     const offchainEffects: OffchainEffect[] = [
-      {
-        data: [OFFCHAIN_MESSAGE_IDENTIFIER, recipient.toField(), ...msgPayload],
-        contractAddress,
-      },
+      { data: [OFFCHAIN_MESSAGE_IDENTIFIER, recipient.toField(), ...msgPayload], contractAddress },
     ];
-
     wallet.simulateTx.mockResolvedValue(makeSimulateResult(offchainEffects, anchorBlockTimestamp));
-
     const deploy = Contract.deploy(wallet, testContractArtifact, []);
     const result = await deploy.simulate({ from: await AztecAddress.random() });
-
     expect(result.offchainMessages).toHaveLength(1);
     expect(result.offchainMessages[0]).toEqual({
       recipient,
@@ -112,15 +100,11 @@ describe('DeployMethod', () => {
 
     it('keeps the address stable across simulate then send when lazy-locking from `from`', async () => {
       const deploy = Contract.deploy(wallet, testContractArtifact, [], undefined, { salt });
-
       const expected = await expectedAddress(alice);
-
       await deploy.simulate({ from: alice });
       const afterSimulate = await deploy.getAddress();
-
       await deploy.send({ from: alice });
       const afterSend = await deploy.getAddress();
-
       expect(afterSimulate).toEqual(afterSend);
       expect(afterSimulate).toEqual(expected);
     });
@@ -147,7 +131,6 @@ describe('DeployMethod', () => {
     it('allows any sender when locked to universal at construction, and the address is stable', async () => {
       const deploy = Contract.deploy(wallet, testContractArtifact, [], undefined, { salt, universalDeploy: true });
       const expected = await expectedAddress(AztecAddress.ZERO);
-
       await expect(deploy.send({ from: alice })).resolves.toBeDefined();
       expect(await deploy.getAddress()).toEqual(expected);
       await expect(deploy.send({ from: bob })).resolves.toBeDefined();