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

package/src/cli/chain_l2_config.ts

@@ -1,74 +0,0 @@
-export type NetworkNames = 'testnet-ignition';
-
-export type L2ChainConfig = {
-  l1ChainId: number;
-  ethereumSlotDuration: number;
-  aztecSlotDuration: number;
-  aztecEpochDuration: number;
-  aztecProofSubmissionWindow: number;
-  testAccounts: boolean;
-  p2pEnabled: boolean;
-  p2pBootstrapNodes: string[];
-  registryAddress: string;
-  seqMinTxsPerBlock: number;
-  seqMaxTxsPerBlock: number;
-};
-
-export const testnetIgnitionL2ChainConfig: L2ChainConfig = {
-  l1ChainId: 11155111,
-  ethereumSlotDuration: 12,
-  aztecSlotDuration: 36,
-  aztecEpochDuration: 32,
-  aztecProofSubmissionWindow: 64,
-  testAccounts: true,
-  p2pEnabled: true,
-  p2pBootstrapNodes: [],
-  registryAddress: '0x12b3ebc176a1646b911391eab3760764f2e05fe3',
-  seqMinTxsPerBlock: 0,
-  seqMaxTxsPerBlock: 0,
-};
-
-export async function getBootnodes(networkName: NetworkNames) {
-  const url = `http://static.aztec.network/${networkName}/bootnodes.json`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch basic contract addresses from ${url}`);
-  }
-  const json = await response.json();
-  return json['bootnodes'];
-}
-
-export async function getL2ChainConfig(networkName: NetworkNames): Promise<L2ChainConfig | undefined> {
-  if (networkName === 'testnet-ignition') {
-    const config = { ...testnetIgnitionL2ChainConfig };
-    config.p2pBootstrapNodes = await getBootnodes(networkName);
-    return config;
-  }
-  return undefined;
-}
-
-function enrichVar(envVar: string, value: string) {
-  // Don't override
-  if (process.env[envVar]) {
-    return;
-  }
-  process.env[envVar] = value;
-}
-
-export async function enrichEnvironmentWithChainConfig(networkName: NetworkNames) {
-  const config = await getL2ChainConfig(networkName);
-  if (!config) {
-    throw new Error(`Unknown network name: ${networkName}`);
-  }
-  enrichVar('ETHEREUM_SLOT_DURATION', config.ethereumSlotDuration.toString());
-  enrichVar('AZTEC_SLOT_DURATION', config.aztecSlotDuration.toString());
-  enrichVar('AZTEC_EPOCH_DURATION', config.aztecEpochDuration.toString());
-  enrichVar('AZTEC_PROOF_SUBMISSION_WINDOW', config.aztecProofSubmissionWindow.toString());
-  enrichVar('P2P_BOOTSTRAP_NODES', config.p2pBootstrapNodes.join(','));
-  enrichVar('TEST_ACCOUNTS', config.testAccounts.toString());
-  enrichVar('P2P_ENABLED', config.p2pEnabled.toString());
-  enrichVar('L1_CHAIN_ID', config.l1ChainId.toString());
-  enrichVar('REGISTRY_CONTRACT_ADDRESS', config.registryAddress);
-  enrichVar('SEQ_MIN_TX_PER_BLOCK', config.seqMinTxsPerBlock.toString());
-  enrichVar('SEQ_MAX_TX_PER_BLOCK', config.seqMaxTxsPerBlock.toString());
-}

package/src/cli/cmds/start_blob_sink.ts

@@ -1,31 +0,0 @@
-import {
-  type BlobSinkConfig,
-  blobSinkConfigMappings,
-  createBlobSinkServer,
-  getBlobSinkConfigFromEnv,
-} from '@aztec/blob-sink/server';
-import type { LogFn } from '@aztec/foundation/log';
-import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
-
-import { extractRelevantOptions } from '../util.js';
-
-export async function startBlobSink(options: any, signalHandlers: (() => Promise<void>)[], userLog: LogFn) {
-  if (options.prover || options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
-    userLog(
-      `Starting a blob sink with --node, --sequencer, --pxe, --p2p-bootstrap, --prover or --txe is not supported.`,
-    );
-    process.exit(1);
-  }
-
-  const blobSinkConfig = {
-    ...getBlobSinkConfigFromEnv(), // get default config from env
-    ...extractRelevantOptions<BlobSinkConfig>(options, blobSinkConfigMappings, 'blobSink'), // override with command line options
-  };
-
-  const telemetry = initTelemetryClient(getTelemetryClientConfig());
-
-  const blobSink = await createBlobSinkServer(blobSinkConfig, telemetry);
-  signalHandlers.push(blobSink.stop.bind(blobSink));
-
-  await blobSink.start();
-}

package/src/cli/cmds/start_faucet.ts

@@ -1,34 +0,0 @@
-import {
-  Faucet,
-  FaucetSchema,
-  createFaucetHttpServer,
-  faucetConfigMapping,
-  getFaucetConfigFromEnv,
-} from '@aztec/aztec-faucet';
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import type { LogFn } from '@aztec/foundation/log';
-
-import { extractNamespacedOptions, extractRelevantOptions } from '../util.js';
-
-export async function startFaucet(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-  log: LogFn,
-) {
-  const faucetOptions = extractNamespacedOptions(options, 'faucet');
-  const config = {
-    ...getFaucetConfigFromEnv(),
-    ...extractRelevantOptions(options, faucetConfigMapping, 'faucet'),
-  };
-
-  const faucet = await Faucet.create(config);
-  if (faucetOptions.apiServer) {
-    const httpServer = createFaucetHttpServer(faucet);
-    httpServer.listen(faucetOptions.apiServerPort);
-    signalHandlers.push(() => new Promise(res => httpServer.close(() => res())));
-    log(`Faucet now running on port: ${faucetOptions.apiServerPort}`);
-  }
-
-  services.faucet = [faucet, FaucetSchema];
-}

package/src/cli/cmds/start_pxe.ts

@@ -1,129 +0,0 @@
-import {
-  AztecAddress,
-  type ContractArtifact,
-  type ContractInstanceWithAddress,
-  Fr,
-  PublicKeys,
-  getContractClassFromArtifact,
-} from '@aztec/aztec.js';
-import { getContractArtifact } from '@aztec/cli/cli-utils';
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import type { LogFn } from '@aztec/foundation/log';
-import {
-  type CliPXEOptions,
-  type PXEService,
-  type PXEServiceConfig,
-  allPxeConfigMappings,
-  createPXEService,
-} from '@aztec/pxe/server';
-import { type AztecNode, PXESchema, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-import { L2BasicContractsMap, Network } from '@aztec/stdlib/network';
-import { makeTracedFetch } from '@aztec/telemetry-client';
-
-import { extractRelevantOptions } from '../util.js';
-import { getVersions } from '../versioning.js';
-
-export type { PXEServiceConfig, CliPXEOptions };
-
-const contractAddressesUrl = 'http://static.aztec.network';
-
-export async function startPXE(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-  userLog: LogFn,
-): Promise<{ pxe: PXEService; config: PXEServiceConfig & CliPXEOptions }> {
-  return await addPXE(options, signalHandlers, services, userLog, {});
-}
-
-function isValidNetwork(value: any): value is Network {
-  return Object.values(Network).includes(value);
-}
-
-async function fetchBasicContractAddresses(url: string) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch basic contract addresses from ${url}`);
-  }
-  return response.json();
-}
-
-export async function addPXE(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-  userLog: LogFn,
-  deps: { node?: AztecNode } = {},
-): Promise<{ pxe: PXEService; config: PXEServiceConfig & CliPXEOptions }> {
-  const pxeConfig = extractRelevantOptions<PXEServiceConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
-
-  let nodeUrl;
-  if (pxeConfig.network) {
-    if (isValidNetwork(pxeConfig.network)) {
-      if (!pxeConfig.apiKey && !pxeConfig.nodeUrl) {
-        userLog(`API Key or Aztec Node URL is required to connect to ${pxeConfig.network}`);
-        process.exit(1);
-      } else if (pxeConfig.apiKey) {
-        nodeUrl = `https://api.aztec.network/${pxeConfig.network}/aztec-node-1/${pxeConfig.apiKey}`;
-      } else if (pxeConfig.nodeUrl) {
-        nodeUrl = pxeConfig.nodeUrl;
-      }
-    } else {
-      userLog(`Network ${pxeConfig.network} is not supported`);
-      process.exit(1);
-    }
-  } else {
-    nodeUrl = pxeConfig.nodeUrl;
-  }
-  if (!nodeUrl && !deps.node && !pxeConfig.network) {
-    userLog('Aztec Node URL (nodeUrl | AZTEC_NODE_URL) option is required to start PXE without --node option');
-    process.exit(1);
-  }
-
-  const node = deps.node ?? createAztecNodeClient(nodeUrl!, getVersions(pxeConfig), makeTracedFetch([1, 2, 3], true));
-  const pxe = await createPXEService(node, pxeConfig as PXEServiceConfig);
-
-  // register basic contracts
-  if (pxeConfig.network) {
-    userLog(`Registering basic contracts for ${pxeConfig.network}`);
-    const basicContractsInfo = await fetchBasicContractAddresses(
-      `${contractAddressesUrl}/${pxeConfig.network}/basic_contracts.json`,
-    );
-    const l2Contracts: Record<
-      string,
-      { name: string; address: AztecAddress; initHash: Fr; salt: Fr; artifact: ContractArtifact }
-    > = {};
-    for (const [key, artifactName] of Object.entries(L2BasicContractsMap[pxeConfig.network as Network])) {
-      l2Contracts[key] = {
-        name: key,
-        address: AztecAddress.fromString(basicContractsInfo[key].address),
-        initHash: Fr.fromHexString(basicContractsInfo[key].initHash),
-        salt: Fr.fromHexString(basicContractsInfo[key].salt),
-        artifact: await getContractArtifact(artifactName, userLog),
-      };
-    }
-
-    await Promise.all(
-      Object.values(l2Contracts).map(async ({ name, address, artifact, initHash, salt }) => {
-        const contractClass = await getContractClassFromArtifact(artifact!);
-        const instance: ContractInstanceWithAddress = {
-          version: 1,
-          salt,
-          initializationHash: initHash,
-          address,
-          deployer: AztecAddress.ZERO,
-          currentContractClassId: contractClass.id,
-          originalContractClassId: contractClass.id,
-          publicKeys: PublicKeys.default(),
-        };
-        userLog(`Registering ${name} at ${address.toString()}`);
-        await pxe.registerContract({ artifact, instance });
-      }),
-    );
-  }
-
-  // Add PXE to services list
-  services.pxe = [pxe, PXESchema];
-
-  return { pxe, config: pxeConfig };
-}

