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

package/src/contract/sent_tx.ts

@@ -1,141 +0,0 @@
-import { retryUntil } from '@aztec/foundation/retry';
-import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecNode, GetPublicLogsResponse, PXE } from '@aztec/stdlib/interfaces/client';
-import { type TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
-
-/** Options related to waiting for a tx. */
-export type WaitOpts = {
-  /** The amount of time to ignore TxStatus.DROPPED receipts (in seconds) due to the presumption that it is being propagated by the p2p network. Defaults to 5. */
-  ignoreDroppedReceiptsFor?: number;
-  /** The maximum time (in seconds) to wait for the transaction to be mined. Defaults to 60. */
-  timeout?: number;
-  /** The maximum time (in seconds) to wait for the transaction to be proven. Defaults to 600. */
-  provenTimeout?: number;
-  /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
-  interval?: number;
-  /** Whether to wait for the tx to be proven. */
-  proven?: boolean;
-  /** Whether to include information useful for debugging/testing in the receipt. */
-  debug?: boolean;
-  /** Whether to accept a revert as a status code for the tx when waiting for it. If false, will throw if the tx reverts. */
-  dontThrowOnRevert?: boolean;
-};
-
-export const DefaultWaitOpts: WaitOpts = {
-  ignoreDroppedReceiptsFor: 5,
-  timeout: 60,
-  provenTimeout: 600,
-  interval: 1,
-  debug: false,
-};
-
-/**
- * The SentTx class represents a sent transaction through the PXE (or directly to a node) providing methods to fetch
- * its hash, receipt, and mining status.
- */
-export class SentTx {
-  constructor(protected pxeOrNode: PXE | AztecNode, protected txHashPromise: Promise<TxHash>) {}
-
-  /**
-   * Retrieves the transaction hash of the SentTx instance.
-   * The function internally awaits for the 'txHashPromise' to resolve, and then returns the resolved transaction hash.
-   *
-   * @returns A promise that resolves to the transaction hash of the SentTx instance.
-   * TODO(#7717): Don't throw here.
-   */
-  public getTxHash(): Promise<TxHash> {
-    return this.txHashPromise;
-  }
-
-  /**
-   * Retrieve the transaction receipt associated with the current SentTx instance.
-   * The function fetches the transaction hash using 'getTxHash' and then queries
-   * the PXE to get the corresponding transaction receipt.
-   *
-   * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
-   */
-  public async getReceipt(): Promise<TxReceipt> {
-    const txHash = await this.getTxHash();
-    return await this.pxeOrNode.getTxReceipt(txHash);
-  }
-
-  /**
-   * Awaits for a tx to be mined and returns the receipt. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt.
-   */
-  public async wait(opts?: WaitOpts): Promise<FieldsOf<TxReceipt>> {
-    const receipt = await this.waitForReceipt(opts);
-    if (receipt.status !== TxStatus.SUCCESS && !opts?.dontThrowOnRevert) {
-      throw new Error(
-        `Transaction ${await this.getTxHash()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
-      );
-    }
-    if (opts?.proven && receipt.blockNumber !== undefined) {
-      await this.waitForProven(receipt.blockNumber, opts);
-    }
-    if (opts?.debug) {
-      const txHash = await this.getTxHash();
-      const { data: tx } = (await this.pxeOrNode.getTxEffect(txHash))!;
-      receipt.debugInfo = {
-        noteHashes: tx.noteHashes,
-        nullifiers: tx.nullifiers,
-        publicDataWrites: tx.publicDataWrites,
-        l2ToL1Msgs: tx.l2ToL1Msgs,
-      };
-    }
-    return receipt;
-  }
-
-  /**
-   * Gets public logs emitted by this tx.
-   * @remarks This function will wait for the tx to be mined if it hasn't been already.
-   * @returns The requested logs.
-   */
-  public async getPublicLogs(): Promise<GetPublicLogsResponse> {
-    await this.wait();
-    return this.pxeOrNode.getPublicLogs({ txHash: await this.getTxHash() });
-  }
-
-  protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {
-    const txHash = await this.getTxHash();
-    const startTime = Date.now();
-    const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
-
-    return await retryUntil(
-      async () => {
-        const txReceipt = await this.pxeOrNode.getTxReceipt(txHash);
-        // If receipt is not yet available, try again
-        if (txReceipt.status === TxStatus.PENDING) {
-          return undefined;
-        }
-        // If the tx was "dropped", either return it or ignore based on timing.
-        // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
-        // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
-        if (txReceipt.status === TxStatus.DROPPED) {
-          const elapsedSeconds = (Date.now() - startTime) / 1000;
-          if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
-            return txReceipt;
-          }
-          return undefined;
-        }
-        return txReceipt;
-      },
-      'isMined',
-      opts?.timeout ?? DefaultWaitOpts.timeout,
-      opts?.interval ?? DefaultWaitOpts.interval,
-    );
-  }
-
-  protected async waitForProven(minedBlock: number, opts?: WaitOpts) {
-    return await retryUntil(
-      async () => {
-        const provenBlock = await this.pxeOrNode.getProvenBlockNumber();
-        return provenBlock >= minedBlock ? provenBlock : undefined;
-      },
-      'isProven',
-      opts?.provenTimeout ?? DefaultWaitOpts.provenTimeout,
-      opts?.interval ?? DefaultWaitOpts.interval,
-    );
-  }
-}

package/src/contract/unsafe_contract.ts

@@ -1,19 +0,0 @@
-import type { ContractArtifact } from '@aztec/stdlib/abi';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-
-import type { Wallet } from '../wallet/index.js';
-import { ContractBase } from './contract_base.js';
-
-/** Unsafe constructor for ContractBase that bypasses the check that the instance is registered in the wallet. */
-export class UnsafeContract extends ContractBase {
-  constructor(
-    /** The deployed contract instance definition. */
-    instance: ContractInstanceWithAddress,
-    /** The Application Binary Interface for the contract. */
-    artifact: ContractArtifact,
-    /** The wallet used for interacting with this contract. */
-    wallet: Wallet,
-  ) {
-    super(instance, artifact, wallet);
-  }
-}

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

package/src/entrypoint/payload.ts

@@ -1,238 +0,0 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import type { Tuple } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-import { FunctionCall, FunctionType } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasSettings } from '@aztec/stdlib/gas';
-import { HashedValues } from '@aztec/stdlib/tx';
-
-import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
-
-/**
- * Fee payment options for a transaction.
- */
-export type FeeOptions = {
-  /** The fee payment method to use */
-  paymentMethod: FeePaymentMethod;
-  /** The gas settings */
-  gasSettings: GasSettings;
-};
-
-// docs:start:user_fee_options
-/** Fee options as set by a user. */
-export type UserFeeOptions = {
-  /** The fee payment method to use */
-  paymentMethod?: FeePaymentMethod;
-  /** The gas settings */
-  gasSettings?: Partial<FieldsOf<GasSettings>>;
-  /** Percentage to pad the base fee by, if empty, defaults to 0.5 */
-  baseFeePadding?: number;
-  /** Whether to run an initial simulation of the tx with high gas limit to figure out actual gas settings. */
-  estimateGas?: boolean;
-  /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
-  estimatedGasPadding?: number;
-};
-// docs:end:user_fee_options
-
-// These must match the values defined in:
-// - noir-projects/aztec-nr/aztec/src/entrypoint/app.nr
-const APP_MAX_CALLS = 4;
-// - and noir-projects/aztec-nr/aztec/src/entrypoint/fee.nr
-const FEE_MAX_CALLS = 2;
-
-/* eslint-disable camelcase */
-/** Encoded function call for account contract entrypoint */
-type EncodedFunctionCall = {
-  /** Arguments hash for the call */
-  args_hash: Fr;
-  /** Selector of the function to call */
-  function_selector: Fr;
-  /** Address of the contract to call */
-  target_address: Fr;
-  /** Whether the function is public or private */
-  is_public: boolean;
-  /** Whether the function can alter state */
-  is_static: boolean;
-};
-/* eslint-enable camelcase */
-
-/** Assembles an entrypoint payload */
-export abstract class EntrypointPayload {
-  protected constructor(
-    private functionCalls: EncodedFunctionCall[],
-    private _hashedArguments: HashedValues[],
-    private generatorIndex: number,
-    private _nonce: Fr,
-  ) {}
-
-  protected static async create(functionCalls: FunctionCall[]) {
-    const hashedArguments: HashedValues[] = [];
-    for (const call of functionCalls) {
-      hashedArguments.push(await HashedValues.fromValues(call.args));
-    }
-
-    /* eslint-disable camelcase */
-    const encodedFunctionCalls = functionCalls.map((call, index) => ({
-      args_hash: hashedArguments[index].hash,
-      function_selector: call.selector.toField(),
-      target_address: call.to.toField(),
-      is_public: call.type == FunctionType.PUBLIC,
-      is_static: call.isStatic,
-    }));
-    /* eslint-enable camelcase */
-
-    return {
-      encodedFunctionCalls,
-      hashedArguments,
-    };
-  }
-
-  /* eslint-disable camelcase */
-  /**
-   * The function calls to execute. This uses snake_case naming so that it is compatible with Noir encoding
-   * @internal
-   */
-  get function_calls() {
-    return this.functionCalls;
-  }
-  /* eslint-enable camelcase */
-
-  /**
-   * The nonce
-   * @internal
-   */
-  get nonce() {
-    return this._nonce;
-  }
-
-  /**
-   * The hashed arguments for the function calls
-   */
-  get hashedArguments() {
-    return this._hashedArguments;
-  }
-
-  /**
-   * Serializes the payload to an array of fields
-   * @returns The fields of the payload
-   */
-  abstract toFields(): Fr[];
-
-  /**
-   * Hashes the payload
-   * @returns The hash of the payload
-   */
-  hash() {
-    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
-  }
-
-  /** Serializes the function calls to an array of fields. */
-  protected functionCallsToFields() {
-    return this.functionCalls.flatMap(call => [
-      call.args_hash,
-      call.function_selector,
-      call.target_address,
-      new Fr(call.is_public),
-      new Fr(call.is_static),
-    ]);
-  }
-
-  /**
-   * Creates an execution payload for a dapp from a set of function calls
-   * @param functionCalls - The function calls to execute
-   * @returns The execution payload
-   */
-  static async fromFunctionCalls(functionCalls: FunctionCall[]) {
-    const { encodedFunctionCalls, hashedArguments } = await this.create(functionCalls);
-    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, 0, Fr.random());
-  }
-
-  /**
-   * Creates an execution payload for the app-portion of a transaction from a set of function calls
-   * @param functionCalls - The function calls to execute
-   * @param nonce - The nonce for the payload, used to emit a nullifier identifying the call
-   * @returns The execution payload
-   */
-  static async fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>, nonce = Fr.random()) {
-    if (functionCalls.length > APP_MAX_CALLS) {
-      throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
-    }
-    const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
-    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
-    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, GeneratorIndex.SIGNATURE_PAYLOAD, nonce);
-  }
-
-  /**
-   * Creates an execution payload to pay the fee for a transaction
-   * @param sender - The address sending this payload
-   * @param feeOpts - The fee payment options
-   * @returns The execution payload
-   */
-  static async fromFeeOptions(sender: AztecAddress, feeOpts?: FeeOptions) {
-    const calls = (await feeOpts?.paymentMethod.getFunctionCalls(feeOpts?.gasSettings)) ?? [];
-    const feePayer = await feeOpts?.paymentMethod.getFeePayer(feeOpts?.gasSettings);
-    const isFeePayer = !!feePayer && feePayer.equals(sender);
-    const paddedCalls = padArrayEnd(calls, FunctionCall.empty(), FEE_MAX_CALLS);
-    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
-    return new FeeEntrypointPayload(
-      encodedFunctionCalls,
-      hashedArguments,
-      GeneratorIndex.FEE_PAYLOAD,
-      Fr.random(),
-      isFeePayer,
-    );
-  }
-}
-
-/** Entrypoint payload for app phase execution. */
-class AppEntrypointPayload extends EntrypointPayload {
-  override toFields(): Fr[] {
-    return [...this.functionCallsToFields(), this.nonce];
-  }
-}
-
-/** Entrypoint payload for fee payment to be run during setup phase. */
-class FeeEntrypointPayload extends EntrypointPayload {
-  #isFeePayer: boolean;
-
-  constructor(
-    functionCalls: EncodedFunctionCall[],
-    hashedArguments: HashedValues[],
-    generatorIndex: number,
-    nonce: Fr,
-    isFeePayer: boolean,
-  ) {
-    super(functionCalls, hashedArguments, generatorIndex, nonce);
-    this.#isFeePayer = isFeePayer;
-  }
-
-  override toFields(): Fr[] {
-    return [...this.functionCallsToFields(), this.nonce, new Fr(this.#isFeePayer)];
-  }
-
-  /* eslint-disable camelcase */
-  /** Whether the sender should be appointed as fee payer. */
-  get is_fee_payer() {
-    return this.#isFeePayer;
-  }
-  /* eslint-enable camelcase */
-}
-
-/**
- * Computes a hash of a combined payload.
- * @param appPayload - An app payload.
- * @param feePayload - A fee payload.
- * @returns A hash of a combined payload.
- */
-export async function computeCombinedPayloadHash(
-  appPayload: AppEntrypointPayload,
-  feePayload: FeeEntrypointPayload,
-): Promise<Fr> {
-  return poseidon2HashWithSeparator(
-    [await appPayload.hash(), await feePayload.hash()],
-    GeneratorIndex.COMBINED_PAYLOAD,
-  );
-}

package/src/fee/fee_juice_payment_method.ts

@@ -1,26 +0,0 @@
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { FunctionCall } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-import type { FeePaymentMethod } from './fee_payment_method.js';
-
-// docs:start:fee_juice_method
-/**
- * Pay fee directly in the Fee Juice.
- */
-export class FeeJuicePaymentMethod implements FeePaymentMethod {
-  // docs:end:fee_juice_method
-  constructor(protected sender: AztecAddress) {}
-
-  getAsset() {
-    return Promise.resolve(ProtocolContractAddress.FeeJuice);
-  }
-
-  getFunctionCalls(): Promise<FunctionCall[]> {
-    return Promise.resolve([]);
-  }
-
-  getFeePayer(): Promise<AztecAddress> {
-    return Promise.resolve(this.sender);
-  }
-}