@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/dest/wallet/signerless_wallet.js

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

package/src/account_manager/account_manager.ts

@@ -1,276 +0,0 @@
-import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import { deriveKeys } from '@aztec/stdlib/keys';
-
-import type { AccountContract } from '../account/account_contract.js';
-import type { Salt } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
-import { Contract } from '../contract/contract.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { DefaultWaitOpts, type WaitOpts } from '../contract/sent_tx.js';
-import { AccountEntrypointMetaPaymentMethod } from '../fee/account_entrypoint_meta_payment_method.js';
-import { AztecAddress, FeeJuicePaymentMethod, type FeePaymentMethod } from '../index.js';
-import { AccountWalletWithSecretKey, SignerlessWallet, type Wallet } from '../wallet/index.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-
-/**
- * Options to deploy an account contract.
- */
-export type DeployAccountOptions = Pick<
-  DeployOptions,
-  'fee' | 'skipClassPublication' | 'skipInstancePublication' | 'skipInitialization'
-> & {
-  /**
-   * Wallet used for any txs to initialize and/or publish the account contract. Must be funded in order to pay for the fee.
-   */
-  deployWallet?: Wallet;
-};
-
-/**
- * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
- * and creating and registering the user wallet in the PXE Service.
- */
-export class AccountManager {
-  private constructor(
-    private pxe: PXE,
-    private secretKey: Fr,
-    private accountContract: AccountContract,
-    private instance: ContractInstanceWithAddress,
-    /**
-     * Contract instantiation salt for the account contract
-     */
-    public readonly salt: Salt,
-  ) {}
-
-  static async create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
-    const { publicKeys } = await deriveKeys(secretKey);
-    salt = salt !== undefined ? new Fr(salt) : Fr.random();
-
-    const { constructorName, constructorArgs } = (await accountContract.getInitializationFunctionAndArgs()) ?? {
-      constructorName: undefined,
-      constructorArgs: undefined,
-    };
-
-    const artifact = await accountContract.getContractArtifact();
-    const instance = await getContractInstanceFromInstantiationParams(artifact, {
-      constructorArtifact: constructorName,
-      constructorArgs,
-      salt: salt,
-      publicKeys,
-    });
-
-    return new AccountManager(pxe, secretKey, accountContract, instance, salt);
-  }
-
-  protected getPublicKeys() {
-    return this.instance.publicKeys;
-  }
-
-  protected getPublicKeysHash() {
-    return this.getPublicKeys().hash();
-  }
-
-  /**
-   * Returns the entrypoint for this account as defined by its account contract.
-   * @returns An entrypoint.
-   */
-  public async getAccount(): Promise<AccountInterface> {
-    const nodeInfo = await this.pxe.getNodeInfo();
-    const completeAddress = await this.getCompleteAddress();
-    return this.accountContract.getInterface(completeAddress, nodeInfo);
-  }
-
-  /**
-   * Gets the calculated complete address associated with this account.
-   * Does not require the account to have been published for public execution.
-   * @returns The address, partial address, and encryption public key.
-   */
-  public getCompleteAddress(): Promise<CompleteAddress> {
-    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
-  }
-
-  /**
-   * Gets the address for this given account.
-   * Does not require the account to have been published for public execution.
-   * @returns The address.
-   */
-  public getAddress() {
-    return this.instance.address;
-  }
-
-  /**
-   * Returns the contract instance definition associated with this account.
-   * Does not require the account to have been published for public execution.
-   * @returns ContractInstance instance.
-   */
-  public getInstance(): ContractInstanceWithAddress {
-    return this.instance;
-  }
-
-  /**
-   * Returns a Wallet instance associated with this account. Use it to create Contract
-   * instances to be interacted with from this account.
-   * @returns A Wallet instance.
-   */
-  public async getWallet(): Promise<AccountWalletWithSecretKey> {
-    const entrypoint = await this.getAccount();
-    return new AccountWalletWithSecretKey(this.pxe, entrypoint, this.secretKey, this.salt);
-  }
-
-  /**
-   * Add this account in the PXE Service and returns the associated wallet. Adding
-   * the account to the PXE Service is required for managing private state associated with it.
-   * Use the returned wallet to create Contract instances to be interacted with from this account.
-   * @param opts - Options to wait for the account to be synched.
-   * @returns A Wallet instance.
-   */
-  public async register(): Promise<AccountWalletWithSecretKey> {
-    await this.pxe.registerContract({
-      artifact: await this.accountContract.getContractArtifact(),
-      instance: this.getInstance(),
-    });
-
-    await this.pxe.registerAccount(this.secretKey, (await this.getCompleteAddress()).partialAddress);
-
-    return this.getWallet();
-  }
-
-  /**
-   * Returns the pre-populated ContractSetupMethods which can prepare a tx to
-   * initialize and/or publish this account's account contract (depending on the contract's design).
-   * If no wallet is provided, it uses a signerless wallet with the multi call entrypoint
-   * @param deployWallet - Wallet used for any txs that are needed to
-   * set up the account contract for use.
-   * @returns A ContractSetupMethods instance that can set up this account contract for use
-   */
-  public async getDeployMethod(deployWallet?: Wallet): Promise<DeployMethod> {
-    const artifact = await this.accountContract.getContractArtifact();
-
-    if (!(await this.hasInitializer())) {
-      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15576):
-      // there should be a path which enables an account contract's class & instance to be published,
-      // even if the account contract doesn't have an initializer function. This should not throw.
-      throw new Error(`Account contract ${artifact.name} does not have an initializer function to call.`);
-    }
-
-    const completeAddress = await this.getCompleteAddress();
-
-    await this.pxe.registerAccount(this.secretKey, completeAddress.partialAddress);
-
-    const { constructorName, constructorArgs } = (await this.accountContract.getInitializationFunctionAndArgs()) ?? {
-      constructorName: undefined,
-      constructorArgs: undefined,
-    };
-
-    if (deployWallet) {
-      // If deploying using an existing wallet/account, treat it like regular contract deployment.
-      const thisWallet = await this.getWallet();
-      return new DeployMethod(
-        this.getPublicKeys(),
-        deployWallet,
-        artifact,
-        address => Contract.at(address, artifact, thisWallet),
-        constructorArgs,
-        constructorName,
-      );
-    }
-
-    const { l1ChainId: chainId, rollupVersion } = await this.pxe.getNodeInfo();
-    // We use a signerless wallet with the multi call entrypoint in order to make multiple calls in one go.
-    // If we used getWallet, the deployment would get routed via the account contract entrypoint
-    // and it can't be used unless the contract is initialized.
-    const wallet = new SignerlessWallet(this.pxe, new DefaultMultiCallEntrypoint(chainId, rollupVersion));
-
-    return new DeployMethod(
-      this.getPublicKeys(),
-      wallet,
-      artifact,
-      address => Contract.at(address, artifact, wallet),
-      constructorArgs,
-      constructorName,
-    );
-  }
-
-  /**
-   * Returns a FeePaymentMethod that routes the original one provided as an argument
-   * through the account's entrypoint. This allows an account contract to pay
-   * for its own deployment and initialization.
-   *
-   * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
-   *
-   * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
-   * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
-   */
-  public async getSelfPaymentMethod(originalPaymentMethod?: FeePaymentMethod) {
-    const artifact = await this.accountContract.getContractArtifact();
-    const wallet = await this.getWallet();
-    const address = wallet.getAddress();
-    return new AccountEntrypointMetaPaymentMethod(
-      artifact,
-      wallet,
-      'entrypoint',
-      address,
-      originalPaymentMethod ?? new FeeJuicePaymentMethod(address),
-    );
-  }
-
-  /**
-   * Submits a tx to initialize and/or publish this account's account contract
-   * (depending on the contract's design).
-   * Doesn't necessarily publish the class nor publish the instance.
-   * Uses the salt provided in the constructor or a randomly generated one.
-   * Adds the account to the PXE Service first.
-   * @param opts - Fee options to be used for the deployment.
-   * @returns A SentTx object that can be waited to get the associated Wallet.
-   */
-  public deploy(opts?: DeployAccountOptions): DeployAccountSentTx {
-    let deployMethod: DeployMethod;
-    const sendTx = () =>
-      this.getDeployMethod(opts?.deployWallet)
-        .then(method => {
-          deployMethod = method;
-          if (!opts?.deployWallet && opts?.fee) {
-            return this.getSelfPaymentMethod(opts?.fee?.paymentMethod);
-          }
-        })
-        .then(maybeWrappedPaymentMethod => {
-          let fee = opts?.fee;
-          if (maybeWrappedPaymentMethod) {
-            fee = { ...opts?.fee, paymentMethod: maybeWrappedPaymentMethod };
-          }
-          return deployMethod.send({
-            from: opts?.deployWallet?.getAddress() ?? AztecAddress.ZERO,
-            contractAddressSalt: new Fr(this.salt),
-            skipClassPublication: opts?.skipClassPublication ?? true,
-            skipInstancePublication: opts?.skipInstancePublication ?? true,
-            skipInitialization: opts?.skipInitialization ?? false,
-            universalDeploy: true,
-            fee,
-          });
-        })
-        .then(tx => tx.getTxHash());
-    return new DeployAccountSentTx(this.pxe, sendTx, this.getWallet());
-  }
-
-  /**
-   * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
-   * Uses the salt provided in the constructor or a randomly generated one. If no initialization
-   * is required it skips the transaction, and only registers the account in the PXE Service.
-   * @param opts - Options to wait for the tx to be mined.
-   * @returns A Wallet instance.
-   */
-  public async waitSetup(opts: DeployAccountOptions & WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithSecretKey> {
-    await ((await this.hasInitializer()) ? this.deploy(opts).wait(opts) : this.register());
-    return this.getWallet();
-  }
-
-  /**
-   * Returns whether this account contract has an initializer function.
-   */
-  public async hasInitializer() {
-    return (await this.accountContract.getInitializationFunctionAndArgs()) !== undefined;
-  }
-}

