@aztec/aztec.js 0.81.0 → 0.82.1-alpha-testnet.1

package/dest/wallet/signerless_wallet.js

@@ -1,4 +1,4 @@
-import { DefaultEntrypoint } from '../entrypoint/default_entrypoint.js';
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 import { BaseWallet } from './base_wallet.js';
 /**
  * Wallet implementation which creates a transaction request directly to the requested contract without any signing.
@@ -7,13 +7,13 @@ import { BaseWallet } from './base_wallet.js';
     constructor(pxe, entrypoint){
         super(pxe), this.entrypoint = entrypoint;
     }
-    async createTxExecutionRequest(execution) {
+    async createTxExecutionRequest(execution, fee, options) {
         let entrypoint = this.entrypoint;
         if (!entrypoint) {
             const { l1ChainId: chainId, protocolVersion } = await this.pxe.getNodeInfo();
             entrypoint = new DefaultEntrypoint(chainId, protocolVersion);
         }
-        return entrypoint.createTxExecutionRequest(execution);
+        return entrypoint.createTxExecutionRequest(execution, fee, options);
     }
     getChainId() {
         throw new Error('SignerlessWallet: Method getChainId not implemented.');
@@ -30,7 +30,4 @@ import { BaseWallet } from './base_wallet.js';
     createAuthWit(_intent) {
         throw new Error('SignerlessWallet: Method createAuthWit not implemented.');
     }
-    isL1ToL2MessageSynced(l1ToL2Message) {
-        return this.pxe.isL1ToL2MessageSynced(l1ToL2Message);
-    }
 }

package/dest/wallet/wallet.d.ts

@@ -0,0 +1,11 @@
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AccountInterface } from '../account/interface.js';
+import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
+/**
+ * The wallet interface.
+ */
+export type Wallet = AccountInterface & Pick<PXE, 'simulateTx' | 'simulateUnconstrained' | 'profileTx' | 'sendTx' | 'getContractClassMetadata' | 'getContractMetadata' | 'registerContract' | 'registerContractClass' | 'proveTx' | 'getNodeInfo' | 'getPXEInfo' | 'getCurrentBaseFees' | 'updateContract' | 'registerSender' | 'getSenders' | 'removeSender' | 'getTxReceipt' | 'getPrivateEvents' | 'getPublicEvents'> & {
+    createAuthWit(intent: IntentInnerHash | IntentAction): Promise<AuthWitness>;
+};
+//# sourceMappingURL=wallet.d.ts.map

package/dest/wallet/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/wallet/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,gBAAgB,GACnC,IAAI,CACF,GAAG,EACD,YAAY,GACZ,uBAAuB,GACvB,WAAW,GACX,QAAQ,GACR,0BAA0B,GAC1B,qBAAqB,GACrB,kBAAkB,GAClB,uBAAuB,GACvB,SAAS,GACT,aAAa,GACb,YAAY,GACZ,oBAAoB,GACpB,gBAAgB,GAChB,gBAAgB,GAChB,YAAY,GACZ,cAAc,GACd,cAAc,GACd,kBAAkB,GAClB,iBAAiB,CACpB,GAAG;IACF,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC7E,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/aztec.js",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/aztec.js",
-  "version": "0.81.0",
+  "version": "0.82.1-alpha-testnet.1",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -23,7 +23,8 @@
     "./tx_hash": "./dest/api/tx_hash.js",
     "./wallet": "./dest/api/wallet.js",
     "./utils": "./dest/api/utils.js",
-    "./testing": "./dest/api/testing.js"
+    "./testing": "./dest/api/testing.js",
+    "./fee/testing": "./dest/api/fee_testing.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -79,12 +80,13 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.81.0",
-    "@aztec/ethereum": "0.81.0",
-    "@aztec/foundation": "0.81.0",
-    "@aztec/l1-artifacts": "0.81.0",
-    "@aztec/protocol-contracts": "0.81.0",
-    "@aztec/stdlib": "0.81.0",
+    "@aztec/constants": "0.82.1-alpha-testnet.1",
+    "@aztec/entrypoints": "0.82.1-alpha-testnet.1",
+    "@aztec/ethereum": "0.82.1-alpha-testnet.1",
+    "@aztec/foundation": "0.82.1-alpha-testnet.1",
+    "@aztec/l1-artifacts": "0.82.1-alpha-testnet.1",
+    "@aztec/protocol-contracts": "0.82.1-alpha-testnet.1",
+    "@aztec/stdlib": "0.82.1-alpha-testnet.1",
     "axios": "^1.7.2",
     "tslib": "^2.4.0",
     "viem": "2.23.7"

