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

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');
-    }
-  }
-}

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/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);
-  }
-}

package/src/deployment/deploy_instance.ts

@@ -1,31 +0,0 @@
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-
-import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getDeployerContract } from '../contract/protocol_contracts.js';
-import type { Wallet } from '../wallet/index.js';
-
-/**
- * Sets up a call to the canonical deployer contract to publicly deploy a contract instance.
- * @param wallet - The wallet to use for the deployment.
- * @param instance - The instance to deploy.
- */
-export async function deployInstance(
-  wallet: Wallet,
-  instance: ContractInstanceWithAddress,
-): Promise<ContractFunctionInteraction> {
-  const deployerContract = await getDeployerContract(wallet);
-  const { salt, currentContractClassId: contractClassId, publicKeys, deployer } = instance;
-  const isUniversalDeploy = deployer.isZero();
-  if (!isUniversalDeploy && !wallet.getAddress().equals(deployer)) {
-    throw new Error(
-      `Expected deployer ${deployer.toString()} does not match sender wallet ${wallet.getAddress().toString()}`,
-    );
-  }
-  return deployerContract.methods.deploy(
-    salt,
-    contractClassId,
-    instance.initializationHash,
-    publicKeys,
-    isUniversalDeploy,
-  );
-}

package/src/deployment/index.ts

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

package/src/deployment/register_class.ts

@@ -1,44 +0,0 @@
-import { MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS, REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type ContractArtifact, bufferAsFields } from '@aztec/stdlib/abi';
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import { Capsule } from '@aztec/stdlib/tx';
-
-import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { getRegistererContract } from '../contract/protocol_contracts.js';
-import type { Wallet } from '../wallet/index.js';
-
-const defaultEmitPublicBytecode =
-  // guard against `process` not being defined (e.g. in the browser)
-  typeof process === 'object' && typeof process.env === 'object'
-    ? ['1', 'true', 'yes', ''].includes(process.env.AZTEC_EMIT_PUBLIC_BYTECODE ?? '')
-    : true;
-
-/** Sets up a call to register a contract class given its artifact. */
-export async function registerContractClass(
-  wallet: Wallet,
-  artifact: ContractArtifact,
-  emitPublicBytecode = defaultEmitPublicBytecode,
-): Promise<ContractFunctionInteraction> {
-  const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
-    await getContractClassFromArtifact(artifact);
-  const registerer = await getRegistererContract(wallet);
-  const fn = registerer.methods.register(
-    artifactHash,
-    privateFunctionsRoot,
-    publicBytecodeCommitment,
-    emitPublicBytecode,
-  );
-
-  const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
-  fn.addCapsule(
-    new Capsule(
-      ProtocolContractAddress.ContractClassRegisterer,
-      new Fr(REGISTERER_CONTRACT_BYTECODE_CAPSULE_SLOT),
-      encodedBytecode,
-    ),
-  );
-
-  return fn;
-}