package/src/account_manager/deploy_account_sent_tx.ts

@@ -1,46 +0,0 @@
-import type { FieldsOf } from '@aztec/foundation/types';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
-import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
-
-import { DefaultWaitOpts, SentTx, type WaitOpts } from '../contract/sent_tx.js';
-import type { Wallet } from '../wallet/wallet.js';
-
-/** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
-export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
-  /** Wallet that corresponds to the newly deployed account contract. */
-  wallet: Wallet;
-};
-
-/**
- * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
- */
-export class DeployAccountSentTx extends SentTx {
-  constructor(
-    pxeOrNode: AztecNode | PXE,
-    sendTx: () => Promise<TxHash>,
-    private getWalletPromise: Promise<Wallet>,
-  ) {
-    super(pxeOrNode, sendTx);
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The deployed contract instance.
-   */
-  public async getWallet(opts?: WaitOpts): Promise<Wallet> {
-    const receipt = await this.wait(opts);
-    return receipt.wallet;
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the receipt along with a wallet instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt with the wallet for the deployed account contract.
-   */
-  public override async wait(opts: WaitOpts = DefaultWaitOpts): Promise<DeployAccountTxReceipt> {
-    const receipt = await super.wait(opts);
-    const wallet = await this.getWalletPromise;
-    return { ...receipt, wallet };
-  }
-}

package/src/account_manager/index.ts

@@ -1,2 +0,0 @@
-export { AccountManager, type DeployAccountOptions } from './account_manager.js';
-export { type DeployAccountTxReceipt, DeployAccountSentTx } from './deploy_account_sent_tx.js';

package/src/api/interfaces.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/rpc.ts

@@ -1,2 +0,0 @@
-export { createPXEClient } from '../rpc_clients/pxe_client.js';
-export { createCompatibleClient } from '../rpc_clients/node/index.js';

package/src/api/tx_hash.ts

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

package/src/contract/deploy_proven_tx.ts

@@ -1,45 +0,0 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { OffchainEffect, ProvingStats, TxProvingResult } from '@aztec/stdlib/tx';
-import { Tx } from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../wallet/wallet.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 {
-  private constructor(
-    wallet: Wallet,
-    tx: Tx,
-    offchainEffects: OffchainEffect[],
-    private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
-    private instanceGetter: () => Promise<ContractInstanceWithAddress>,
-    stats?: ProvingStats,
-  ) {
-    super(wallet, tx, offchainEffects, stats);
-  }
-
-  static async fromProvingResult<TContract extends Contract = Contract>(
-    wallet: Wallet,
-    txProvingResult: TxProvingResult,
-    postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
-    instanceGetter: () => Promise<ContractInstanceWithAddress>,
-    stats?: ProvingStats,
-  ): Promise<DeployProvenTx<TContract>> {
-    const tx = await txProvingResult.toTx();
-    return new DeployProvenTx(wallet, tx, txProvingResult.getOffchainEffects(), postDeployCtor, instanceGetter, stats);
-  }
-
-  /**
-   * Sends the transaction to the network via the provided wallet.
-   */
-  public override send(): DeploySentTx<TContract> {
-    const sendTx = () => this.wallet.sendTx(this);
-
-    return new DeploySentTx(this.wallet, sendTx, this.postDeployCtor, this.instanceGetter);
-  }
-}

package/src/contract/proven_tx.ts

@@ -1,36 +0,0 @@
-import { type OffchainEffect, type ProvingStats, Tx } from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../wallet/wallet.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 {
-  #wallet: Wallet;
-
-  constructor(
-    wallet: Wallet,
-    tx: Tx,
-    /** The offchain effects emitted during the execution of the transaction. */
-    public offchainEffects: OffchainEffect[],
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    public stats?: ProvingStats,
-  ) {
-    super(tx.txHash, tx.data, tx.clientIvcProof, tx.contractClassLogFields, tx.publicFunctionCalldata);
-    this.#wallet = wallet;
-  }
-
-  protected get wallet(): Wallet {
-    return this.#wallet;
-  }
-
-  /**
-   * Sends the transaction to the network via the provided wallet.
-   */
-  public send(): SentTx {
-    const sendTx = () => this.#wallet.sendTx(this);
-
-    return new SentTx(this.#wallet, sendTx);
-  }
-}

package/src/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/pxe_client.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 {
-        // do nothing
-      }
-    },
-    'isNodeReady',
-    120,
-    1,
-  );
-  return response;
-};