package/src/account/{contract.ts → account_contract.ts}

@@ -1,10 +1,11 @@
+import type { AuthWitnessProvider } from '@aztec/entrypoints/interfaces';
 import { Fr } from '@aztec/foundation/fields';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { CompleteAddress, NodeInfo } from '@aztec/stdlib/contract';
 import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
 import { deriveKeys } from '@aztec/stdlib/keys';
 
-import type { AccountInterface, AuthWitnessProvider } from './interface.js';
+import type { AccountInterface } from './interface.js';
 
 // docs:start:account-contract-interface
 /**

package/src/account/index.ts

@@ -8,9 +8,8 @@
  */
 import type { Fr } from '@aztec/foundation/fields';
 
-export { type AccountContract, getAccountContractAddress } from './contract.js';
-export { type AccountInterface, type AuthWitnessProvider } from './interface.js';
-export * from './wallet.js';
+export { type AccountContract, getAccountContractAddress } from './account_contract.js';
+export { type AccountInterface } from './interface.js';
 
 /** A contract deployment salt. */
 export type Salt = Fr | number | bigint;

package/src/account/interface.ts

@@ -1,20 +1,9 @@
+import type { AuthWitnessProvider, EntrypointInterface } from '@aztec/entrypoints/interfaces';
 import type { Fr } from '@aztec/foundation/fields';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 
-import type { EntrypointInterface } from '../entrypoint/entrypoint.js';
-
 // docs:start:account-interface
