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

package/src/api/ethereum/chain_monitor.ts

@@ -1,88 +0,0 @@
-import type { RollupContract } from '@aztec/ethereum/contracts';
-import { createLogger } from '@aztec/foundation/log';
-
-import type { PublicClient } from 'viem';
-
-/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
-export class ChainMonitor {
-  private readonly l1Client: PublicClient;
-  private handle: NodeJS.Timeout | undefined;
-
-  /** Current L1 block number */
-  public l1BlockNumber!: number;
-  /** Current L2 block number */
-  public l2BlockNumber!: number;
-  /** Current L2 proven block number */
-  public l2ProvenBlockNumber!: number;
-  /** L1 timestamp for the current L2 block */
-  public l2BlockTimestamp!: bigint;
-  /** L1 timestamp for the proven L2 block */
-  public l2ProvenBlockTimestamp!: bigint;
-
-  constructor(
-    private readonly rollup: RollupContract,
-    private logger = createLogger('aztecjs:utils:chain_monitor'),
-    private readonly intervalMs = 200,
-  ) {
-    this.l1Client = rollup.client;
-  }
-
-  start() {
-    if (this.handle) {
-      throw new Error('Chain monitor already started');
-    }
-    this.handle = setInterval(this.safeRun.bind(this), this.intervalMs);
-    return this;
-  }
-
-  stop() {
-    if (this.handle) {
-      clearInterval(this.handle!);
-      this.handle = undefined;
-    }
-  }
-
-  private safeRun() {
-    void this.run().catch(error => {
-      this.logger.error('Error in chain monitor loop', error);
-    });
-  }
-
-  async run() {
-    const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({ cacheTime: 0 }));
-    if (this.l1BlockNumber === newL1BlockNumber) {
-      return;
-    }
-    this.l1BlockNumber = newL1BlockNumber;
-
-    const block = await this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false });
-    const timestamp = block.timestamp;
-    const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
-
-    let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
-
-    const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
-    if (this.l2BlockNumber !== newL2BlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
-      msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
-      this.l2BlockNumber = newL2BlockNumber;
-      this.l2BlockTimestamp = timestamp;
-    }
-
-    const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
-    if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
-      msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
-      this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
-      this.l2ProvenBlockTimestamp = timestamp;
-    }
-
-    this.logger.info(msg, {
-      l1Timestamp: timestamp,
-      l1BlockNumber: this.l1BlockNumber,
-      l2SlotNumber: await this.rollup.getSlotNumber(),
-      l2BlockNumber: this.l2BlockNumber,
-      l2ProvenBlockNumber: this.l2ProvenBlockNumber,
-    });
-  }
-}

package/src/api/ethereum/cheat_codes.ts

