@aztec/cli-wallet 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

package/dest/utils/wallet.js

@@ -1,31 +1,59 @@
-import { EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
-import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
-import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { EcdsaKAccountContract, EcdsaRAccountContract, EcdsaRSSHAccountContract } from '@aztec/accounts/ecdsa';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/ecdsa/stub';
+import { SchnorrAccountContract, SchnorrInitializerlessAccountContract } from '@aztec/accounts/schnorr';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/schnorr/stub';
 import { getIdentities } from '@aztec/accounts/utils';
 import { NO_FROM } from '@aztec/aztec.js/account';
-import { getContractInstanceFromInstantiationParams, getGasLimits } from '@aztec/aztec.js/contracts';
+import { ContractFunctionInteraction, getContractClassFromArtifact } from '@aztec/aztec.js/contracts';
 import { AccountManager } from '@aztec/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
 import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createPXE, getPXEConfig } from '@aztec/pxe/server';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
-import { BaseWallet } from '@aztec/wallet-sdk/base-wallet';
+import { BaseWallet, getGasLimits } from '@aztec/wallet-sdk/base-wallet';
 import { extractECDSAPublicKeyFromBase64String } from './ecdsa.js';
-import { printGasEstimates } from './options/fees.js';
+/** Padding the CLI wallet applies to simulated gas usage when deriving declared gas limits. */ const DEFAULT_ESTIMATED_GAS_PADDING = 0.1;
 export class CLIWallet extends BaseWallet {
     userLog;
     db;
     accountCache;
+    // Stub class ids, populated on wallet startup
+    // to avoid redundant work per simulation
+    stubClassIds;
     constructor(pxe, node, userLog, db){
-        super(pxe, node), this.userLog = userLog, this.db = db, this.accountCache = new Map();
+        super(pxe, node), this.userLog = userLog, this.db = db, this.accountCache = new Map(), this.stubClassIds = new Map();
         this.cancellableTransactions = true;
     }
     static async create(node, log, db, overridePXEConfig) {
         const pxeConfig = Object.assign(getPXEConfig(), overridePXEConfig);
         const pxe = await createPXE(node, pxeConfig);
-        return new CLIWallet(pxe, node, log, db);
+        const wallet = new CLIWallet(pxe, node, log, db);
+        await wallet.initStubClasses();
+        await wallet.registerAuthRegistry();
+        return wallet;
+    }
+    async registerAuthRegistry() {
+        const { instance, artifact } = await getStandardAuthRegistry();
+        await this.pxe.registerContractClass(artifact);
+        await this.pxe.registerContract(instance);
+    }
+    /**
+   * Hashes and registers the stub class for every supported account type with PXE, populating
+   * stubClassIds. Called on wallet initialization.
+   */ async initStubClasses() {
+        const { id: schnorrClassId } = await getContractClassFromArtifact(StubSchnorrAccountContractArtifact);
+        await this.pxe.registerContractClass(StubSchnorrAccountContractArtifact);
+        // ecdsa stubs share the same class id
+        const { id: ecdsaClassId } = await getContractClassFromArtifact(StubEcdsaAccountContractArtifact);
+        await this.pxe.registerContractClass(StubEcdsaAccountContractArtifact);
+        this.stubClassIds.set('schnorr', schnorrClassId);
+        this.stubClassIds.set('schnorr_initializerless', schnorrClassId);
+        this.stubClassIds.set('ecdsasecp256k1', ecdsaClassId);
+        this.stubClassIds.set('ecdsasecp256r1', ecdsaClassId);
+        this.stubClassIds.set('ecdsasecp256r1ssh', ecdsaClassId);
     }
     async getAccounts() {
         const accounts = await this.db?.listAliases('accounts') ?? [];
@@ -33,13 +61,25 @@ export class CLIWallet extends BaseWallet {
             const alias = key.includes(':') ? key.slice(key.indexOf(':') + 1) : key;
             return {
                 alias,
-                item: AztecAddress.fromString(value)
+                item: AztecAddress.fromStringUnsafe(value)
             };
         }));
     }