package/src/fee/account_entrypoint_meta_payment_method.ts

@@ -1,89 +0,0 @@
-import {
-  EncodedAppEntrypointCalls,
-  EncodedCallsForEntrypoint,
-  computeCombinedPayloadHash,
-} from '@aztec/entrypoints/encoding';
-import type { AuthWitnessProvider, FeePaymentMethod } from '@aztec/entrypoints/interfaces';
-import { ExecutionPayload } from '@aztec/entrypoints/payload';
-import {
-  type ContractArtifact,
-  type FunctionArtifact,
-  FunctionCall,
-  FunctionSelector,
-  encodeArguments,
-  getFunctionArtifactByName,
-} from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { GasSettings } from '@aztec/stdlib/gas';
-
-/**
- * Fee payment method that allows a contract to pay for its own deployment
- * It works by rerouting the provided fee payment method through the account's entrypoint,
- * which sets itself as fee payer.
- *
- * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
- * that is sent to the user's account entrypoint, that has plumbing to handle a fee payload.
- * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
- * how to handle this payload.
- * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
- * being deployed with the original fee payload.
- *
- * This class can be seen in action in AccountManager.ts#getSelfPaymentMethod
- */
-export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
-  constructor(
-    private artifact: ContractArtifact,
-    private authWitnessProvider: AuthWitnessProvider,
-    private feePaymentNameOrArtifact: string | FunctionArtifact,
-    private accountAddress: AztecAddress,
-    private paymentMethod: FeePaymentMethod,
-  ) {}
-
-  getAsset(): Promise<AztecAddress> {
-    return this.paymentMethod.getAsset();
-  }
-
-  async getExecutionPayload(gasSettings: GasSettings): Promise<ExecutionPayload> {
-    const emptyAppCalls = await EncodedAppEntrypointCalls.fromAppExecution([]);
-    // Get the execution payload for the fee, it includes the calls and potentially authWitnesses
-    const { calls: feeCalls, authWitnesses: feeAuthwitnesses } =
-      await this.paymentMethod.getExecutionPayload(gasSettings);
-    // Encode the calls for the fee
-    const feePayer = await this.paymentMethod.getFeePayer(gasSettings);
-    const isFeePayer = feePayer.equals(this.accountAddress);
-    const feeEncodedCalls = await EncodedCallsForEntrypoint.fromFeeCalls(feeCalls, isFeePayer);
-
-    // Get the entrypoint args
-    const args = [emptyAppCalls, feeEncodedCalls, false];
-    const feePaymentArtifact =
-      typeof this.feePaymentNameOrArtifact === 'string'
-        ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact)
-        : this.feePaymentNameOrArtifact;
-
-    const entrypointCall = new FunctionCall(
-      feePaymentArtifact.name,
-      this.accountAddress,
-      await FunctionSelector.fromNameAndParameters(feePaymentArtifact.name, feePaymentArtifact.parameters),
-      feePaymentArtifact.functionType,
-      feePaymentArtifact.isStatic,
-      encodeArguments(feePaymentArtifact, args),
-      feePaymentArtifact.returnTypes,
-    );
-
-    // Compute the authwitness required to verify the combined payload
-    const combinedPayloadAuthWitness = await this.authWitnessProvider.createAuthWit(
-      await computeCombinedPayloadHash(emptyAppCalls, feeEncodedCalls),
-    );
-
-    return new ExecutionPayload(
-      [entrypointCall],
-      [combinedPayloadAuthWitness, ...feeAuthwitnesses],
-      [],
-      [...emptyAppCalls.hashedArguments, ...feeEncodedCalls.hashedArguments],
-    );
-  }
-
-  getFeePayer(gasSettings: GasSettings): Promise<AztecAddress> {
-    return this.paymentMethod.getFeePayer(gasSettings);
-  }
-}