-/** Creates authorization witnesses. */
-export interface AuthWitnessProvider {
-  /**
-   * Computes an authentication witness from either a message hash
-   * @param messageHash - The message hash to approve
-   * @returns The authentication witness
-   */
-  createAuthWit(messageHash: Fr | Buffer): Promise<AuthWitness>;
-}
 
 /**
  * Handler for interfacing with an account. Knows how to create transaction execution

package/src/account_manager/account_manager.ts

@@ -0,0 +1,294 @@
+import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
+import { Fr } from '@aztec/foundation/fields';
+import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { deriveKeys } from '@aztec/stdlib/keys';
+
+import type { AccountContract } from '../account/account_contract.js';
+import type { Salt } from '../account/index.js';
+import type { AccountInterface } from '../account/interface.js';
+import { Contract } from '../contract/contract.js';
+import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
+import { DefaultWaitOpts, type WaitOpts } from '../contract/sent_tx.js';
+import { AccountEntrypointMetaPaymentMethod } from '../fee/account_entrypoint_meta_payment_method.js';
+import { FeeJuicePaymentMethod, type FeePaymentMethod } from '../index.js';
+import { AccountWalletWithSecretKey, SignerlessWallet, type Wallet } from '../wallet/index.js';
+import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
+
+/**
+ * Options to deploy an account contract.
+ */
+export type DeployAccountOptions = Pick<
+  DeployOptions,
+  'fee' | 'skipClassRegistration' | 'skipPublicDeployment' | 'skipInitialization'
+> & {
+  /**
+   * Wallet used for deploying the account contract. Must be funded in order to pay for the fee.
+   */
+  deployWallet?: Wallet;
+};
+
+/**
+ * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
+ * and creating and registering the user wallet in the PXE Service.
+ */
+export class AccountManager {
+  private constructor(
+    private pxe: PXE,
+    private secretKey: Fr,
+    private accountContract: AccountContract,
+    private instance: ContractInstanceWithAddress,
+    /**
+     * Deployment salt for the account contract
+     */
+    public readonly salt: Salt,
+  ) {}
+
+  static async create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
+    const { publicKeys } = await deriveKeys(secretKey);
+    salt = salt !== undefined ? new Fr(salt) : Fr.random();
+
+    const { constructorName, constructorArgs } = (await accountContract.getDeploymentFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    const artifact = await accountContract.getContractArtifact();
+    const instance = await getContractInstanceFromDeployParams(artifact, {
+      constructorArtifact: constructorName,
+      constructorArgs,
+      salt: salt,
+      publicKeys,
+    });
+
+    return new AccountManager(pxe, 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 getAccount(): Promise<AccountInterface> {
+    const nodeInfo = await this.pxe.getNodeInfo();
+    const completeAddress = await this.getCompleteAddress();
+    return this.accountContract.getInterface(completeAddress, nodeInfo);
+  }
+
+  /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to be deployed or registered.
+   * @returns The address, partial address, and encryption public key.
+   */
+  public getCompleteAddress(): Promise<CompleteAddress> {
+    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+  }
+
+  /**
+   * Gets the address for this given account.
+   * Does not require the account to be deployed or registered.
+   * @returns The address.
+   */
+  public getAddress() {
+    return this.instance.address;
+  }
+
+  /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to be deployed or registered.
+   * @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 getWallet(): Promise<AccountWalletWithSecretKey> {
+    const entrypoint = await this.getAccount();
+    return new AccountWalletWithSecretKey(this.pxe, entrypoint, this.secretKey, this.salt);
+  }
+
+  /**
+   * Registers this account in the PXE Service and returns the associated wallet. Registering
+   * the account on the PXE Service is required for managing private state associated with it.
+   * Use the returned wallet to create Contract instances to be interacted with from this account.
+   * @param opts - Options to wait for the account to be synched.
+   * @returns A Wallet instance.
+   */
+  public async register(): Promise<AccountWalletWithSecretKey> {
+    await this.pxe.registerContract({
+      artifact: await this.accountContract.getContractArtifact(),
+      instance: this.getInstance(),
+    });
+
+    await this.pxe.registerAccount(this.secretKey, (await this.getCompleteAddress()).partialAddress);
+
+    return this.getWallet();
+  }
+
+  /**
+   * Returns the pre-populated deployment method to deploy the account contract that backs this account.
+   * If no wallet is provided, it uses a signerless wallet with the multi call entrypoint
+   * @param deployWallet - Wallet used for deploying the account contract.
+   * @returns A DeployMethod instance that deploys this account contract
+   */
+  async #getDeployMethod(deployWallet?: Wallet): Promise<DeployMethod> {
+    const artifact = await this.accountContract.getContractArtifact();
+
+    if (!(await this.isDeployable())) {
+      throw new Error(`Account contract ${artifact.name} does not require deployment.`);
+    }
+
+    const completeAddress = await this.getCompleteAddress();
+
+    await this.pxe.registerAccount(this.secretKey, completeAddress.partialAddress);
+
+    const { constructorName, constructorArgs } = (await this.accountContract.getDeploymentFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    if (deployWallet) {
+      // If deploying using an existing wallet/account, treat it like regular contract deployment.
+      const thisWallet = await this.getWallet();
+      return new DeployMethod(
+        this.getPublicKeys(),
+        deployWallet,
+        artifact,
+        address => Contract.at(address, artifact, thisWallet),
+        constructorArgs,
+        constructorName,
+      );
+    }
+
+    const { l1ChainId: chainId, protocolVersion } = await this.pxe.getNodeInfo();
+    // We use a signerless wallet with the multi call entrypoint in order to make multiple calls in one go.
+    // If we used getWallet, the deployment would get routed via the account contract entrypoint
+    // and it can't be used unless the contract is initialized.
+    const wallet = new SignerlessWallet(this.pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion));
+
+    return new DeployMethod(
+      this.getPublicKeys(),
+      wallet,
+      artifact,
+      address => Contract.at(address, artifact, wallet),
+      constructorArgs,
+      constructorName,
+    );
+  }
+
+  /**
+   * 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)
+   */
+  async #getSelfPaymentMethod(originalPaymentMethod?: FeePaymentMethod) {
+    const artifact = await this.accountContract.getContractArtifact();
+    const wallet = await this.getWallet();
+    const address = wallet.getAddress();
+    return new AccountEntrypointMetaPaymentMethod(
+      artifact,
+      wallet,
+      'entrypoint',
+      address,
+      originalPaymentMethod ?? new FeeJuicePaymentMethod(address),
+    );
+  }
+
+  /**
+   * Deploys the account contract that backs this account.
+   * Does not register the associated class nor publicly deploy the instance by default.
+   * Uses the salt provided in the constructor or a randomly generated one.
+   * Registers the account in the PXE Service before deploying the contract.
+   * @param opts - Fee options to be used for the deployment.
+   * @returns A SentTx object that can be waited to get the associated Wallet.
+   */
+  public deploy(opts?: DeployAccountOptions): DeployAccountSentTx {
+    let deployMethod: DeployMethod;
+    const sentTx = this.#getDeployMethod(opts?.deployWallet)
+      .then(method => {
+        deployMethod = method;
+        if (!opts?.deployWallet && opts?.fee) {
+          return this.#getSelfPaymentMethod(opts?.fee?.paymentMethod);
+        }
+      })
+      .then(maybeWrappedPaymentMethod => {
+        let fee = opts?.fee;
+        if (maybeWrappedPaymentMethod) {
+          fee = { ...opts?.fee, paymentMethod: maybeWrappedPaymentMethod };
+        }
+        return deployMethod.send({
+          contractAddressSalt: new Fr(this.salt),
+          skipClassRegistration: opts?.skipClassRegistration ?? true,
+          skipPublicDeployment: opts?.skipPublicDeployment ?? true,
+          skipInitialization: opts?.skipInitialization ?? false,
+          universalDeploy: true,
+          fee,
+        });
+      })
+      .then(tx => tx.getTxHash());
+    return new DeployAccountSentTx(this.pxe, sentTx, this.getWallet());
+  }
+
+  /**
+   * Estimates the gas needed to deploy the account contract that backs this account.
+   * This method is here to ensure that the fee payment method is correctly set up in case
+   * the account contract needs to pay for its own deployment.
+   * @param opts - Fee options to be used for the deployment.
+   * @returns The gas estimations for the account contract deployment and initialization.
+   */
+  public async estimateDeploymentGas(
+    opts?: DeployAccountOptions,
+  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
+    const deployMethod = await this.#getDeployMethod(opts?.deployWallet);
+    const fee =
+      !opts?.deployWallet && opts?.fee
+        ? { ...opts.fee, paymentMethod: await this.#getSelfPaymentMethod(opts.fee.paymentMethod) }
+        : opts?.fee;
+    return deployMethod.estimateGas({
+      contractAddressSalt: new Fr(this.salt),
+      skipClassRegistration: opts?.skipClassRegistration ?? true,
+      skipPublicDeployment: opts?.skipPublicDeployment ?? true,
+      skipInitialization: opts?.skipInitialization ?? false,
+      universalDeploy: true,
+      fee,
+    });
+  }
+
+  /**
+   * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
+   * Uses the salt provided in the constructor or a randomly generated one. If no initialization
+   * is required it skips the transaction, and only registers the account in the PXE Service.
+   * @param opts - Options to wait for the tx to be mined.
+   * @returns A Wallet instance.
+   */
+  public async waitSetup(opts: DeployAccountOptions & WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithSecretKey> {
+    await ((await this.isDeployable()) ? this.deploy(opts).wait(opts) : this.register());
+    return this.getWallet();
+  }
+
+  /**
+   * Returns whether this account contract has a constructor and needs deployment.
+   */
+  public async isDeployable() {
+    return (await this.accountContract.getDeploymentFunctionAndArgs()) !== undefined;
+  }
+}

package/src/account_manager/deploy_account_sent_tx.ts

@@ -1,9 +1,9 @@
 import type { FieldsOf } from '@aztec/foundation/types';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
 import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
 import { DefaultWaitOpts, SentTx, type WaitOpts } from '../contract/sent_tx.js';
+import type { Wallet } from '../wallet/wallet.js';
 
 /** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
 export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
@@ -15,8 +15,8 @@ export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
  * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
  */
 export class DeployAccountSentTx extends SentTx {
-  constructor(pxe: PXE, txHashPromise: Promise<TxHash>, private getWalletPromise: Promise<Wallet>) {
-    super(pxe, txHashPromise);
+  constructor(pxeOrNode: AztecNode | PXE, txHashPromise: Promise<TxHash>, private getWalletPromise: Promise<Wallet>) {
+    super(pxeOrNode, txHashPromise);
   }
 
   /**