+    /**
+   * Derives suggested total and teardown gas limits from simulated gas usage, padded and clamped to the
+   * network's per-tx admission limits.
+   * @param gasUsed - The gas consumed during simulation (from a `simulate({ includeMetadata: true })` result).
+   */ async estimateGasLimits(gasUsed) {
+        const maxTxGasLimits = await this.getMaxTxGasLimits();
+        return getGasLimits(gasUsed, maxTxGasLimits, DEFAULT_ESTIMATED_GAS_PADDING);
+    }
     async createCancellationTxExecutionRequest(from, txNonce, increasedFee) {
         const executionPayload = ExecutionPayload.empty();
-        const feeOptions = await this.completeFeeOptions(from, executionPayload.feePayer, increasedFee.gasSettings);
+        const feeOptions = await this.completeFeeOptions({
+            from,
+            feePayer: executionPayload.feePayer,
+            gasSettings: increasedFee.gasSettings
+        });
         const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
         const fromAccount = await this.getAccountFromAddress(from);
         const chainInfo = await this.getChainInfo();
@@ -53,14 +93,17 @@ export class CLIWallet extends BaseWallet {
     }
     async proveCancellationTx(from, txNonce, increasedFee) {
         const cancellationTxRequest = await this.createCancellationTxExecutionRequest(from, txNonce, increasedFee);
-        return await this.pxe.proveTx(cancellationTxRequest, this.scopesFrom(from));
+        return await this.pxe.proveTx(cancellationTxRequest, {
+            scopes: this.scopesFrom(from, [], undefined),
+            senderForTags: from
+        });
     }
     async getAccountFromAddress(address) {
         let account;
         if (this.accountCache.has(address.toString())) {
             return this.accountCache.get(address.toString());
         } else {
-            const accountManager = await this.createOrRetrieveAccount(address);
+            const accountManager = await this.retrieveAccount(address);
             account = await accountManager.getAccount();
         }
         if (!account) {
@@ -68,58 +111,89 @@ export class CLIWallet extends BaseWallet {
         }
         return account;
     }
-    async createAccount(secret, salt, contract) {
-        const accountManager = await AccountManager.create(this, secret, contract, salt);
-        const instance = accountManager.getInstance();
-        const artifact = await contract.getContractArtifact();
-        await this.registerContract(instance, artifact, secret);
-        this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
-        return accountManager;
+    /**
+   * Creates an account from freshly supplied keys. SSH accounts sign with a key held in the agent (resolved from
+   * `publicKey`), every other type is rooted on `signingKey`, with `secretKey` as its privacy secret.
+   */ async createAccount(type, signingKey, secretKey, salt = Fr.ZERO, publicKey) {
+        const publicSigningKey = type === 'ecdsasecp256r1ssh' ? await this.resolveSshPublicSigningKey(publicKey) : undefined;
+        return this.buildAccount(type, salt, signingKey, secretKey, publicSigningKey);
     }
-    async createOrRetrieveAccount(address, secretKey, type = 'schnorr', salt, publicKey) {
-        let account;
-        salt ??= Fr.ZERO;
-        if (this.db && address) {
-            ({ type, secretKey, salt } = await this.db.retrieveAccount(address));
+    /**
+   * Retrieves a previously stored account by address, loading its keys, type and salt from the wallet database.
+   */ async retrieveAccount(address) {
+        if (!this.db) {
+            throw new Error('Cannot retrieve an account without a wallet database');
         }
-        if (!secretKey) {
-            throw new Error('Cannot retrieve/create wallet without secret key');
+        const { type, signingKey, secretKey, salt } = await this.db.retrieveAccount(address);
+        if (type !== 'ecdsasecp256r1ssh' && !signingKey) {
+            throw new Error(`Account ${address} has no stored signing key: it was created with an older version of aztec-wallet and is ` + `incompatible with this one. Create a new account to continue.`);
         }
+        const publicSigningKey = type === 'ecdsasecp256r1ssh' ? await this.db.retrieveAccountMetadata(address, 'publicSigningKey') : undefined;
+        return this.buildAccount(type, salt, signingKey, secretKey, publicSigningKey);
+    }
+    async buildAccount(type, salt, signingKey, secretKey, publicSigningKey) {
         switch(type){
             case 'schnorr':
-                {
-                    account = await this.createAccount(secretKey, salt, new SchnorrAccountContract(deriveSigningKey(secretKey)));
-                    break;
-                }
+            case 'schnorr_initializerless':
             case 'ecdsasecp256r1':
+            case 'ecdsasecp256k1':
                 {
-                    account = await this.createAccount(secretKey, salt, new EcdsaRAccountContract(deriveSigningKey(secretKey).toBuffer()));
-                    break;
+                    if (!signingKey || !secretKey) {
+                        throw new Error('Cannot build account without signing key and secret key');
+                    }
+                    const contract = type === 'schnorr' ? new SchnorrAccountContract(signingKey) : type === 'schnorr_initializerless' ? new SchnorrInitializerlessAccountContract(signingKey) : type === 'ecdsasecp256r1' ? new EcdsaRAccountContract(signingKey.toBuffer()) : new EcdsaKAccountContract(signingKey.toBuffer());
+                    return await this.materializeAccount(secretKey, salt, contract);
                 }
             case 'ecdsasecp256r1ssh':
                 {
-                    let publicSigningKey;
-                    if (this.db && address) {
-                        publicSigningKey = await this.db.retrieveAccountMetadata(address, 'publicSigningKey');
-                    } else if (publicKey) {
-                        const identities = await getIdentities();
-                        const foundIdentity = identities.find((identity)=>identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey);
-                        if (!foundIdentity) {
-                            throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
-                        }
-                        publicSigningKey = extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
-                    } else {
-                        throw new Error('Public key must be provided for ECDSA SSH account');
+                    if (!secretKey || !publicSigningKey) {
+                        throw new Error('Cannot build SSH account without secret key and public signing key');
                     }
-                    account = await this.createAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
-                    break;
+                    return await this.materializeAccount(secretKey, salt, new EcdsaRSSHAccountContract(publicSigningKey));
                 }
             default:
                 {
                     throw new Error(`Unsupported account type: ${type}`);
                 }
         }
-        return account;
+    }
+    async resolveSshPublicSigningKey(publicKey) {
+        if (!publicKey) {
+            throw new Error('Public key must be provided for ECDSA SSH account');
+        }
+        const identities = await getIdentities();
+        const foundIdentity = identities.find((identity)=>identity.type === 'ecdsa-sha2-nistp256' && identity.publicKey === publicKey);
+        if (!foundIdentity) {
+            throw new Error(`Identity for public key ${publicKey} not found in the SSH agent`);
+        }
+        return extractECDSAPublicKeyFromBase64String(foundIdentity.publicKey);
+    }
+    async materializeAccount(secret, salt, contract) {
+        const accountManager = await AccountManager.create(this, secret, contract, {
+            salt
+        });
+        const instance = accountManager.getInstance();
+        const artifact = await contract.getContractArtifact();
+        await this.registerContract(instance, artifact, secret);
+        this.accountCache.set(accountManager.address.toString(), await accountManager.getAccount());
+        // Initializerless accounts have no deployment tx; their address commits to the signing public key
+        // (via the contract's immutablesHash, resolved by AccountManager.create) and the constructor's
+        // storage writes are materialized locally via a simulated "store" call here.
+        if (contract instanceof SchnorrInitializerlessAccountContract) {
+            const constructorAbi = artifact.functions.find((f)=>f.name === 'constructor');
+            if (!constructorAbi) {
+                throw new Error('Could not create SchnorrInitializerlessAccount: constructor ABI not found');
+            }
+            const { x, y } = await contract.getSigningPublicKey();
+            const storeCall = new ContractFunctionInteraction(this, instance.address, constructorAbi, [
+                x,
+                y
+            ]);
+            await storeCall.simulate({
+                from: instance.address
+            });
+        }
+        return accountManager;
     }
     /**
    * Creates a stub account that impersonates the given address, allowing kernelless simulations
@@ -133,30 +207,27 @@ export class CLIWallet extends BaseWallet {
         if (!contractInstance) {
             throw new Error(`No contract instance found for address: ${originalAddress.address}`);
         }
-        const stubAccount = createStubAccount(originalAddress);
-        const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
-            salt: Fr.random()
-        });
+        const { type } = await this.db.retrieveAccount(address);
+        const stubAccount = type === 'schnorr' || type === 'schnorr_initializerless' ? createStubSchnorrAccount(originalAddress) : createStubEcdsaAccount(originalAddress);
+        const stubClassId = this.stubClassIds.get(type);
+        if (!stubClassId) {
+            throw new Error(`Stub class for account type '${type}' was not registered at wallet init. This is a bug — initStubClasses should cover every supported AccountType.`);
+        }
+        const instance = {
+            ...contractInstance,
+            currentContractClassId: stubClassId
+        };
         return {
             account: stubAccount,
-            instance,
-            artifact: StubAccountContractArtifact
+            instance
         };
     }
-    async simulateTx(executionPayload, opts) {
-        const simulationResults = await super.simulateTx(executionPayload, opts);
-        if (opts.fee?.estimateGas) {
-            const feeOptions = await this.completeFeeOptions(opts.from, executionPayload.feePayer, opts.fee?.gasSettings);
-            const limits = getGasLimits(simulationResults, opts.fee?.estimatedGasPadding);
-            printGasEstimates(feeOptions, limits, this.userLog);
-        }
-        return simulationResults;
-    }
     /**
    * Uses a stub account for kernelless simulation, bypassing real account authorization.
    * Uses DefaultEntrypoint directly for NO_FROM transactions.
    */ async simulateViaEntrypoint(executionPayload, opts) {
-        const { from, feeOptions, scopes } = opts;
+        const { from, feeOptions, additionalScopes, sendMessagesAs } = opts;
+        const scopes = this.scopesFrom(from, additionalScopes ?? [], sendMessagesAs);
         const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
         const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
             feeExecutionPayload,
@@ -169,12 +240,11 @@ export class CLIWallet extends BaseWallet {
             const entrypoint = new DefaultEntrypoint();
             txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
         } else {
-            const { account, instance, artifact } = await this.getFakeAccountDataFor(from);
+            const { account, instance } = await this.getFakeAccountDataFor(from);
             overrides = {
                 contracts: {
                     [from.toString()]: {
-                        instance,
-                        artifact
+                        instance
                     }
                 }
             };
@@ -186,13 +256,16 @@ export class CLIWallet extends BaseWallet {
             };
             txRequest = await account.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
         }
-        return this.pxe.simulateTx(txRequest, {
+        const result = await this.pxe.simulateTx(txRequest, {
             simulatePublic: true,
             skipFeeEnforcement: true,
             skipTxValidation: true,
             overrides,
-            scopes
+            scopes,
+            senderForTags: this.senderForTagsFrom(from, sendMessagesAs)
         });
+        const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+        return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
     }
     // Exposed because of the `aztec-wallet get-tx` command. It has been decided that it's fine to keep around because
     // this is just a CLI wallet.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/cli-wallet",
-  "version": "0.0.1-commit.42ee6df9b",
+  "version": "0.0.1-commit.431c48d",
   "type": "module",
   "exports": {
     ".": "./dest/cmds/index.js",
@@ -19,7 +19,7 @@
   "scripts": {
     "start": "node --no-warnings ./dest/bin",
     "start:debug": "node --inspect=0.0.0.0:9221 --no-warnings ./dest/bin",
-    "dev": "LOG_LEVEL=debug && node ./dest/bin",
+    "dev": "LOG_LEVEL=\"debug; info: json-rpc, simulator\" node ./dest/bin",
     "build": "yarn clean && ../scripts/tsc.sh",
     "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
@@ -67,19 +67,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.1-commit.42ee6df9b",
-    "@aztec/aztec.js": "0.0.1-commit.42ee6df9b",
-    "@aztec/bb.js": "0.0.1-commit.42ee6df9b",
-    "@aztec/cli": "0.0.1-commit.42ee6df9b",
-    "@aztec/entrypoints": "0.0.1-commit.42ee6df9b",
-    "@aztec/ethereum": "0.0.1-commit.42ee6df9b",
-    "@aztec/foundation": "0.0.1-commit.42ee6df9b",
-    "@aztec/kv-store": "0.0.1-commit.42ee6df9b",
-    "@aztec/noir-contracts.js": "0.0.1-commit.42ee6df9b",
-    "@aztec/noir-noirc_abi": "0.0.1-commit.42ee6df9b",
-    "@aztec/pxe": "0.0.1-commit.42ee6df9b",
-    "@aztec/stdlib": "0.0.1-commit.42ee6df9b",
-    "@aztec/wallet-sdk": "0.0.1-commit.42ee6df9b",
+    "@aztec/accounts": "0.0.1-commit.431c48d",
+    "@aztec/aztec.js": "0.0.1-commit.431c48d",
+    "@aztec/bb.js": "0.0.1-commit.431c48d",
+    "@aztec/cli": "0.0.1-commit.431c48d",
+    "@aztec/entrypoints": "0.0.1-commit.431c48d",
+    "@aztec/ethereum": "0.0.1-commit.431c48d",
+    "@aztec/foundation": "0.0.1-commit.431c48d",
+    "@aztec/kv-store": "0.0.1-commit.431c48d",
+    "@aztec/noir-contracts.js": "0.0.1-commit.431c48d",
+    "@aztec/noir-noirc_abi": "0.0.1-commit.431c48d",
+    "@aztec/pxe": "0.0.1-commit.431c48d",
+    "@aztec/standard-contracts": "0.0.1-commit.431c48d",
+    "@aztec/stdlib": "0.0.1-commit.431c48d",
+    "@aztec/wallet-sdk": "0.0.1-commit.431c48d",
     "commander": "^12.1.0",
     "inquirer": "^10.1.8",
     "source-map-support": "^0.5.21",

package/src/bin/index.ts

@@ -73,7 +73,7 @@ function injectInternalCommands(program: Command, log: LogFn, db: WalletDB) {
 
 /** CLI wallet main entrypoint */
 async function main() {
-  const walletVersion = getPackageVersion() ?? '0.0.0';
+  const walletVersion = getPackageVersion();
 
   const db = WalletDB.getInstance();
   const walletAndNodeWrapper = new CliWalletAndNodeWrapper();

package/src/cmds/check_tx.ts

@@ -33,7 +33,7 @@ export async function checkTx(
 // dependency when dropping PXE JSON RPC Server.
 
 async function inspectTx(wallet: CLIWallet, aztecNode: AztecNode, txHash: TxHash, log: LogFn) {
-  const [receipt, effectsInBlock] = await Promise.all([aztecNode.getTxReceipt(txHash), aztecNode.getTxEffect(txHash)]);
+  const receipt = await aztecNode.getTxReceipt(txHash, { includeTxEffect: true });
   // Base tx data
   log(`Tx ${txHash.toString()}`);
   log(` Status: ${receipt.status}`);
@@ -44,11 +44,11 @@ async function inspectTx(wallet: CLIWallet, aztecNode: AztecNode, txHash: TxHash
     log(` Error: ${receipt.error}`);
   }
 
-  if (!effectsInBlock) {
+  if (!receipt.isMined() || !receipt.txEffect) {
     return;
   }
 
-  const effects = effectsInBlock.data;
+  const effects = receipt.txEffect;
   const artifactMap = await getKnownArtifacts(wallet);
 
   log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);
@@ -197,21 +197,22 @@ type ContractArtifactWithClassId = ContractArtifact & { classId: Fr };
 
 async function getKnownArtifacts(wallet: CLIWallet): Promise<ArtifactMap> {
   const knownContractAddresses = await wallet.getContracts();
-  const knownContracts = (
-    await Promise.all(knownContractAddresses.map(contractAddress => wallet.getContractMetadata(contractAddress)))
-  ).map(contractMetadata => contractMetadata.instance);
-  const classIds = [...new Set(knownContracts.map(contract => contract?.currentContractClassId))];
+  const knownContracts = await Promise.all(
+    knownContractAddresses.map(contractAddress => wallet.getContractMetadata(contractAddress)),
+  );
+  const classIdFor = (metadata: (typeof knownContracts)[number]): Fr | undefined =>
+    metadata.updatedContractClassId ?? metadata.instance?.originalContractClassId;
+  const classIds = [...new Set(knownContracts.map(classIdFor))];
   const knownArtifacts = (
     await Promise.all(classIds.map(classId => (classId ? wallet.getContractArtifact(classId) : undefined)))
   ).map((artifact, index) => (artifact ? { ...artifact, classId: classIds[index] } : undefined));
   const map: Record<string, ContractArtifactWithClassId> = {};
-  for (const instance of knownContracts) {
-    if (instance) {
-      const artifact = knownArtifacts.find(a =>
-        a?.classId?.equals(instance.currentContractClassId),
-      ) as ContractArtifactWithClassId;
+  for (const metadata of knownContracts) {
+    const classId = classIdFor(metadata);
+    if (metadata.instance && classId) {
+      const artifact = knownArtifacts.find(a => a?.classId?.equals(classId)) as ContractArtifactWithClassId;
       if (artifact) {
-        map[instance.address.toString()] = artifact;
+        map[metadata.instance.address.toString()] = artifact;
       }
     }
   }

package/src/cmds/create_account.ts

@@ -1,3 +1,4 @@
+import { deriveSecretKeyFromSigningKey } from '@aztec/accounts/utils';
 import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { NO_WAIT } from '@aztec/aztec.js/contracts';
@@ -5,6 +6,7 @@ import { type AztecNode, waitForTx } from '@aztec/aztec.js/node';
 import type { DeployAccountOptions } from '@aztec/aztec.js/wallet';
 import { prettyPrintJSON } from '@aztec/cli/cli-utils';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { type TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 
@@ -18,7 +20,7 @@ export async function createAccount(
   wallet: CLIWallet,
   aztecNode: AztecNode,
   accountType: AccountType,
-  secretKey: Fr | undefined,
+  signingKey: GrumpkinScalar | undefined,
   salt: Fr | undefined,
   publicKey: string | undefined,
   alias: string | undefined,
@@ -35,15 +37,17 @@ export async function createAccount(
   debugLogger: Logger,
   log: LogFn,
 ) {
-  secretKey ??= Fr.random();
-
-  const account = await wallet.createOrRetrieveAccount(
-    undefined /* address, we don't have it yet */,
-    secretKey,
-    accountType,
-    salt,
-    publicKey,
-  );
+  let secretKey: Fr;
+  if (accountType === 'ecdsasecp256r1ssh') {
+    // SSH accounts sign with a key held in the agent, and so we cannot derive their privacy secret key from it. Instead
+    // we pick a random value.
+    secretKey = Fr.random();
+  } else {
+    signingKey ??= GrumpkinScalar.random();
+    secretKey = await deriveSecretKeyFromSigningKey(signingKey);
+  }
+
+  const account = await wallet.createAccount(accountType, signingKey, secretKey, salt, publicKey);
   const instanceSalt = account.getInstance().salt;
   const { address, publicKeys, partialAddress } = await account.getCompleteAddress();
 
@@ -51,6 +55,9 @@ export async function createAccount(
   if (json) {
     out.address = address;
     out.publicKey = publicKeys;
+    if (signingKey) {
+      out.signingKey = signingKey;
+    }
     if (secretKey) {
       out.secretKey = secretKey;
     }
@@ -61,6 +68,9 @@ export async function createAccount(
     log(`\nNew account:\n`);
     log(`Address:         ${address.toString()}`);
     log(`Public key:      ${publicKeys.toString()}`);
+    if (signingKey) {
+      log(`Signing key:     ${signingKey.toString()}`);
+    }
     if (secretKey) {
       log(`Secret key:     ${secretKey.toString()}`);
     }
@@ -71,7 +81,9 @@ export async function createAccount(
 
   let txHash: TxHash | undefined;
   let txReceipt: TxReceipt | undefined;
-  if (!registerOnly) {
+  // Initializerless accounts have no deployment tx — creating one only registers it locally — so there is
+  // nothing to deploy on-chain.
+  if (!registerOnly && accountType !== 'schnorr_initializerless') {
     const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(aztecNode, wallet, address);
 
     const delegatedDeployment = deployer && !account.address.equals(deployer);
@@ -89,10 +101,10 @@ export async function createAccount(
     const deployMethod = await account.getDeployMethod();
     const sim = await deployMethod.simulate({
       ...deployAccountOpts,
-      fee: { ...deployAccountOpts.fee, estimateGas: true },
+      includeMetadata: true,
     });
-    // estimateGas: true guarantees these fields are present
-    const estimatedGas = sim.estimatedGas!;
+    // includeMetadata: true guarantees these fields are present
+    const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed!);
     const stats = sim.stats!;
 
     if (feeOpts.estimateOnly) {
@@ -160,5 +172,5 @@ export async function createAccount(
     }
   }
 
-  return { alias, address, secretKey, salt: instanceSalt };
+  return { alias, address, signingKey, secretKey, salt: instanceSalt };
 }

package/src/cmds/deploy.ts

@@ -1,5 +1,5 @@
 import { NO_FROM } from '@aztec/aztec.js/account';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { DeployOptions } from '@aztec/aztec.js/contracts';
 import { NO_WAIT } from '@aztec/aztec.js/contracts';
 import { ContractDeployer } from '@aztec/aztec.js/deployment';
@@ -36,6 +36,7 @@ export async function deploy(
   timeout: number = DEFAULT_TX_TIMEOUT_S,
   debugLogger: Logger,
   log: LogFn,
+  universal?: boolean,
 ) {
   const out: Record<string, any> = {};
   salt ??= Fr.random();
@@ -45,12 +46,7 @@ export async function deploy(
 
   // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)?
 
-  const contractDeployer = new ContractDeployer(
-    contractArtifact,
-    wallet,
-    publicKeys ?? PublicKeys.default(),
-    initializer,
-  );
+  const contractDeployer = new ContractDeployer(contractArtifact, wallet, initializer);
 
   let args = [];
   if (rawArgs.length > 0) {
@@ -62,13 +58,15 @@ export async function deploy(
     debugLogger.debug(`Encoded arguments: ${args.join(', ')}`);
   }
 
-  const deployInteraction = contractDeployer.deploy(...args);
+  const deployInteraction = contractDeployer.deploy(args, {
+    salt,
+    publicKeys: publicKeys ?? PublicKeys.default(),
+    ...(universal ? { universalDeploy: true as const } : {}),
+  });
   const { paymentMethod, gasSettings } = await feeOpts.toUserFeeOptions(node, wallet, deployer);
   const deployOpts: DeployOptions = {
     fee: { gasSettings, paymentMethod },
     from: deployer ?? NO_FROM,
-    contractAddressSalt: salt,
-    universalDeploy: !deployer,
     skipClassPublication,
     skipInitialization,
     skipInstancePublication,
@@ -77,10 +75,10 @@ export async function deploy(
   const localStart = performance.now();
   const sim = await deployInteraction.simulate({
     ...deployOpts,
-    fee: { ...deployOpts.fee, estimateGas: true },
+    includeMetadata: true,
   });
-  // estimateGas: true guarantees these fields are present
-  const estimatedGas = sim.estimatedGas!;
+  // includeMetadata: true guarantees these fields are present
+  const estimatedGas = await wallet.estimateGasLimits(sim.gasUsed!);
   const stats = sim.stats!;
 
   if (feeOpts.estimateOnly) {
@@ -101,8 +99,9 @@ export async function deploy(
       printProfileResult(stats, log);
     }
 
-    const { address, partialAddress } = deployInteraction;
     const instance = await deployInteraction.getInstance();
+    const address = instance.address;
+    const partialAddress = await deployInteraction.getPartialAddress();
 
     const { txHash } = await deployInteraction.send({ ...deployOpts, wait: NO_WAIT });
     const localTimeMs = performance.now() - localStart;
@@ -115,8 +114,8 @@ export async function deploy(
       const nodeTimeMs = performance.now() - nodeStart;
 
       if (!json) {
-        log(`Contract deployed at ${address?.toString()}`);
-        log(`Contract partial address ${(await partialAddress)?.toString()}`);
+        log(`Contract deployed at ${address.toString()}`);
+        log(`Contract partial address ${partialAddress.toString()}`);
         log(`Contract init hash ${instance.initializationHash.toString()}`);
         log(`Deployment tx hash: ${txHash.toString()}`);
         log(`Deployment salt: ${salt.toString()}`);
@@ -126,8 +125,8 @@ export async function deploy(
         log(` Node inclusion time: ${(nodeTimeMs / 1000).toFixed(1)}s`);
       } else {
         out.contract = {
-          address: address?.toString(),
-          partialAddress: (await partialAddress)?.toString(),
+          address: address.toString(),
+          partialAddress: partialAddress.toString(),
           initializationHash: instance.initializationHash.toString(),
           salt: salt.toString(),
           transactionFee: receipt.transactionFee?.toString(),
@@ -135,16 +134,16 @@ export async function deploy(
       }
     } else {
       if (!json) {
-        log(`Contract deployed at ${address?.toString()}`);
-        log(`Contract partial address ${(await partialAddress)?.toString()}`);
+        log(`Contract deployed at ${address.toString()}`);
+        log(`Contract partial address ${partialAddress.toString()}`);
         log(`Contract init hash ${instance.initializationHash.toString()}`);
         log(`Deployment tx hash: ${txHash.toString()}`);
         log(`Deployment salt: ${salt.toString()}`);
         log(`Deployer: ${instance.deployer.toString()}`);
       } else {
         out.contract = {
-          address: address?.toString(),
-          partialAddress: (await partialAddress)?.toString(),
+          address: address.toString(),
+          partialAddress: partialAddress.toString(),
           initializationHash: instance.initializationHash.toString(),
           salt: salt.toString(),
         };
@@ -154,5 +153,5 @@ export async function deploy(
   if (json) {
     log(prettyPrintJSON(out));
   }
-  return deployInteraction.address;
+  return await deployInteraction.getAddress();
 }