package/src/cli/get_l1_config.ts

@@ -1,18 +0,0 @@
-import { type L1ContractAddresses, RegistryContract, getL1ContractsConfig, getPublicClient } from '@aztec/ethereum';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-
-export async function getL1Config(
-  registryAddress: EthAddress,
-  l1RpcUrls: string[],
-  l1ChainId: number,
-): Promise<{ addresses: L1ContractAddresses; config: Awaited<ReturnType<typeof getL1ContractsConfig>> }> {
-  const publicClient = getPublicClient({ l1RpcUrls, l1ChainId });
-  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, 'canonical');
-
-  const config = await getL1ContractsConfig(publicClient, addresses);
-
-  return {
-    addresses,
-    config,
-  };
-}

package/src/sandbox/index.ts

@@ -1,5 +0,0 @@
-export * from './sandbox.js';
-
-export { getDeployedBananaCoinAddress, getDeployedBananaFPCAddress } from './banana_fpc.js';
-export { getDeployedSponsoredFPCAddress } from './sponsored_fpc.js';
-export { SponsoredFeePaymentMethod } from './sponsored_fee_payment_method.js';

package/src/sandbox/sandbox.ts

@@ -1,229 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
-import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AnvilTestWatcher, EthCheatCodes, SignerlessWallet } from '@aztec/aztec.js';
-import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
-import { setupCanonicalL2FeeJuice } from '@aztec/cli/setup-contracts';
-import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
-import {
-  NULL_KEY,
-  createEthereumChain,
-  deployL1Contracts,
-  getL1ContractsConfigEnvVars,
-  waitForPublicClient,
-} from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import {
-  type TelemetryClient,
-  getConfigEnvVars as getTelemetryClientConfig,
-  initTelemetryClient,
-} from '@aztec/telemetry-client';
-import { getGenesisValues } from '@aztec/world-state/testing';
-
-import { type HDAccount, type PrivateKeyAccount, createPublicClient, fallback, http as httpViemTransport } from 'viem';
-import { mnemonicToAccount } from 'viem/accounts';
-import { foundry } from 'viem/chains';
-
-import { createAccountLogs } from '../cli/util.js';
-import { DefaultMnemonic } from '../mnemonic.js';
-import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
-import { getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js';
-
-const logger = createLogger('sandbox');
-
-const localAnvil = foundry;
-
-/**
- * Function to deploy our L1 contracts to the sandbox L1
- * @param aztecNodeConfig - The Aztec Node Config
- * @param hdAccount - Account for publishing L1 contracts
- */
-export async function deployContractsToL1(
-  aztecNodeConfig: AztecNodeConfig,
-  hdAccount: HDAccount | PrivateKeyAccount,
-  contractDeployLogger = logger,
-  opts: { assumeProvenThroughBlockNumber?: number; salt?: number; genesisArchiveRoot?: Fr; genesisBlockHash?: Fr } = {},
-) {
-  const chain =
-    aztecNodeConfig.l1RpcUrls.length > 0
-      ? createEthereumChain(aztecNodeConfig.l1RpcUrls, aztecNodeConfig.l1ChainId)
-      : { chainInfo: localAnvil };
-
-  await waitForPublicClient(aztecNodeConfig);
-
-  const l1Contracts = await deployL1Contracts(
-    aztecNodeConfig.l1RpcUrls,
-    hdAccount,
-    chain.chainInfo,
-    contractDeployLogger,
-    {
-      ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
-      ...aztecNodeConfig,
-      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-      genesisBlockHash: opts.genesisBlockHash ?? new Fr(GENESIS_BLOCK_HASH),
-      salt: opts.salt,
-    },
-  );
-
-  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
-
-  return aztecNodeConfig.l1Contracts;
-}
-
-/** Sandbox settings. */
-export type SandboxConfig = AztecNodeConfig & {
-  /** Mnemonic used to derive the L1 deployer private key.*/
-  l1Mnemonic: string;
-  /** Salt used to deploy L1 contracts.*/
-  l1Salt: string;
-  /** Whether to expose PXE service on sandbox start.*/
-  noPXE: boolean;
-  /** Whether to deploy test accounts on sandbox start.*/
-  testAccounts: boolean;
-};
-
-/**
- * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
- * Does not start any HTTP services nor populate any initial accounts.
- * @param config - Optional Sandbox settings.
- */
-export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog: LogFn) {
-  // sandbox is meant for test envs. We should only need one l1RpcUrl
-  const l1RpcUrl = config.l1RpcUrls?.[0];
-  if (!l1RpcUrl) {
-    throw new Error('An L1 RPC URL is required');
-  }
-  if ((config.l1RpcUrls?.length || 0) > 1) {
-    logger.warn(`Multiple L1 RPC URLs provided. Sandbox will only use the first one: ${l1RpcUrl}`);
-  }
-  const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
-  const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
-  if (!aztecNodeConfig.publisherPrivateKey || aztecNodeConfig.publisherPrivateKey === NULL_KEY) {
-    const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
-  }
-  if (!aztecNodeConfig.validatorPrivateKey || aztecNodeConfig.validatorPrivateKey === NULL_KEY) {
-    const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.validatorPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
-  }
-
-  const initialAccounts = await (async () => {
-    if (config.testAccounts) {
-      if (aztecNodeConfig.p2pEnabled) {
-        userLog(`Not setting up test accounts as we are connecting to a network`);
-      } else if (config.noPXE) {
-        userLog(`Not setting up test accounts as we are not exposing a PXE`);
-      } else {
-        return await getInitialTestAccounts();
-      }
-    }
-    return [];
-  })();
-
-  const bananaFPC = await getBananaFPCAddress(initialAccounts);
-  const sponsoredFPC = await getSponsoredFPCAddress();
-  const fundedAddresses = initialAccounts.length
-    ? [...initialAccounts.map(a => a.address), bananaFPC, sponsoredFPC]
-    : [];
-  const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(fundedAddresses);
-
-  let watcher: AnvilTestWatcher | undefined = undefined;
-  if (!aztecNodeConfig.p2pEnabled) {
-    const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
-      assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
-      genesisArchiveRoot,
-      genesisBlockHash,
-      salt: config.l1Salt ? parseInt(config.l1Salt) : undefined,
-    });
-
-    const chain =
-      aztecNodeConfig.l1RpcUrls.length > 0
-        ? createEthereumChain([l1RpcUrl], aztecNodeConfig.l1ChainId)
-        : { chainInfo: localAnvil };
-
-    const publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
-    });
-
-    watcher = new AnvilTestWatcher(new EthCheatCodes([l1RpcUrl]), l1ContractAddresses.rollupAddress, publicClient);
-    watcher.setIsSandbox(true);
-    await watcher.start();
-  }
-
-  const telemetry = initTelemetryClient(getTelemetryClientConfig());
-  // Create a local blob sink client inside the sandbox, no http connectivity
-  const blobSinkClient = createBlobSinkClient();
-  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobSinkClient }, { prefilledPublicData });
-  const pxe = await createAztecPXE(node);
-
-  await setupCanonicalL2FeeJuice(
-    new SignerlessWallet(pxe),
-    aztecNodeConfig.l1Contracts.feeJuicePortalAddress,
-    undefined,
-    logger.info,
-  );
-
-  if (initialAccounts.length) {
-    userLog('Setting up funded test accounts...');
-    const accounts = await deployFundedSchnorrAccounts(pxe, initialAccounts);
-    const accountsWithSecrets = accounts.map((account, i) => ({
-      account,
-      secretKey: initialAccounts[i].secret,
-    }));
-    const accLogs = await createAccountLogs(accountsWithSecrets, pxe);
-    userLog(accLogs.join(''));
-
-    const deployer = await getSchnorrWallet(pxe, initialAccounts[0].address, initialAccounts[0].signingKey);
-    await setupBananaFPC(initialAccounts, deployer, userLog);
-    await setupSponsoredFPC(deployer, userLog);
-  }
-
-  const stop = async () => {
-    await node.stop();
-    await watcher?.stop();
-  };
-
-  return { node, pxe, stop };
-}
-
-/**
- * Create and start a new Aztec RPC HTTP Server
- * @param config - Optional Aztec node settings.
- */
-export async function createAztecNode(
-  config: Partial<AztecNodeConfig> = {},
-  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface } = {},
-  options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
-) {
-  // TODO(#12272): will clean this up. This is criminal.
-  const { l1Contracts, ...rest } = getConfigEnvVars();
-  const aztecNodeConfig: AztecNodeConfig = {
-    ...rest,
-    ...config,
-    l1Contracts: { ...l1Contracts, ...config.l1Contracts },
-  };
-  logger.info('createAztecNode', aztecNodeConfig);
-  const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
-  return node;
-}
-
-/**
- * Create and start a new Aztec PXE HTTP Server
- * @param config - Optional PXE settings.
- */
-export async function createAztecPXE(node: AztecNode, config: Partial<PXEServiceConfig> = {}) {
-  const pxeServiceConfig: PXEServiceConfig = { ...getPXEServiceConfig(), ...config };
-  const pxe = await createPXEService(node, pxeServiceConfig);
-  return pxe;
-}