package/src/fee/fee_juice_payment_method.ts

@@ -1,25 +0,0 @@
-import type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
-import { ExecutionPayload } from '@aztec/entrypoints/payload';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-// 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);
-  }
-
-  getExecutionPayload(): Promise<ExecutionPayload> {
-    return Promise.resolve(ExecutionPayload.empty());
-  }
-
-  getFeePayer(): Promise<AztecAddress> {
-    return Promise.resolve(this.sender);
-  }
-}

package/src/fee/utils.ts

@@ -1,39 +0,0 @@
-import { DefaultEntrypoint } from '@aztec/entrypoints/default';
-import { type FunctionAbi, decodeFromAbi } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { GasSettings } from '@aztec/stdlib/gas';
-
-import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import type { Wallet } from '../wallet/wallet.js';
-import { FeeJuicePaymentMethod } from './fee_juice_payment_method.js';
-
-/**
- * Use a wallet to simulate a function avoiding the wallet's entrypoint, as a SignerlessWallet would do
- * @param wallet - The wallet to use for the simulation.
- * @param contractAddress - The address of the contract to call.
- * @param abi - The ABI of the function to simulate.
- * @param args - The arguments to pass to the function.
- * @returns The return values of the function call.
- */
-export async function simulateWithoutSignature(
-  wallet: Wallet,
-  contractAddress: AztecAddress,
-  abi: FunctionAbi,
-  args: any[],
-) {
-  const interaction = new ContractFunctionInteraction(wallet, contractAddress, abi, args);
-
-  const request = await interaction.request();
-  const maxFeesPerGas = (await wallet.getCurrentBaseFees()).mul(1.5);
-  const paymentMethod = new FeeJuicePaymentMethod(AztecAddress.ZERO);
-  const gasSettings = GasSettings.default({ maxFeesPerGas });
-  const fee = { gasSettings, paymentMethod };
-
-  const { l1ChainId: chainId, rollupVersion } = await wallet.getNodeInfo();
-  const entrypoint = new DefaultEntrypoint(chainId, rollupVersion);
-  const signerlessTxExecutionRequest = await entrypoint.createTxExecutionRequest(request, fee, {});
-
-  const simulationResult = await wallet.simulateTx(signerlessTxExecutionRequest, false, undefined, true);
-  const rawReturnValues = simulationResult.getPrivateReturnValues().values;
-  return decodeFromAbi(abi.returnTypes, rawReturnValues!);
-}