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

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

package/src/entrypoint/default_entrypoint.ts

@@ -1,39 +0,0 @@
-import { FunctionType } from '@aztec/stdlib/abi';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import type { EntrypointInterface, ExecutionRequestInit } from './entrypoint.js';
-
-/**
- * Default implementation of the entrypoint interface. It calls a function on a contract directly
- */
-export class DefaultEntrypoint implements EntrypointInterface {
-  constructor(private chainId: number, private protocolVersion: number) {}
-
-  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { fee, calls, authWitnesses = [], hashedArguments = [], capsules = [] } = exec;
-
-    if (calls.length > 1) {
-      throw new Error(`Expected a single call, got ${calls.length}`);
-    }
-
-    const call = calls[0];
-
-    if (call.type !== FunctionType.PRIVATE) {
-      throw new Error('Public entrypoints are not allowed');
-    }
-
-    const entrypointHashedValues = await HashedValues.fromValues(call.args);
-    const txContext = new TxContext(this.chainId, this.protocolVersion, fee.gasSettings);
-    return Promise.resolve(
-      new TxExecutionRequest(
-        call.to,
-        call.selector,
-        entrypointHashedValues.hash,
-        txContext,
-        [...hashedArguments, entrypointHashedValues],
-        authWitnesses,
-        capsules,
-      ),
-    );
-  }
-}

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -1,93 +0,0 @@
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type FunctionAbi, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { HashedValues, TxContext, TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from './entrypoint.js';
-
-/**
- * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
- */
-export class DefaultMultiCallEntrypoint implements EntrypointInterface {
-  constructor(
-    private chainId: number,
-    private version: number,
-    private address: AztecAddress = ProtocolContractAddress.MultiCallEntrypoint,
-  ) {}
-
-  async createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
-    const { fee, calls, authWitnesses = [], hashedArguments = [], capsules = [] } = executions;
-    const payload = await EntrypointPayload.fromAppExecution(calls);
-    const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [payload]));
-
-    const txRequest = TxExecutionRequest.from({
-      firstCallArgsHash: entrypointHashedArgs.hash,
-      origin: this.address,
-      functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
-      txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
-      argsOfCalls: [...payload.hashedArguments, ...hashedArguments, entrypointHashedArgs],
-      authWitnesses,
-      capsules,
-    });
-
-    return Promise.resolve(txRequest);
-  }
-
-  private getEntrypointAbi() {
-    return {
-      name: 'entrypoint',
-      isInitializer: false,
-      functionType: 'private',
-      isInternal: false,
-      isStatic: false,
-      parameters: [
-        {
-          name: 'app_payload',
-          type: {
-            kind: 'struct',
-            path: 'authwit::entrypoint::app::AppPayload',
-            fields: [
-              {
-                name: 'function_calls',
-                type: {
-                  kind: 'array',
-                  length: 4,
-                  type: {
-                    kind: 'struct',
-                    path: 'authwit::entrypoint::function_call::FunctionCall',
-                    fields: [
-                      { name: 'args_hash', type: { kind: 'field' } },
-                      {
-                        name: 'function_selector',
-                        type: {
-                          kind: 'struct',
-                          path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
-                          fields: [{ name: 'inner', type: { kind: 'integer', sign: 'unsigned', width: 32 } }],
-                        },
-                      },
-                      {
-                        name: 'target_address',
-                        type: {
-                          kind: 'struct',
-                          path: 'authwit::aztec::protocol_types::address::AztecAddress',
-                          fields: [{ name: 'inner', type: { kind: 'field' } }],
-                        },
-                      },
-                      { name: 'is_public', type: { kind: 'boolean' } },
-                      { name: 'is_static', type: { kind: 'boolean' } },
-                    ],
-                  },
-                },
-              },
-              { name: 'nonce', type: { kind: 'field' } },
-            ],
-          },
-          visibility: 'public',
-        },
-      ],
-      returnTypes: [],
-      errorTypes: {},
-    } as FunctionAbi;
-  }
-}

package/src/entrypoint/entrypoint.ts

@@ -1,39 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { FunctionCall } from '@aztec/stdlib/abi';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { Capsule, HashedValues, TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import { EntrypointPayload, type FeeOptions, computeCombinedPayloadHash } from './payload.js';
-
-export { EntrypointPayload, type FeeOptions, computeCombinedPayloadHash };
-
-export { DefaultEntrypoint } from './default_entrypoint.js';
-export { DefaultMultiCallEntrypoint } from './default_multi_call_entrypoint.js';
-
-/** Encodes the calls to be done in a transaction. */
-export type ExecutionRequestInit = {
-  /** The function calls to be executed. */
-  calls: FunctionCall[];
-  /** Any transient auth witnesses needed for this execution */
-  authWitnesses?: AuthWitness[];
-  /** Any transient hashed arguments for this execution */
-  hashedArguments?: HashedValues[];
-  /** Data passed through an oracle for this execution. */
-  capsules?: Capsule[];
-  /** How the fee is going to be payed */
-  fee: FeeOptions;
-  /** An optional nonce. Used to repeat a previous tx with a higher fee so that the first one is cancelled */
-  nonce?: Fr;
-  /** Whether the transaction can be cancelled. If true, an extra nullifier will be emitted: H(nonce, GENERATOR_INDEX__TX_NULLIFIER) */
-  cancellable?: boolean;
-};
-
-/** Creates transaction execution requests out of a set of function calls. */
-export interface EntrypointInterface {
-  /**
-   * Generates an execution request out of set of function calls.
-   * @param execution - The execution intents to be run.
-   * @returns The authenticated transaction execution request.
-   */
-  createTxExecutionRequest(execution: ExecutionRequestInit): Promise<TxExecutionRequest>;
-}