package/src/sandbox/sponsored_fee_payment_method.ts

@@ -1,46 +0,0 @@
-import type { FeePaymentMethod } from '@aztec/aztec.js';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-import { getDeployedSponsoredFPCAddress } from './sponsored_fpc.js';
-
-/**
- * A payment method that uses the SponsoredFPCContract to pay the fee unconditionally.
- */
-export class SponsoredFeePaymentMethod implements FeePaymentMethod {
-  constructor(
-    /**
-     * Contract which will pay the fee.
-     */
-    private paymentContract: AztecAddress,
-  ) {}
-
-  static async new(pxe: PXE) {
-    const sponsoredFPC = await getDeployedSponsoredFPCAddress(pxe);
-    return new SponsoredFeePaymentMethod(sponsoredFPC);
-  }
-
-  getAsset(): Promise<AztecAddress> {
-    return Promise.resolve(ProtocolContractAddress.FeeJuice);
-  }
-
-  getFeePayer(): Promise<AztecAddress> {
-    return Promise.resolve(this.paymentContract);
-  }
-
-  async getFunctionCalls(): Promise<FunctionCall[]> {
-    return [
-      {
-        name: 'sponsor_unconditionally',
-        to: this.paymentContract,
-        selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'),
-        type: FunctionType.PRIVATE,
-        isStatic: false,
-        args: [],
-        returnTypes: [],
-      },
-    ];
-  }
-}

