@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/wallet/account_entrypoint_meta_payment_method.ts

@@ -0,0 +1,106 @@
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { EncodedAppEntrypointCalls } from '@aztec/entrypoints/encoding';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import {
+  type ContractArtifact,
+  type FunctionArtifact,
+  FunctionCall,
+  FunctionSelector,
+  encodeArguments,
+  getFunctionArtifactByName,
+} from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { Wallet } from './index.js';
+
+/**
+ * Fee payment method that allows an account contract to pay for its own deployment
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle it.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
+ */
+export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+  constructor(
+    private wallet: Wallet,
+    private artifact: ContractArtifact,
+    private feePaymentNameOrArtifact: string | FunctionArtifact,
+    private accountAddress: AztecAddress,
+    private paymentMethod?: FeePaymentMethod,
+  ) {}
+
+  getAsset(): Promise<AztecAddress> {
+    return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  async getExecutionPayload(): Promise<ExecutionPayload> {
+    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
+    // It can be empty because the account might attempt to pay for the tx fee using its own
+    // FeeJuice balance
+    const { calls: feeCalls, authWitnesses: feeAuthwitnesses } =
+      (await this.paymentMethod?.getExecutionPayload()) ?? ExecutionPayload.empty();
+    // Encode the calls for the fee
+    const feePayer = (await this.paymentMethod?.getFeePayer()) ?? this.accountAddress;
+    const isFeePayer = feePayer.equals(this.accountAddress);
+    let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+    if (isFeePayer) {
+      // If the account is the fee payer, and the incoming fee payload has calls
+      // it can only be FeeJuicePaymentMethodWithClaim
+      // If the payload has no calls, it's paying using
+      // its own fee juice balance
+      accountFeePaymentMethodOptions =
+        feeCalls.length === 0
+          ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE
+          : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+    }
+    const feeEncodedCalls = await EncodedAppEntrypointCalls.create(feeCalls);
+
+    // Get the entrypoint args
+    const args = [feeEncodedCalls, accountFeePaymentMethodOptions, false];
+    const feePaymentArtifact =
+      typeof this.feePaymentNameOrArtifact === 'string'
+        ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact)
+        : this.feePaymentNameOrArtifact;
+
+    const entrypointCall = new FunctionCall(
+      feePaymentArtifact.name,
+      this.accountAddress,
+      await FunctionSelector.fromNameAndParameters(feePaymentArtifact.name, feePaymentArtifact.parameters),
+      feePaymentArtifact.functionType,
+      false /** hideMsgSender -- set to `false`, because it's not applicable for an entrypoint function (only for enqueued public calls) */,
+      feePaymentArtifact.isStatic,
+      encodeArguments(feePaymentArtifact, args),
+      feePaymentArtifact.returnTypes,
+    );
+
+    // Compute the authwitness required to verify the combined payload
+    const payloadAuthWitness = await this.wallet.createAuthWit(this.accountAddress, await feeEncodedCalls.hash());
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      [payloadAuthWitness, ...feeAuthwitnesses],
+      [],
+      feeEncodedCalls.hashedArguments,
+      feePayer,
+    );
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.accountAddress);
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.paymentMethod?.getGasSettings();
+  }
+}

package/src/wallet/account_manager.ts