@@ -1,184 +0,0 @@
-import type { ViemPublicClient } from '@aztec/ethereum';
-import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-import { RollupAbi } from '@aztec/l1-artifacts';
-
-import { type GetContractReturnType, type Hex, createPublicClient, fallback, getContract, http, keccak256 } from 'viem';
-import { foundry } from 'viem/chains';
-
-export { EthCheatCodes };
-
-/** Cheat codes for the L1 rollup contract. */
-export class RollupCheatCodes {
-  private client: ViemPublicClient;
-  private rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>;
-
-  private logger = createLogger('aztecjs:cheat_codes');
-
-  constructor(private ethCheatCodes: EthCheatCodes, addresses: Pick<L1ContractAddresses, 'rollupAddress'>) {
-    this.client = createPublicClient({
-      chain: foundry,
-      transport: fallback(ethCheatCodes.rpcUrls.map(url => http(url))),
-    });
-    this.rollup = getContract({
-      abi: RollupAbi,
-      address: addresses.rollupAddress.toString(),
-      client: this.client,
-    });
-  }
-
-  /** Returns the current slot */
-  public async getSlot() {
-    const ts = BigInt((await this.client.getBlock()).timestamp);
-    return await this.rollup.read.getSlotAt([ts]);
-  }
-
-  /** Returns the current epoch */
-  public async getEpoch() {
-    const slotNumber = await this.getSlot();
-    return await this.rollup.read.getEpochAtSlot([slotNumber]);
-  }
-
-  /**
-   * Returns the pending and proven chain tips
-   * @returns The pending and proven chain tips
-   */
-  public async getTips(): Promise<{
-    /** The pending chain tip */ pending: bigint;
-    /** The proven chain tip */ proven: bigint;
-  }> {
-    const res = await this.rollup.read.getTips();
-    return {
-      pending: res.pendingBlockNumber,
-      proven: res.provenBlockNumber,
-    };
-  }
-
-  /** Fetches the epoch and slot duration config from the rollup contract */
-  public async getConfig(): Promise<{
-    /** Epoch duration */ epochDuration: bigint;
-    /** Slot duration */ slotDuration: bigint;
-  }> {
-    const [epochDuration, slotDuration] = await Promise.all([
-      this.rollup.read.getEpochDuration(),
-      this.rollup.read.getSlotDuration(),
-    ]);
-    return { epochDuration, slotDuration };
-  }
-
-  /** Warps time in L1 until the next epoch */
-  public async advanceToNextEpoch() {
-    const slot = await this.getSlot();
-    const { epochDuration, slotDuration } = await this.getConfig();
-    const slotsUntilNextEpoch = epochDuration - (slot % epochDuration) + 1n;
-    const timeToNextEpoch = slotsUntilNextEpoch * slotDuration;
-    const l1Timestamp = BigInt((await this.client.getBlock()).timestamp);
-    await this.ethCheatCodes.warp(Number(l1Timestamp + timeToNextEpoch), true);
-    this.logger.warn(`Advanced to next epoch`);
-  }
-
-  /** Warps time in L1 until the beginning of the next slot. */
-  public async advanceToNextSlot() {
-    const currentSlot = await this.getSlot();
-    const timestamp = await this.rollup.read.getTimestampForSlot([currentSlot + 1n]);
-    await this.ethCheatCodes.warp(Number(timestamp));
-    this.logger.warn(`Advanced to slot ${currentSlot + 1n}`);
-    return [timestamp, currentSlot + 1n];
-  }
-
-  /**
-   * Warps time in L1 equivalent to however many slots.
-   * @param howMany - The number of slots to advance.
-   */
-  public async advanceSlots(howMany: number) {
-    const l1Timestamp = (await this.client.getBlock()).timestamp;
-    const slotDuration = await this.rollup.read.getSlotDuration();
-    const timeToWarp = BigInt(howMany) * slotDuration;
-    await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, true);
-    const [slot, epoch] = await Promise.all([this.getSlot(), this.getEpoch()]);
-    this.logger.warn(`Advanced ${howMany} slots up to slot ${slot} in epoch ${epoch}`);
-  }
-
-  /**
-   * Marks the specified block (or latest if none) as proven
-   * @param maybeBlockNumber - The block number to mark as proven (defaults to latest pending)
-   */
-  public async markAsProven(maybeBlockNumber?: number | bigint) {
-    const { pending, proven } = await this.getTips();
-
-    let blockNumber = maybeBlockNumber;
-    if (blockNumber === undefined || blockNumber > pending) {
-      blockNumber = pending;
-    }
-    if (blockNumber <= proven) {
-      this.logger.warn(`Block ${blockNumber} is already proven`);
-      return;
-    }
-
-    // @note @LHerskind this is heavily dependent on the storage layout and size of values
-    // The rollupStore is a struct and if the size of elements or the struct changes, this can break
-
-    // Convert string to bytes and then compute keccak256
-    const storageSlot = keccak256(Buffer.from('aztec.stf.storage', 'utf-8'));
-    const provenBlockNumberSlot = BigInt(storageSlot) + 1n;
-
-    const tipsBefore = await this.getTips();
-
-    await this.ethCheatCodes.store(
-      EthAddress.fromString(this.rollup.address),
-      provenBlockNumberSlot,
-      BigInt(blockNumber),
-    );
-
-    const tipsAfter = await this.getTips();
-    this.logger.info(
-      `Proven tip moved: ${tipsBefore.proven} -> ${tipsAfter.proven}. Pending tip: ${tipsAfter.pending}.`,
-    );
-  }
-
-  /**
-   * Executes an action impersonated as the owner of the Rollup contract.
-   * @param action - The action to execute
-   */
-  public async asOwner(
-    action: (owner: Hex, rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>) => Promise<void>,
-  ) {
-    const owner = await this.rollup.read.owner();
-    await this.ethCheatCodes.startImpersonating(owner);
-    await action(owner, this.rollup);
-    await this.ethCheatCodes.stopImpersonating(owner);
-  }
-
-  /** Directly calls the L1 gas fee oracle. */
-  public async updateL1GasFeeOracle() {
-    await this.asOwner(async (account, rollup) => {
-      const hash = await rollup.write.updateL1GasFeeOracle({ account, chain: this.client.chain });
-      await this.client.waitForTransactionReceipt({ hash });
-      this.logger.warn(`Updated L1 gas fee oracle`);
-    });
-  }
-
-  /**
-   * Bumps proving cost per mana.
-   * @param bumper - Callback to calculate the new proving cost per mana based on current value.
-   */
-  public async bumpProvingCostPerMana(bumper: (before: bigint) => bigint) {
-    const currentCost = await this.rollup.read.getProvingCostPerManaInEth();
-    const newCost = bumper(currentCost);
-    await this.setProvingCostPerMana(newCost);
-  }
-
-  /**
-   * Directly updates proving cost per mana.
-   * @param ethValue - The new proving cost per mana in ETH
-   */
-  public async setProvingCostPerMana(ethValue: bigint) {
-    await this.asOwner(async (account, rollup) => {
-      const hash = await rollup.write.setProvingCostPerMana([ethValue], { account, chain: this.client.chain });
-      await this.client.waitForTransactionReceipt({ hash });
-      this.logger.warn(`Updated proving cost per mana to ${ethValue}`);
-    });
-  }
-}

