@aztec/aztec 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/examples/token.ts

@@ -1,13 +1,14 @@
-import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
-import { createPXEClient } from '@aztec/aztec.js';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import { createLogger } from '@aztec/foundation/log';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 const logger = createLogger('example:token');
 
-const url = 'http://localhost:8080';
+const nodeUrl = 'http://localhost:8080';
 
-const pxe = createPXEClient(url);
+const node = createAztecNodeClient(nodeUrl);
 
 const ALICE_MINT_BALANCE = 333n;
 const TRANSFER_AMOUNT = 33n;
@@ -18,39 +19,42 @@ const TRANSFER_AMOUNT = 33n;
 async function main() {
   logger.info('Running token contract test on HTTP interface.');
 
-  const [aliceWallet, bobWallet] = await getDeployedTestAccountsWallets(pxe);
-  const alice = aliceWallet.getCompleteAddress();
-  const bob = bobWallet.getCompleteAddress();
+  const wallet = await EmbeddedWallet.create(node);
 
-  logger.info(`Fetched Alice and Bob accounts: ${alice.address.toString()}, ${bob.address.toString()}`);
+  // During local network setup we deploy a few accounts. Below we add them to our wallet.
+  const [aliceInitialAccountData, bobInitialAccountData] = await getInitialTestAccountsData();
+  await wallet.createSchnorrAccount(aliceInitialAccountData.secret, aliceInitialAccountData.salt);
+  await wallet.createSchnorrAccount(bobInitialAccountData.secret, bobInitialAccountData.salt);
+
+  const alice = aliceInitialAccountData.address;
+  const bob = bobInitialAccountData.address;
+
+  logger.info(`Fetched Alice and Bob accounts: ${alice.toString()}, ${bob.toString()}`);
 
   logger.info('Deploying Token...');
-  const token = await TokenContract.deploy(aliceWallet, alice, 'TokenName', 'TokenSymbol', 18).send().deployed();
+  const { contract: token } = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({
+    from: alice,
+  });
   logger.info('Token deployed');
 
-  // Create the contract abstraction and link it to Alice's and Bob's wallet for future signing
-  const tokenAlice = await TokenContract.at(token.address, aliceWallet);
-  const tokenBob = await TokenContract.at(token.address, bobWallet);
-
   // Mint tokens to Alice
   logger.info(`Minting ${ALICE_MINT_BALANCE} more coins to Alice...`);
-  const from = aliceWallet.getAddress(); // we are setting from to Alice here because we need a sender to calculate the tag
-  await tokenAlice.methods.mint_to_private(from, aliceWallet.getAddress(), ALICE_MINT_BALANCE).send().wait();
+  await token.methods.mint_to_private(alice, ALICE_MINT_BALANCE).send({ from: alice });
 
   logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
 
-  const balanceAfterMint = await tokenAlice.methods.balance_of_private(alice).simulate();
+  const { result: balanceAfterMint } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Tokens successfully minted. New Alice's balance: ${balanceAfterMint}`);
 
   // We will now transfer tokens from Alice to Bob
   logger.info(`Transferring ${TRANSFER_AMOUNT} tokens from Alice to Bob...`);
-  await tokenAlice.methods.transfer(bob, TRANSFER_AMOUNT).send().wait();
+  await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice });
 
   // Check the new balances
-  const aliceBalance = await tokenAlice.methods.balance_of_private(alice).simulate();
+  const { result: aliceBalance } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Alice's balance ${aliceBalance}`);
 
-  const bobBalance = await tokenBob.methods.balance_of_private(bob).simulate();
+  const { result: bobBalance } = await token.methods.balance_of_private(bob).simulate({ from: bob });
   logger.info(`Bob's balance ${bobBalance}`);
 }
 

package/src/examples/util.ts