@@ -0,0 +1,154 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  CompleteAddress,
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/stdlib/contract';
+import { deriveKeys } from '@aztec/stdlib/keys';
+
+import type { AccountContract } from '../account/account_contract.js';
+import { AccountWithSecretKey } from '../account/account_with_secret_key.js';
+import type { Salt } from '../account/index.js';
+import type { AccountInterface } from '../account/interface.js';
+import { Contract } from '../contract/contract.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+import type { Wallet } from './wallet.js';
+
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */
+export class AccountManager {
+  private constructor(
+    private wallet: Wallet,
+    private secretKey: Fr,
+    private accountContract: AccountContract,
+    private instance: ContractInstanceWithAddress,
+    /**
+     * Contract instantiation salt for the account contract
+     */
+    public readonly salt: Salt,
+  ) {}
+
+  static async create(wallet: Wallet, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
+    const { publicKeys } = await deriveKeys(secretKey);
+    salt = salt !== undefined ? new Fr(salt) : Fr.random();
+
+    const { constructorName, constructorArgs } = (await accountContract.getInitializationFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    const artifact = await accountContract.getContractArtifact();
+    const instance = await getContractInstanceFromInstantiationParams(artifact, {
+      constructorArtifact: constructorName,
+      constructorArgs,
+      salt: salt,
+      publicKeys,
+    });
+
+    return new AccountManager(wallet, secretKey, accountContract, instance, salt);
+  }
+
+  protected getPublicKeys() {
+    return this.instance.publicKeys;
+  }
+
+  protected getPublicKeysHash() {
+    return this.getPublicKeys().hash();
+  }
+
+  /**
+   * Returns the entrypoint for this account as defined by its account contract.
+   * @returns An entrypoint.
+   */
+  public async getAccountInterface(): Promise<AccountInterface> {
+    const chainInfo = await this.wallet.getChainInfo();
+    const completeAddress = await this.getCompleteAddress();
+    return this.accountContract.getInterface(completeAddress, chainInfo);
+  }
+
+  /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns The address, partial address, and encryption public key.
+   */
+  public getCompleteAddress(): Promise<CompleteAddress> {
+    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+  }
+
+  /**
+   * Returns the secret key used to derive the rest of the privacy keys for this contract
+   */
+  public getSecretKey() {
+    return this.secretKey;
+  }
+
+  get address() {
+    return this.instance.address;
+  }
+
+  /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns ContractInstance instance.
+   */
+  public getInstance(): ContractInstanceWithAddress {
+    return this.instance;
+  }
+
+  /**
+   * Returns a Wallet instance associated with this account. Use it to create Contract
+   * instances to be interacted with from this account.
+   * @returns A Wallet instance.
+   */
+  public async getAccount(): Promise<AccountWithSecretKey> {
+    const accountInterface = await this.getAccountInterface();
+    return new AccountWithSecretKey(accountInterface, this.secretKey, this.salt);
+  }
+
+  /**
+   * Returns the account contract that backs this account.
+   * @returns The account contract
+   */
+  getAccountContract(): AccountContract {
+    return this.accountContract;
+  }
+
+  /**
+   * Returns a preconfigured deploy method that contains all the necessary function
+   * calls to deploy the account contract.
+   */
+  public async getDeployMethod(): Promise<DeployAccountMethod> {
+    const artifact = await this.accountContract.getContractArtifact();
+
+    if (!(await this.hasInitializer())) {
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15576):
+      // there should be a path which enables an account contract's class & instance to be published,
+      // even if the account contract doesn't have an initializer function. This should not throw.
+      throw new Error(`Account contract ${artifact.name} does not have an initializer function to call.`);
+    }
+
+    const { constructorName, constructorArgs } = (await this.accountContract.getInitializationFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    return new DeployAccountMethod(
+      this.getPublicKeys(),
+      this.wallet,
+      artifact,
+      instance => Contract.at(instance.address, artifact, this.wallet),
+      new Fr(this.salt),
+      constructorArgs,
+      constructorName,
+    );
+  }
+
+  /**
+   * Returns whether this account contract has an initializer function.
+   */
+  public async hasInitializer() {
+    return (await this.accountContract.getInitializationFunctionAndArgs()) !== undefined;
+  }
+}

package/src/wallet/deploy_account_method.ts

@@ -0,0 +1,126 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ContractArtifact, FunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+
+import type { Contract } from '../contract/contract.js';
+import type { ContractBase } from '../contract/contract_base.js';
+import {
+  DeployMethod,
+  type DeployOptions,
+  type RequestDeployOptions,
+  type SimulateDeployOptions,
+} from '../contract/deploy_method.js';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import { AccountEntrypointMetaPaymentMethod } from './account_entrypoint_meta_payment_method.js';
+import type { Wallet } from './index.js';
+
+/**
+ * The configuration options for the request method. Omits the contractAddressSalt, since
+ * for account contracts that is fixed in the constructor
+ */
+export type RequestDeployAccountOptions = Omit<RequestDeployOptions, 'contractAddressSalt'>;
+
+/**
+ * The configuration options for the send/prove methods. Omits:
+ * - The contractAddressSalt, since for account contracts that is fixed in the constructor.
+ * - UniversalDeployment flag, since account contracts are always deployed with it set to true
+ */
+export type DeployAccountOptions = Omit<DeployOptions, 'contractAddressSalt' | 'universalDeploy'>;
+
+/**
+ * The configuration options for the simulate method. Omits the contractAddressSalt, since
+ * for account contracts that is fixed in the constructor
+ */
+export type SimulateDeployAccountOptions = Omit<SimulateDeployOptions, 'contractAddressSalt'>;
+
+/**
+ * Modified version of the DeployMethod used to deploy account contracts. Supports deploying
+ * contracts that can pay for their own fee, plus some preconfigured options to avoid errors.
+ */
+export class DeployAccountMethod<TContract extends ContractBase = Contract> extends DeployMethod<TContract> {
+  constructor(
+    publicKeys: PublicKeys,
+    wallet: Wallet,
+    artifact: ContractArtifact,
+    postDeployCtor: (instance: ContractInstanceWithAddress, wallet: Wallet) => TContract,
+    private salt: Fr,
+    args: any[] = [],
+    constructorNameOrArtifact?: string | FunctionArtifact,
+  ) {
+    super(publicKeys, wallet, artifact, postDeployCtor, args, constructorNameOrArtifact);
+  }
+
+  /**
+   * Returns a FeePaymentMethod that routes the original one provided as an argument
+   * through the account's entrypoint. This allows an account contract to pay
+   * for its own deployment and initialization.
+   *
+   * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
+   *
+   * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
+   * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
+   */
+  private getSelfFeePaymentMethod(originalPaymentMethod?: FeePaymentMethod) {
+    if (!this.address) {
+      throw new Error('Instance is not yet constructed. This is a bug!');
+    }
+    return new AccountEntrypointMetaPaymentMethod(
+      this.wallet,
+      this.artifact,
+      'entrypoint',
+      this.address,
+      originalPaymentMethod,
+    );
+  }
+
+  /**
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param opts - Configuration options.
+   * @returns The execution payload for this operation
+   */
+  public override async request(opts?: RequestDeployAccountOptions): Promise<ExecutionPayload> {
+    const optionsWithDefaults: RequestDeployOptions = {
+      ...opts,
+      // Regardless of whom sends the transaction, account contracts
+      // are always deployed as universalDeployment: true
+      deployer: undefined,
+      contractAddressSalt: new Fr(this.salt),
+      skipClassPublication: opts?.skipClassPublication ?? true,
+      skipInstancePublication: opts?.skipInstancePublication ?? true,
+      skipInitialization: opts?.skipInitialization ?? false,
+    };
+    // Override the fee to undefined, since we'll replace it
+    const deploymentExecutionPayload = await super.request({ ...optionsWithDefaults, fee: undefined });
+    const executionPayloads = [deploymentExecutionPayload];
+    // If this is a self-deployment, manage the fee accordingly
+    if (opts?.deployer?.equals(AztecAddress.ZERO)) {
+      const feePaymentMethod = this.getSelfFeePaymentMethod(opts?.fee?.paymentMethod);
+      const feeExecutionPayload = await feePaymentMethod.getExecutionPayload();
+      // Notice they are reversed (fee payment usually goes first):
+      // this is because we need to construct the contract BEFORE it can pay for its own fee
+      executionPayloads.push(feeExecutionPayload);
+    } else {
+      const feeExecutionPayload = opts?.fee?.paymentMethod
+        ? await opts.fee.paymentMethod.getExecutionPayload()
+        : undefined;
+      if (feeExecutionPayload) {
+        executionPayloads.unshift(feeExecutionPayload);
+      }
+    }
+    return mergeExecutionPayloads(executionPayloads);
+  }
+
+  override convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
+    return {
+      ...options,
+      // Deployer is handled in the request method and forcibly set to undefined,
+      // since our account contracts are created with universalDeployment: true
+      // We need to forward it though, because depending on the deployer we have to assemble
+      // The fee payment method one way or another
+      deployer: options.from,
+    };
+  }
+}

package/src/wallet/index.ts

@@ -1,33 +1,2 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-import type { AccountContract } from '../account/account_contract.js';
-import { AccountWallet } from './account_wallet.js';
-
 export * from './wallet.js';
-export * from './account_wallet.js';
-export * from './account_wallet_with_private_key.js';
-export * from './signerless_wallet.js';
-
-/**
- * Gets a wallet for an already registered account.
- * @param pxe - PXE Service instance.
- * @param address - Address for the account.
- * @param accountContract - Account contract implementation.
- * @returns A wallet for this account that can be used to interact with a contract instance.
- */
-export async function getWallet(
-  pxe: PXE,
-  address: AztecAddress,
-  accountContract: AccountContract,
-): Promise<AccountWallet> {
-  const completeAddress = (await pxe.getRegisteredAccounts()).find(completeAddress =>
-    completeAddress.address.equals(address),
-  );
-  if (!completeAddress) {
-    throw new Error(`Account ${address} not found`);
-  }
-  const nodeInfo = await pxe.getNodeInfo();
-  const entrypoint = accountContract.getInterface(completeAddress, nodeInfo);
-  return new AccountWallet(pxe, entrypoint);
-}
+export * from './account_manager.js';