package/src/api/ethereum/index.ts

@@ -1,19 +0,0 @@
-export {
-  L1FeeJuicePortalManager,
-  L1ToL2TokenPortalManager,
-  L1TokenManager,
-  L1TokenPortalManager,
-  type L2AmountClaim,
-  type L2AmountClaimWithRecipient,
-  type L2Claim,
-  generateClaimSecret,
-} from './portal_manager.js';
-export { getL1ContractAddresses } from './l1_contracts.js';
-export { RollupCheatCodes, EthCheatCodes } from './cheat_codes.js';
-export { ChainMonitor } from './chain_monitor.js';
-export { AnvilTestWatcher } from './anvil_test_watcher.js';
-export {
-  deployL1Contract,
-  deployL1Contracts,
-  type DeployL1ContractsReturnType,
-} from '@aztec/ethereum/deploy-l1-contracts';

package/src/api/ethereum/l1_contracts.ts

@@ -1,21 +0,0 @@
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import { retryUntil } from '@aztec/foundation/retry';
-
-import { createPXEClient } from '../../rpc_clients/index.js';
-
-export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
-  const pxeClient = createPXEClient(url, {});
-  const response = await retryUntil(
-    async () => {
-      try {
-        return (await pxeClient.getNodeInfo()).l1ContractAddresses;
-      } catch (err) {
-        // do nothing
-      }
-    },
-    'isNodeReady',
-    120,
-    1,
-  );
-  return response;
-};

package/src/api/interfaces/pxe.ts

@@ -1 +0,0 @@
-export type { PXE } from '@aztec/stdlib/interfaces/client';

package/src/api/log_id.ts

@@ -1 +0,0 @@
-export { LogId } from '@aztec/stdlib/logs';

package/src/api/tx_hash.ts

@@ -1 +0,0 @@
-export { TxHash } from '@aztec/stdlib/tx';

package/src/contract/deploy_proven_tx.ts