@@ -1,5 +1,5 @@
-import { EthAddress } from '@aztec/aztec.js';
-import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 import type { Abi, Narrow } from 'abitype';
@@ -7,27 +7,25 @@ import type { Hex } from 'viem';
 
 /**
  * Helper function to deploy ETH contracts.
- * @param walletClient - A viem WalletClient.
- * @param publicClient - A viem PublicClient.
+ * @param l1Client - A viem WalletClient extended with public actions.
  * @param abi - The ETH contract's ABI (as abitype's Abi).
  * @param bytecode  - The ETH contract's bytecode.
  * @param args - Constructor arguments for the contract.
  * @returns The ETH address the contract was deployed to.
  */
 export async function deployL1Contract(
-  walletClient: ViemWalletClient,
-  publicClient: ViemPublicClient,
+  l1Client: ExtendedViemWalletClient,
   abi: Narrow<Abi | readonly unknown[]>,
   bytecode: Hex,
   args: readonly unknown[] = [],
 ): Promise<EthAddress> {
-  const hash = await walletClient.deployContract({
+  const hash = await l1Client.deployContract({
     abi,
     bytecode,
     args,
   });
 
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const receipt = await l1Client.waitForTransactionReceipt({ hash });
   const contractAddress = receipt.contractAddress;
   if (!contractAddress) {
     throw new Error(`No contract address found in receipt: ${jsonStringify(receipt)}`);

package/src/index.ts

@@ -1,7 +1,6 @@
 export {
-  createSandbox,
-  getDeployedBananaCoinAddress,
-  getDeployedBananaFPCAddress,
-  getDeployedSponsoredFPCAddress,
-  SponsoredFeePaymentMethod,
-} from './sandbox/index.js';
+  createLocalNetwork,
+  registerDeployedBananaCoinInWalletAndGetAddress,
+  registerDeployedBananaFPCInWalletAndGetAddress,
+  registerDeployedSponsoredFPCInWalletAndGetAddress,
+} from './local-network/index.js';

package/src/local-network/auth_registry.ts

@@ -0,0 +1,19 @@
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { AuthRegistryArtifact, getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+export async function publishStandardAuthRegistry(
+  wallet: Wallet,
+  from: AztecAddress,
+  waitOpts?: WaitOpts,
+): Promise<void> {
+  const { instance, contractClass } = await getStandardAuthRegistry();
+  if (!(await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, AuthRegistryArtifact)).send({ from, wait: waitOpts });
+  }
+  if (!(await wallet.getContractMetadata(instance.address)).isContractPublished) {
+    await publishInstance(wallet, instance).send({ from, wait: waitOpts });
+  }
+}

package/src/{sandbox → local-network}/banana_fpc.ts

@@ -1,12 +1,12 @@
-import { type InitialAccountData, getInitialTestAccounts } from '@aztec/accounts/testing';
-import type { Wallet } from '@aztec/aztec.js';
-import { Fr } from '@aztec/foundation/fields';
+import { type InitialAccountData, getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type ContractInstanceWithAddress, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import { type ContractInstanceWithAddress, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 
 const BANANA_COIN_SALT = new Fr(0);
 const bananaCoinArgs = {
@@ -23,7 +23,7 @@ function getBananaAdmin(initialAccounts: InitialAccountData[]): AztecAddress {
 
 async function getBananaCoinInstance(initialAccounts: InitialAccountData[]): Promise<ContractInstanceWithAddress> {
   const admin = getBananaAdmin(initialAccounts);
-  return await getContractInstanceFromDeployParams(TokenContract.artifact, {
+  return await getContractInstanceFromInstantiationParams(TokenContract.artifact, {
     constructorArgs: [admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal],
     salt: BANANA_COIN_SALT,
   });
@@ -36,7 +36,7 @@ export async function getBananaCoinAddress(initialAccounts: InitialAccountData[]
 async function getBananaFPCInstance(initialAccounts: InitialAccountData[]): Promise<ContractInstanceWithAddress> {
   const bananaCoin = await getBananaCoinAddress(initialAccounts);
   const admin = getBananaAdmin(initialAccounts);
-  return await getContractInstanceFromDeployParams(FPCContract.artifact, {
+  return await getContractInstanceFromInstantiationParams(FPCContract.artifact, {
     constructorArgs: [bananaCoin, admin],
     salt: BANANA_FPC_SALT,
   });
@@ -46,38 +46,41 @@ export async function getBananaFPCAddress(initialAccounts: InitialAccountData[])
   return (await getBananaFPCInstance(initialAccounts)).address;
 }
 
-export async function setupBananaFPC(initialAccounts: InitialAccountData[], deployer: Wallet, log: LogFn) {
+export async function setupBananaFPC(
+  initialAccounts: InitialAccountData[],
+  wallet: Wallet,
+  log: LogFn,
+  waitOpts?: WaitOpts,
+) {
   const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
   const admin = getBananaAdmin(initialAccounts);
-  const [bananaCoin, fpc] = await Promise.all([
-    TokenContract.deploy(deployer, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal)
-      .send({ contractAddressSalt: BANANA_COIN_SALT, universalDeploy: true })
-      .deployed(),
-    FPCContract.deploy(deployer, bananaCoinAddress, admin)
-      .send({ contractAddressSalt: BANANA_FPC_SALT, universalDeploy: true })
-      .deployed(),
+  const [{ contract: bananaCoin }, { contract: fpc }] = await Promise.all([
+    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal, {
+      salt: BANANA_COIN_SALT,
+      universalDeploy: true,
+    }).send({ from: admin, wait: waitOpts }),
+    FPCContract.deploy(wallet, bananaCoinAddress, admin, { salt: BANANA_FPC_SALT, universalDeploy: true }).send({
+      from: admin,
+      wait: waitOpts,
+    }),
   ]);
 
   log(`BananaCoin: ${bananaCoin.address}`);
   log(`FPC: ${fpc.address}`);
 }
 
-export async function getDeployedBananaCoinAddress(pxe: PXE) {
-  const initialAccounts = await getInitialTestAccounts();
-  const bananaCoin = await getBananaCoinAddress(initialAccounts);
-  const contracts = await pxe.getContracts();
-  if (!contracts.find(c => c.equals(bananaCoin))) {
-    throw new Error('BananaCoin not deployed.');
-  }
-  return bananaCoin;
+export async function registerDeployedBananaCoinInWalletAndGetAddress(wallet: Wallet) {
+  const initialAccounts = await getInitialTestAccountsData();
+  const bananaCoin = await getBananaCoinInstance(initialAccounts);
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(bananaCoin, TokenContract.artifact);
+  return bananaCoin.address;
 }
 
-export async function getDeployedBananaFPCAddress(pxe: PXE) {
-  const initialAccounts = await getInitialTestAccounts();
+export async function registerDeployedBananaFPCInWalletAndGetAddress(wallet: Wallet) {
+  const initialAccounts = await getInitialTestAccountsData();
   const fpc = await getBananaFPCInstance(initialAccounts);
-  const contracts = await pxe.getContracts();
-  if (!contracts.find(c => c.equals(fpc.address))) {
-    throw new Error('BananaFPC not deployed.');
-  }
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(fpc, FPCContract.artifact);
   return fpc.address;
 }

package/src/local-network/index.ts

@@ -0,0 +1,7 @@
+export * from './local-network.js';
+
+export {
+  registerDeployedBananaCoinInWalletAndGetAddress,
+  registerDeployedBananaFPCInWalletAndGetAddress,
+} from './banana_fpc.js';
+export { registerDeployedSponsoredFPCInWalletAndGetAddress } from './sponsored_fpc.js';

package/src/local-network/local-network.ts

@@ -0,0 +1,303 @@
+#!/usr/bin/env -S node --no-warnings
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { waitForPublicClient } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { NULL_KEY } from '@aztec/ethereum/constants';
+import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { SequencerState } from '@aztec/sequencer-client';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { TxStatus } from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
+import {
+  type TelemetryClient,
+  getConfigEnvVars as getTelemetryClientConfig,
+  initTelemetryClient,
+} from '@aztec/telemetry-client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { createAccountLogs } from '../cli/util.js';
+import { DefaultMnemonic } from '../mnemonic.js';
+import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
+import { EpochTestSettler } from '../testing/epoch_test_settler.js';
+import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
+import { publishStandardAuthRegistry } from './auth_registry.js';
+import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
+import { getSponsoredFPCAddress } from './sponsored_fpc.js';
+
+const logger = createLogger('local-network');
+
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = { waitForStatus: TxStatus.CHECKPOINTED };
+
+const localAnvil = foundry;
+
+/**
+ * Function to deploy our L1 contracts to the local network L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */
+export async function deployContractsToL1(
+  aztecNodeConfig: AztecNodeConfig,
+  privateKey: Hex,
+  opts: {
+    genesisArchiveRoot?: Fr;
+    feeJuicePortalInitialBalance?: bigint;
+  } = {},
+): Promise<L1ContractAddresses> {
+  await waitForPublicClient(aztecNodeConfig);
+
+  const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
+    ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
+    ...aztecNodeConfig,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+    feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+    aztecTargetCommitteeSize: 0, // no committee in local network
+    slasherEnabled: false, // no slashing in local network
+    realVerifier: false,
+  });
+
+  Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
+  aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
+
+  return l1Contracts.l1ContractAddresses;
+}
+
+/** Local network settings. */
+export type LocalNetworkConfig = AztecNodeConfig & {
+  /** Mnemonic used to derive the L1 deployer private key.*/
+  l1Mnemonic: string;
+  /** Whether to deploy test accounts on local network 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 local network settings.
+ */
+export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {}, userLog: LogFn) {
+  // local network 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. Local networks will only use the first one: ${l1RpcUrl}`);
+  }
+
+  // The local network deploys a banana FPC with Token contracts, so include Token entries
+  // in the setup allowlist so FPC-based fee payments work out of the box.
+  const tokenAllowList = await getTokenAllowedSetupFunctions();
+
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...config,
+    txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
+  };
+  const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
+  if (
+    aztecNodeConfig.sequencerPublisherPrivateKeys == undefined ||
+    !aztecNodeConfig.sequencerPublisherPrivateKeys.length ||
+    aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY
+  ) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.sequencerPublisherPrivateKeys = [
+      new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const),
+    ];
+  }
+  if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${Buffer.from(privKey!).toString('hex')}`]);
+  }
+  aztecNodeConfig.coinbase = EthAddress.fromString(
+    privateKeyToAddress(aztecNodeConfig.validatorPrivateKeys.getValue()[0]),
+  );
+
+  const initialAccounts = await (async () => {
+    if (config.testAccounts === true || config.testAccounts === undefined) {
+      if (aztecNodeConfig.p2pEnabled) {
+        userLog(`Not setting up test accounts as we are connecting to a network`);
+      } else {
+        userLog(`Setting up test accounts`);
+        return await getInitialTestAccountsData();
+      }
+    }
+    return [];
+  })();
+
+  const bananaFPC = await getBananaFPCAddress(initialAccounts);
+  const sponsoredFPC = await getSponsoredFPCAddress();
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const fundedAddresses = [
+    ...initialAccounts.map(a => a.address),
+    ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
+    ...prefundAddresses,
+  ];
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses);
+
+  const dateProvider = new TestDateProvider();
+
+  let cheatcodes: EthCheatCodes | undefined;
+  let rollupAddress: EthAddress | undefined;
+  let watcher: AnvilTestWatcher | undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    ({ rollupAddress } = await deployContractsToL1(
+      aztecNodeConfig,
+      aztecNodeConfig.validatorPrivateKeys.getValue()[0],
+      {
+        genesisArchiveRoot,
+        feeJuicePortalInitialBalance: fundingNeeded,
+      },
+    ));
+
+    const chain =
+      aztecNodeConfig.l1RpcUrls.length > 0
+        ? createEthereumChain([l1RpcUrl], aztecNodeConfig.l1ChainId)
+        : { chainInfo: localAnvil };
+
+    const publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
+    });
+
+    cheatcodes = new EthCheatCodes([l1RpcUrl], dateProvider);
+
+    watcher = new AnvilTestWatcher(cheatcodes, rollupAddress, publicClient, dateProvider);
+    watcher.setisLocalNetwork(true);
+    watcher.setIsMarkingAsProven(false); // Do not mark as proven in the watcher. It's marked in the epochTestSettler after the out hash is set.
+
+    await watcher.start();
+  }
+
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob client client inside the local network, no http connectivity
+  const blobClient = createBlobClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
+
+  // Now that the node is up, let the watcher check for pending txs so it can skip unfilled slots faster when
+  // transactions are waiting in the mempool. Also let it check if the sequencer is actively building, to avoid
+  // warping time out from under an in-progress block.
+  watcher?.setGetPendingTxCount(() => node.getPendingTxCount());
+  const sequencer = node.getSequencer()?.getSequencer();
+  if (sequencer) {
+    const idleStates: Set<string> = new Set([
+      SequencerState.STOPPED,
+      SequencerState.STOPPING,
+      SequencerState.IDLE,
+      SequencerState.SYNCHRONIZING,
+    ]);
+    watcher?.setIsSequencerBuilding(() => !idleStates.has(sequencer.getState()));
+    // Under proposer pipelining the L1 publish for slot N happens during wall-clock slot N,
+    // but the proposer for slot N has already built the checkpoint during slot N-1 and is
+    // waiting for L1 to advance. We need to fast-forward L1 to wake that wait — and the wait
+    // we have to break first is `waitForValidParentCheckpointOnL1`, which blocks the
+    // checkpoint_proposal_job's background submission task until the archiver has synced past
+    // the build slot. That wait happens *before* `PUBLISHING_CHECKPOINT` is set, so a hook on
+    // that state transition would be circular (L1 has to advance before the state we'd use to
+    // advance L1 fires). The earliest pre-wait signal is `block-proposed`, which the sequencer
+    // emits once each block is built. In sandbox single-block-per-slot mode this is
+    // effectively "checkpoint built", and the watcher warp is harmless if a subsequent
+    // assembly/validation/parent-wait step aborts: L1 just sits one slot ahead, which the
+    // cascade absorbs.
+    if (watcher) {
+      sequencer.on('block-proposed', ({ slot }) => watcher!.setProposedTargetSlot(Number(slot)));
+    }
+  }
+
+  let epochTestSettler: EpochTestSettler | undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    epochTestSettler = new EpochTestSettler(
+      cheatcodes!,
+      rollupAddress!,
+      node.getBlockSource(),
+      logger.createChild('epoch-settler'),
+      { pollingIntervalMs: 200 },
+    );
+    await epochTestSettler.start();
+  }
+
+  if (initialAccounts.length) {
+    const wallet = await EmbeddedWallet.create(node, {
+      pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
+      ephemeral: true,
+    });
+
+    userLog('Setting up funded test accounts...');
+    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts, setupWaitOpts);
+    const accLogs = await createAccountLogs(accountManagers, wallet);
+    userLog(accLogs.join(''));
+
+    userLog('Publishing standard AuthRegistry contract...');
+    await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
+
+    await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
+
+    userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
+
+    // We no longer need the wallet once we've setup the accounts so we stop the underlying PXE job queue
+    await wallet.stop();
+  }
+
+  const stop = async () => {
+    await node.stop();
+    await watcher?.stop();
+    await epochTestSettler?.stop();
+  };
+
+  return { node, 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;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+  } = {},
+  options: { genesis?: GenesisData } = {},
+) {
+  // TODO(#12272): will clean this up. This is criminal.
+  // Not sure why this was ever done. Will be fixed in A-989, A-991, A-990.
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...config,
+  };
+  const node = await AztecNodeService.createAndSync(
+    aztecNodeConfig,
+    { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
+    options,
+  );
+  return node;
+}

package/src/local-network/sponsored_fpc.ts

@@ -0,0 +1,26 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import {
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { SPONSORED_FPC_SALT } from '@aztec/constants';
+import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
+
+async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
+  return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+    salt: new Fr(SPONSORED_FPC_SALT),
+  });
+}
+
+export async function getSponsoredFPCAddress(): Promise<AztecAddress> {
+  return (await getSponsoredFPCInstance()).address;
+}
+
+export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet): Promise<AztecAddress> {
+  const fpc = await getSponsoredFPCInstance();
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(fpc, SponsoredFPCContract.artifact);
+  return fpc.address;
+}