@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/wallet/signerless_wallet.js

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

package/src/account/wallet.ts

@@ -1,13 +0,0 @@
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
-import type { AccountInterface } from './interface.js';
-
-/**
- * The wallet interface.
- */
-export type Wallet = AccountInterface &
-  PXE & {
-    createAuthWit(intent: IntentInnerHash | IntentAction): Promise<AuthWitness>;
-  };

package/src/account_manager/deploy_account_method.ts

@@ -1,86 +0,0 @@
-import {
-  type ContractArtifact,
-  type FunctionArtifact,
-  FunctionSelector,
-  encodeArguments,
-  getFunctionArtifactByName,
-} from '@aztec/stdlib/abi';
-import type { PublicKeys } from '@aztec/stdlib/keys';
-
-import type { AuthWitnessProvider } from '../account/interface.js';
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../api/entrypoint.js';
-import { Contract } from '../contract/contract.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { EntrypointPayload, computeCombinedPayloadHash } from '../entrypoint/payload.js';
-
-/**
- * Contract interaction for deploying an account contract. Handles fee preparation and contract initialization.
- */
-export class DeployAccountMethod extends DeployMethod {
-  #authWitnessProvider: AuthWitnessProvider;
-  #feePaymentArtifact: FunctionArtifact | undefined;
-
-  constructor(
-    authWitnessProvider: AuthWitnessProvider,
-    publicKeys: PublicKeys,
-    wallet: Wallet,
-    artifact: ContractArtifact,
-    args: any[] = [],
-    constructorNameOrArtifact?: string | FunctionArtifact,
-    feePaymentNameOrArtifact?: string | FunctionArtifact,
-  ) {
-    super(
-      publicKeys,
-      wallet,
-      artifact,
-      (address, wallet) => Contract.at(address, artifact, wallet),
-      args,
-      constructorNameOrArtifact,
-    );
-
-    this.#authWitnessProvider = authWitnessProvider;
-    this.#feePaymentArtifact =
-      typeof feePaymentNameOrArtifact === 'string'
-        ? getFunctionArtifactByName(artifact, feePaymentNameOrArtifact)
-        : feePaymentNameOrArtifact;
-  }
-
-  protected override async getInitializeFunctionCalls(
-    options: DeployOptions,
-  ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments'>> {
-    const exec = await super.getInitializeFunctionCalls(options);
-
-    if (options.fee && this.#feePaymentArtifact) {
-      const { address } = await this.getInstance();
-      const emptyAppPayload = await EntrypointPayload.fromAppExecution([]);
-      const fee = await this.getDefaultFeeOptions(options.fee);
-      const feePayload = await EntrypointPayload.fromFeeOptions(address, fee);
-
-      exec.calls.push({
-        name: this.#feePaymentArtifact.name,
-        to: address,
-        args: encodeArguments(this.#feePaymentArtifact, [emptyAppPayload, feePayload, false]),
-        selector: await FunctionSelector.fromNameAndParameters(
-          this.#feePaymentArtifact.name,
-          this.#feePaymentArtifact.parameters,
-        ),
-        type: this.#feePaymentArtifact.functionType,
-        isStatic: this.#feePaymentArtifact.isStatic,
-        returnTypes: this.#feePaymentArtifact.returnTypes,
-      });
-
-      exec.authWitnesses ??= [];
-      exec.hashedArguments ??= [];
-
-      exec.authWitnesses.push(
-        await this.#authWitnessProvider.createAuthWit(await computeCombinedPayloadHash(emptyAppPayload, feePayload)),
-      );
-
-      exec.hashedArguments.push(...emptyAppPayload.hashedArguments);
-      exec.hashedArguments.push(...feePayload.hashedArguments);
-    }
-
-    return exec;
-  }
-}

package/src/account_manager/deploy_account_sent_tx.ts

@@ -1,42 +0,0 @@
-import type { FieldsOf } from '@aztec/foundation/types';
-import type { 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';
-
-/** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
-export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
-  /** Wallet that corresponds to the newly deployed account contract. */
-  wallet: Wallet;
-};
-
-/**
- * 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);
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The deployed contract instance.
-   */
-  public async getWallet(opts?: WaitOpts): Promise<Wallet> {
-    const receipt = await this.wait(opts);
-    return receipt.wallet;
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the receipt along with a wallet instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt with the wallet for the deployed account contract.
-   */
-  public override async wait(opts: WaitOpts = DefaultWaitOpts): Promise<DeployAccountTxReceipt> {
-    const receipt = await super.wait(opts);
-    const wallet = await this.getWalletPromise;
-    return { ...receipt, wallet };
-  }
-}

package/src/account_manager/index.ts

@@ -1,229 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import { deriveKeys } from '@aztec/stdlib/keys';
-
-import type { AccountContract } from '../account/contract.js';
-import type { Salt, Wallet } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { Contract } from '../contract/index.js';
-import { DefaultWaitOpts, type WaitOpts } from '../contract/sent_tx.js';
-import { DefaultMultiCallEntrypoint } from '../entrypoint/default_multi_call_entrypoint.js';
-import { AccountWalletWithSecretKey, SignerlessWallet } from '../wallet/index.js';
-import { DeployAccountMethod } from './deploy_account_method.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 artifact = await accountContract.getContractArtifact();
-    const instance = await getContractInstanceFromDeployParams(artifact, {
-      constructorArgs: await accountContract.getDeploymentArgs(),
-      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.
-   * Typically you will not need this method and can call `deploy` directly. Use this for having finer
-   * grained control on when to create, simulate, and send the deployment tx.
-   * @param deployWallet - Wallet used for deploying the account contract.
-   * @returns A DeployMethod instance that deploys this account contract.
-   */
-  public async getDeployMethod(deployWallet?: Wallet) {
-    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 args = (await this.accountContract.getDeploymentArgs()) ?? [];
-
-    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),
-        args,
-        'constructor',
-      );
-    }
-
-    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 DeployAccountMethod(
-      this.accountContract.getAuthWitnessProvider(completeAddress),
-      this.getPublicKeys(),
-      wallet,
-      artifact,
-      args,
-      'constructor',
-      'entrypoint',
-    );
-  }
-
-  /**
-   * 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 {
-    const sentTx = this.getDeployMethod(opts?.deployWallet)
-      .then(deployMethod =>
-        deployMethod.send({
-          contractAddressSalt: new Fr(this.salt),
-          skipClassRegistration: opts?.skipClassRegistration ?? true,
-          skipPublicDeployment: opts?.skipPublicDeployment ?? true,
-          skipInitialization: opts?.skipInitialization ?? false,
-          universalDeploy: true,
-          fee: opts?.fee,
-        }),
-      )
-      .then(tx => tx.getTxHash());
-    return new DeployAccountSentTx(this.pxe, sentTx, this.getWallet());
-  }
-
-  /**
-   * 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.getDeploymentArgs()) !== undefined;
-  }
-}
-
-export { DeployAccountMethod } from './deploy_account_method.js';
-export { type DeployAccountTxReceipt, DeployAccountSentTx } from './deploy_account_sent_tx.js';

package/src/api/cheat_codes.ts

@@ -1,35 +0,0 @@
-import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-import { AztecCheatCodes } from '../utils/aztec_cheatcodes.js';
-import { RollupCheatCodes } from './ethereum/cheat_codes.js';
-
-/**
- * A class that provides utility functions for interacting with the chain.
- */
-export class CheatCodes {
-  constructor(
-    /** Cheat codes for L1.*/
-    public eth: EthCheatCodes,
-    /** Cheat codes for Aztec L2. */
-    public aztec: AztecCheatCodes,
-    /** Cheat codes for the Aztec Rollup contract on L1. */
-    public rollup: RollupCheatCodes,
-  ) {}
-
-  static async create(rpcUrls: string[], pxe: PXE): Promise<CheatCodes> {
-    const ethCheatCodes = new EthCheatCodes(rpcUrls);
-    const aztecCheatCodes = new AztecCheatCodes(pxe);
-    const rollupCheatCodes = new RollupCheatCodes(
-      ethCheatCodes,
-      await pxe.getNodeInfo().then(n => n.l1ContractAddresses),
-    );
-    return new CheatCodes(ethCheatCodes, aztecCheatCodes, rollupCheatCodes);
-  }
-
-  static createRollup(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes {
-    const ethCheatCodes = new EthCheatCodes(rpcUrls);
-    return new RollupCheatCodes(ethCheatCodes, addresses);
-  }
-}

package/src/api/entrypoint.ts

@@ -1 +0,0 @@
-export * from '../entrypoint/entrypoint.js';

package/src/api/ethereum/anvil_test_watcher.ts

@@ -1,158 +0,0 @@
-import type { ViemPublicClient } from '@aztec/ethereum';
-import type { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import type { TestDateProvider } from '@aztec/foundation/timer';
-import { RollupAbi } from '@aztec/l1-artifacts';
-
-import { type GetContractReturnType, getAddress, getContract } from 'viem';
-
-import { RollupCheatCodes } from './cheat_codes.js';
-
-/**
- * Represents a watcher for a rollup contract.
- *
- * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
- * it will periodically check if the current slot have already been filled, e.g., there was an L2
- * block within the slot. And if so, it will time travel into the next slot.
- */
-export class AnvilTestWatcher {
-  private isSandbox: boolean = false;
-
-  private rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>;
-  private rollupCheatCodes: RollupCheatCodes;
-
-  private filledRunningPromise?: RunningPromise;
-  private mineIfOutdatedPromise?: RunningPromise;
-  private markingAsProvenRunningPromise?: RunningPromise;
-
-  private logger: Logger = createLogger(`aztecjs:utils:watcher`);
-
-  private isMarkingAsProven = true;
-
-  constructor(
-    private cheatcodes: EthCheatCodes,
-    rollupAddress: EthAddress,
-    publicClient: ViemPublicClient,
-    private dateProvider?: TestDateProvider,
-  ) {
-    this.rollup = getContract({
-      address: getAddress(rollupAddress.toString()),
-      abi: RollupAbi,
-      client: publicClient,
-    });
-
-    this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
-      rollupAddress,
-    });
-
-    this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
-  }
-
-  setIsMarkingAsProven(isMarkingAsProven: boolean) {
-    this.isMarkingAsProven = isMarkingAsProven;
-  }
-
-  setIsSandbox(isSandbox: boolean) {
-    this.isSandbox = isSandbox;
-  }
-
-  async start() {
-    if (this.filledRunningPromise) {
-      throw new Error('Watcher already watching for filled slot');
-    }
-
-    // If auto mining is not supported (e.g., we are on a real network), then we
-    // will simple do nothing. But if on an anvil or the like, this make sure that
-    // the sandbox and tests don't break because time is frozen and we never get to
-    // the next slot.
-    const isAutoMining = await this.cheatcodes.isAutoMining();
-
-    if (isAutoMining) {
-      this.filledRunningPromise = new RunningPromise(() => this.warpTimeIfNeeded(), this.logger, 1000);
-      this.filledRunningPromise.start();
-      this.mineIfOutdatedPromise = new RunningPromise(() => this.mineIfOutdated(), this.logger, 1000);
-      this.mineIfOutdatedPromise.start();
-      this.markingAsProvenRunningPromise = new RunningPromise(() => this.markAsProven(), this.logger, 1000);
-      this.markingAsProvenRunningPromise.start();
-      this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
-    } else {
-      this.logger.info(`Watcher not started because not auto mining`);
-    }
-  }
-
-  async stop() {
-    await this.filledRunningPromise?.stop();
-    await this.mineIfOutdatedPromise?.stop();
-    await this.markingAsProvenRunningPromise?.stop();
-  }
-
-  async markAsProven() {
-    if (!this.isMarkingAsProven) {
-      return;
-    }
-    await this.rollupCheatCodes.markAsProven();
-  }
-
-  async mineIfOutdated() {
-    // this doesn't apply to the sandbox, because we don't have a date provider in the sandbox
-    if (!this.dateProvider) {
-      return;
-    }
-
-    const l1Time = (await this.cheatcodes.timestamp()) * 1000;
-    const wallTime = this.dateProvider.now();
-
-    // If the wall time is more than 24 seconds away from L1 time,
-    // mine a block and sync the clocks
-    if (Math.abs(wallTime - l1Time) > 24 * 1000) {
-      this.logger.warn(`Wall time is more than 24 seconds away from L1 time, mining a block and syncing clocks`);
-      await this.cheatcodes.evmMine();
-      const newL1Time = await this.cheatcodes.timestamp();
-      this.logger.info(`New L1 time: ${newL1Time}`);
-      this.dateProvider.setTime(newL1Time * 1000);
-    }
-  }
-
-  async warpTimeIfNeeded() {
-    try {
-      const currentSlot = await this.rollup.read.getCurrentSlot();
-      const pendingBlockNumber = BigInt(await this.rollup.read.getPendingBlockNumber());
-      const blockLog = await this.rollup.read.getBlock([pendingBlockNumber]);
-      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([currentSlot + 1n]));
-
-      if (currentSlot === blockLog.slotNumber) {
-        // We should jump to the next slot
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp);
-          this.dateProvider?.setTime(nextSlotTimestamp * 1000);
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
-        }
-
-        this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
-        return;
-      }
-
-      // If we are not in sandbox, we don't need to warp time
-      if (!this.isSandbox) {
-        return;
-      }
-
-      const currentTimestamp = this.dateProvider?.now() ?? Date.now();
-      if (currentTimestamp > nextSlotTimestamp * 1000) {
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp);
-          this.dateProvider?.setTime(nextSlotTimestamp * 1000);
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
-        }
-
-        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
-      }
-    } catch (err) {
-      this.logger.error('mineIfSlotFilled failed');
-    }
-  }
-}