package/src/sandbox/sponsored_fpc.ts

@@ -1,38 +0,0 @@
-import {
-  type ContractInstanceWithAddress,
-  Fr,
-  type PXE,
-  type Wallet,
-  getContractInstanceFromDeployParams,
-} from '@aztec/aztec.js';
-import type { LogFn } from '@aztec/foundation/log';
-import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
-
-const SPONSORED_FPC_SALT = new Fr(0);
-
-async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
-  return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, {
-    salt: SPONSORED_FPC_SALT,
-  });
-}
-
-export async function getSponsoredFPCAddress() {
-  return (await getSponsoredFPCInstance()).address;
-}
-
-export async function setupSponsoredFPC(deployer: Wallet, log: LogFn) {
-  const deployed = await SponsoredFPCContract.deploy(deployer)
-    .send({ contractAddressSalt: SPONSORED_FPC_SALT, universalDeploy: true })
-    .deployed();
-
-  log(`SponsoredFPC: ${deployed.address}`);
-}
-
-export async function getDeployedSponsoredFPCAddress(pxe: PXE) {
-  const fpc = await getSponsoredFPCAddress();
-  const contracts = await pxe.getContracts();
-  if (!contracts.find(c => c.equals(fpc))) {
-    throw new Error('SponsoredFPC not deployed.');
-  }
-  return fpc;
-}