@@ -1,34 +0,0 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { Tx } from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../account/index.js';
-import type { Contract } from './contract.js';
-import { DeploySentTx } from './deploy_sent_tx.js';
-import { ProvenTx } from './proven_tx.js';
-
-/**
- * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract deployment.
- */
-export class DeployProvenTx<TContract extends Contract = Contract> extends ProvenTx {
-  constructor(
-    wallet: PXE | Wallet,
-    tx: Tx,
-    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
-    private instanceGetter: () => Promise<ContractInstanceWithAddress>,
-  ) {
-    super(wallet, tx);
-  }
-
-  /**
-   * Sends the transaction to the network via the provided wallet.
-   */
-  public override send(): DeploySentTx<TContract> {
-    const promise = (() => {
-      return this.wallet.sendTx(this.getPlainDataTx());
-    })();
-
-    return new DeploySentTx(this.wallet, promise, this.postDeployCtor, this.instanceGetter);
-  }
-}

package/src/contract/deploy_sent_tx.ts

@@ -1,74 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-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 type { Contract } from './contract.js';
-import type { ContractBase } from './contract_base.js';
-import { SentTx, type WaitOpts } from './sent_tx.js';
-
-/** Options related to waiting for a deployment tx. */
-export type DeployedWaitOpts = WaitOpts & {
-  /** Wallet to use for creating a contract instance. Uses the one set in the deployer constructor if not set. */
-  wallet?: Wallet;
-};
-
-/** Extends a transaction receipt with a contract instance that represents the newly deployed contract. */
-export type DeployTxReceipt<TContract extends ContractBase = Contract> = FieldsOf<TxReceipt> & {
-  /** Instance of the newly deployed contract. */
-  contract: TContract;
-};
-
-/**
- * A contract deployment transaction sent to the network, extending SentTx with methods to create a contract instance.
- */
-export class DeploySentTx<TContract extends Contract = Contract> extends SentTx {
-  private log = createLogger('aztecjs:deploy_sent_tx');
-
-  constructor(
-    pxeOrWallet: PXE | Wallet,
-    txHashPromise: Promise<TxHash>,
-    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
-    /** A getter for the deployed contract instance */
-    public instanceGetter: () => Promise<ContractInstanceWithAddress>,
-  ) {
-    super(pxeOrWallet, 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 deployed(opts?: DeployedWaitOpts): Promise<TContract> {
-    const receipt = await this.wait(opts);
-    const instance = await this.instanceGetter();
-    this.log.info(`Contract ${instance.address.toString()} successfully deployed.`);
-    return receipt.contract;
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the receipt along with a contract 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 deployed contract instance.
-   */
-  public override async wait(opts?: DeployedWaitOpts): Promise<DeployTxReceipt<TContract>> {
-    const receipt = await super.wait(opts);
-    const contract = await this.getContractObject(opts?.wallet);
-    return { ...receipt, contract };
-  }
-
-  protected async getContractObject(wallet?: Wallet): Promise<TContract> {
-    const isWallet = (pxeOrWallet: PXE | Wallet | AztecNode): pxeOrWallet is Wallet =>
-      !!(pxeOrWallet as Wallet).createTxExecutionRequest;
-    const contractWallet = wallet ?? (isWallet(this.pxeOrNode) && this.pxeOrNode);
-    if (!contractWallet) {
-      throw new Error(`A wallet is required for creating a contract instance`);
-    }
-    const instance = await this.instanceGetter();
-    return this.postDeployCtor(instance.address, contractWallet) as Promise<TContract>;
-  }
-}

package/src/contract/index.ts

@@ -1,48 +0,0 @@
-/**
- * The `contract` module provides utilities for deploying and interacting with contracts, based on a
- * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
- * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/guides/smart_contracts/how_to_compile_contract | Compiling contracts}
- * section of the documentation for how to generate an artifact out of your Noir source code.
- *
- * The {@link Contract} class is the main class in this module, and provides static methods for deploying
- * a contract or interacting with an already deployed one. The `methods` property of the contract instance
- * provides access to private, public, and simulate methods, that can be invoked in a transaction via `send()`,
- * or can be queried via `simulate()`.
- *
- * ```ts
- * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
- * console.log(`Contract deployed at ${contract.address}`);
- * ```
- *
- * ```ts
- * const contract = await Contract.at(address, MyContractArtifact, wallet);
- * await contract.methods.mint(1000, owner).send().wait();
- * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
- * ```
- *
- * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
- * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
- * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
- * or obtaining the `request` for aggregating into a {@link BatchCall}.
- *
- * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
- * transaction hash, or simply `wait` until the transaction is mined and the local PXE Service
- * has synchronized its changes.
- *
- * @remarks If you are using typescript, consider using the
- * {@link https://docs.aztec.network/developers/guides/smart_contracts/how_to_compile_contract#typescript-interfaces | autogenerated type-safe interfaces}
- * for interacting with your contracts.
- *
- * @packageDocumentation
- */
-export { Contract } from './contract.js';
-export {
-  ContractFunctionInteraction,
-  type ProfileResult,
-  type SendMethodOptions,
-} from './contract_function_interaction.js';
-export { DefaultWaitOpts, SentTx, type WaitOpts } from './sent_tx.js';
-export { ContractBase, type ContractMethod, type ContractNotes, type ContractStorageLayout } from './contract_base.js';
-export { BatchCall } from './batch_call.js';
-export { type DeployOptions, DeployMethod } from './deploy_method.js';
-export { DeploySentTx } from './deploy_sent_tx.js';

package/src/contract/protocol_contracts.ts

@@ -1,35 +0,0 @@
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-
-import type { Wallet } from '../wallet/index.js';
-import { UnsafeContract } from './unsafe_contract.js';
-
-/** Returns a Contract wrapper for the class registerer. */
-export async function getRegistererContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractClassRegisterer);
-  if (!contractInstance) {
-    throw new Error("ContractClassRegisterer is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}
-
-/** Returns a Contract wrapper for the instance deployer. */
-export async function getDeployerContract(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.ContractInstanceDeployer);
-  if (!contractInstance) {
-    throw new Error("ContractInstanceDeployer is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}
-
-/** Returns a Contract wrapper for the fee juice */
-export async function getFeeJuice(wallet: Wallet) {
-  const { contractInstance } = await wallet.getContractMetadata(ProtocolContractAddress.FeeJuice);
-  if (!contractInstance) {
-    throw new Error("FeeJuice is not registered in this wallet's instance");
-  }
-  const { artifact } = await wallet.getContractClassMetadata(contractInstance.currentContractClassId, true);
-  return new UnsafeContract(contractInstance!, artifact!, wallet);
-}

package/src/contract/proven_tx.ts

@@ -1,42 +0,0 @@
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import { Tx } from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../account/index.js';
-import { SentTx } from './sent_tx.js';
-
-/**
- * A proven transaction that can be sent to the network. Returned by the `prove` method of a contract interaction.
- */
-export class ProvenTx extends Tx {
-  constructor(protected wallet: PXE | Wallet, tx: Tx) {
-    super(
-      tx.data,
-      tx.clientIvcProof,
-      tx.contractClassLogs,
-      tx.enqueuedPublicFunctionCalls,
-      tx.publicTeardownFunctionCall,
-    );
-  }
-
-  // Clone the TX data to get a serializable object.
-  protected getPlainDataTx(): Tx {
-    return new Tx(
-      this.data,
-      this.clientIvcProof,
-      this.contractClassLogs,
-      this.enqueuedPublicFunctionCalls,
-      this.publicTeardownFunctionCall,
-    );
-  }
-
-  /**
-   * Sends the transaction to the network via the provided wallet.
-   */
-  public send(): SentTx {
-    const promise = (() => {
-      return this.wallet.sendTx(this.getPlainDataTx());
-    })();
-
-    return new SentTx(this.wallet, promise);
-  }
-}