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

package/dest/sandbox/sandbox.d.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env -S node --no-warnings
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { type BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import { Fr } from '@aztec/foundation/fields';
 import { type LogFn } from '@aztec/foundation/log';
-import { type PXEServiceConfig } from '@aztec/pxe/server';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { DateProvider } from '@aztec/foundation/timer';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { type HDAccount, type PrivateKeyAccount } from 'viem';
@@ -13,38 +13,41 @@ import { type HDAccount, type PrivateKeyAccount } from 'viem';
  * @param aztecNodeConfig - The Aztec Node Config
  * @param hdAccount - Account for publishing L1 contracts
  */
-export declare function deployContractsToL1(aztecNodeConfig: AztecNodeConfig, hdAccount: HDAccount | PrivateKeyAccount, contractDeployLogger?: import("@aztec/aztec.js").Logger, opts?: {
+export declare function deployContractsToL1(aztecNodeConfig: AztecNodeConfig, hdAccount: HDAccount | PrivateKeyAccount, contractDeployLogger?: import("@aztec/foundation/log").Logger, opts?: {
     assumeProvenThroughBlockNumber?: number;
     salt?: number;
     genesisArchiveRoot?: Fr;
-    genesisBlockHash?: Fr;
+    feeJuicePortalInitialBalance?: bigint;
 }): Promise<{
-    rollupAddress: import("@aztec/aztec.js").EthAddress;
-    registryAddress: import("@aztec/aztec.js").EthAddress;
-    inboxAddress: import("@aztec/aztec.js").EthAddress;
-    outboxAddress: import("@aztec/aztec.js").EthAddress;
-    feeJuiceAddress: import("@aztec/aztec.js").EthAddress;
-    feeJuicePortalAddress: import("@aztec/aztec.js").EthAddress;
-    coinIssuerAddress: import("@aztec/aztec.js").EthAddress;
-    rewardDistributorAddress: import("@aztec/aztec.js").EthAddress;
-    governanceProposerAddress: import("@aztec/aztec.js").EthAddress;
-    governanceAddress: import("@aztec/aztec.js").EthAddress;
-    stakingAssetAddress: import("@aztec/aztec.js").EthAddress;
+    rollupAddress: EthAddress;
+    registryAddress: EthAddress;
+    inboxAddress: EthAddress;
+    outboxAddress: EthAddress;
+    feeJuiceAddress: EthAddress;
+    feeJuicePortalAddress: EthAddress;
+    coinIssuerAddress: EthAddress;
+    rewardDistributorAddress: EthAddress;
+    governanceProposerAddress: EthAddress;
+    governanceAddress: EthAddress;
+    stakingAssetAddress: EthAddress;
 } & {
-    slashFactoryAddress?: import("@aztec/aztec.js").EthAddress | undefined;
+    slashFactoryAddress?: EthAddress | undefined;
+    feeAssetHandlerAddress?: EthAddress | undefined;
+    stakingAssetHandlerAddress?: EthAddress | undefined;
+    zkPassportVerifierAddress?: EthAddress | undefined;
+    gseAddress?: EthAddress | undefined;
+    dateGatedRelayerAddress?: EthAddress | undefined;
 } & {
-    rollupAddress: import("@aztec/aztec.js").EthAddress;
+    rollupAddress: EthAddress;
 } & {
-    rollupAddress: import("@aztec/aztec.js").EthAddress;
+    rollupAddress: EthAddress;
 }>;
 /** 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;
+    deployAztecContractsSalt: string;
     /** Whether to deploy test accounts on sandbox start.*/
     testAccounts: boolean;
 };
@@ -55,7 +58,6 @@ export type SandboxConfig = AztecNodeConfig & {
  */
 export declare function createSandbox(config: Partial<SandboxConfig> | undefined, userLog: LogFn): Promise<{
     node: AztecNodeService;
-    pxe: import("@aztec/pxe/server").PXEService;
     stop: () => Promise<void>;
 }>;
 /**
@@ -65,12 +67,8 @@ export declare function createSandbox(config: Partial<SandboxConfig> | undefined
 export declare function createAztecNode(config?: Partial<AztecNodeConfig>, deps?: {
     telemetry?: TelemetryClient;
     blobSinkClient?: BlobSinkClientInterface;
+    dateProvider?: DateProvider;
 }, options?: {
     prefilledPublicData?: PublicDataTreeLeaf[];
 }): Promise<AztecNodeService>;
-/**
- * Create and start a new Aztec PXE HTTP Server
- * @param config - Optional PXE settings.
- */
-export declare function createAztecPXE(node: AztecNode, config?: Partial<PXEServiceConfig>): Promise<import("@aztec/pxe/server").PXEService>;
 //# sourceMappingURL=sandbox.d.ts.map

package/dest/sandbox/sandbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../src/sandbox/sandbox.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,KAAK,eAAe,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAE7F,OAAO,EAAE,KAAK,uBAAuB,EAAwB,MAAM,yBAAyB,CAAC;AAU7F,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,KAAK,EAAgB,MAAM,uBAAuB,CAAC;AAGjE,OAAO,EAAE,KAAK,gBAAgB,EAAyC,MAAM,mBAAmB,CAAC;AACjG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,iBAAiB,EAA2D,MAAM,MAAM,CAAC;AAavH;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,SAAS,GAAG,iBAAiB,EACxC,oBAAoB,mCAAS,EAC7B,IAAI,GAAE;IAAE,8BAA8B,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,EAAE,CAAC;IAAC,gBAAgB,CAAC,EAAE,EAAE,CAAA;CAAO;;;;;;;;;;;;;;;;;;GA6BtH;AAED,wBAAwB;AACxB,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG;IAC5C,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,OAAO,CAAC;IACf,uDAAuD;IACvD,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,MAAM,oCAA6B,EAAE,OAAO,EAAE,KAAK;;;;GAkGtF;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,EACrC,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,eAAe,CAAC;IAAC,cAAc,CAAC,EAAE,uBAAuB,CAAA;CAAO,EACpF,OAAO,GAAE;IAAE,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAAO,6BAY7D;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,GAAE,OAAO,CAAC,gBAAgB,CAAM,mDAI3F"}
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../src/sandbox/sandbox.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAC7F,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,KAAK,uBAAuB,EAAwB,MAAM,yBAAyB,CAAC;AAY7F,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,KAAK,EAAgB,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAGzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAIjC,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,iBAAiB,EAA2D,MAAM,MAAM,CAAC;AAcvH;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,SAAS,GAAG,iBAAiB,EACxC,oBAAoB,yCAAS,EAC7B,IAAI,GAAE;IACJ,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kBAAkB,CAAC,EAAE,EAAE,CAAC;IACxB,4BAA4B,CAAC,EAAE,MAAM,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;GAkCP;AAED,wBAAwB;AACxB,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG;IAC5C,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,wBAAwB,EAAE,MAAM,CAAC;IACjC,uDAAuD;IACvD,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,YAAK,EAAE,OAAO,EAAE,KAAK;;;GAgHtF;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,EACrC,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,eAAe,CAAC;IAAC,cAAc,CAAC,EAAE,uBAAuB,CAAC;IAAC,YAAY,CAAC,EAAE,YAAY,CAAA;CAAO,EACjH,OAAO,GAAE;IAAE,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAAO,6BAW7D"}

package/dest/sandbox/sandbox.js

@@ -1,26 +1,28 @@
 #!/usr/bin/env -S node --no-warnings
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AnvilTestWatcher, EthCheatCodes, SignerlessWallet } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { 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 { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
+import { NULL_KEY, createEthereumChain, deployL1Contracts, deployMulticall3, getL1ContractsConfigEnvVars, waitForPublicClient } from '@aztec/ethereum';
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
+import { TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 import { createPublicClient, fallback, http as httpViemTransport } from 'viem';
-import { mnemonicToAccount } from 'viem/accounts';
+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 { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
-import { getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js';
+import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 const logger = createLogger('sandbox');
 const localAnvil = foundry;
 /**
@@ -35,14 +37,18 @@ const localAnvil = foundry;
     const l1Contracts = await deployL1Contracts(aztecNodeConfig.l1RpcUrls, hdAccount, chain.chainInfo, contractDeployLogger, {
         ...getL1ContractsConfigEnvVars(),
         ...aztecNodeConfig,
-        l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
         vkTreeRoot: getVKTreeRoot(),
-        protocolContractTreeRoot,
+        protocolContractsHash,
         genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-        genesisBlockHash: opts.genesisBlockHash ?? new Fr(GENESIS_BLOCK_HASH),
-        salt: opts.salt
+        salt: opts.salt,
+        feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+        aztecTargetCommitteeSize: 0,
+        slasherFlavor: 'none',
+        realVerifier: false
     });
+    await deployMulticall3(l1Contracts.l1Client, logger);
     aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+    aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
     return aztecNodeConfig.l1Contracts;
 }
 /**
@@ -63,22 +69,26 @@ const localAnvil = foundry;
         ...config
     };
     const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
-    if (!aztecNodeConfig.publisherPrivateKey || aztecNodeConfig.publisherPrivateKey === NULL_KEY) {
+    if (aztecNodeConfig.publisherPrivateKeys == undefined || !aztecNodeConfig.publisherPrivateKeys.length || aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY) {
         const privKey = hdAccount.getHdKey().privateKey;
-        aztecNodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey).toString('hex')}`;
+        aztecNodeConfig.publisherPrivateKeys = [
+            new SecretValue(`0x${Buffer.from(privKey).toString('hex')}`)
+        ];
     }
-    if (!aztecNodeConfig.validatorPrivateKey || aztecNodeConfig.validatorPrivateKey === NULL_KEY) {
+    if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
         const privKey = hdAccount.getHdKey().privateKey;
-        aztecNodeConfig.validatorPrivateKey = `0x${Buffer.from(privKey).toString('hex')}`;
+        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) {
+        if (config.testAccounts === true || config.testAccounts === undefined) {
             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();
+                userLog(`Setting up test accounts`);
+                return await getInitialTestAccountsData();
             }
         }
         return [];
@@ -90,14 +100,15 @@ const localAnvil = foundry;
         bananaFPC,
         sponsoredFPC
     ] : [];
-    const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(fundedAddresses);
+    const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
     let watcher = undefined;
+    const dateProvider = new TestDateProvider();
     if (!aztecNodeConfig.p2pEnabled) {
         const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
             assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
             genesisArchiveRoot,
-            genesisBlockHash,
-            salt: config.l1Salt ? parseInt(config.l1Salt) : undefined
+            salt: config.deployAztecContractsSalt ? parseInt(config.deployAztecContractsSalt) : undefined,
+            feeJuicePortalInitialBalance: fundingNeeded
         });
         const chain = aztecNodeConfig.l1RpcUrls.length > 0 ? createEthereumChain([
             l1RpcUrl
@@ -112,7 +123,7 @@ const localAnvil = foundry;
         });
         watcher = new AnvilTestWatcher(new EthCheatCodes([
             l1RpcUrl
-        ]), l1ContractAddresses.rollupAddress, publicClient);
+        ], dateProvider), l1ContractAddresses.rollupAddress, publicClient, dateProvider);
         watcher.setIsSandbox(true);
         await watcher.start();
     }
@@ -121,24 +132,28 @@ const localAnvil = foundry;
     const blobSinkClient = createBlobSinkClient();
     const node = await createAztecNode(aztecNodeConfig, {
         telemetry,
-        blobSinkClient
+        blobSinkClient,
+        dateProvider
     }, {
         prefilledPublicData
     });
-    const pxe = await createAztecPXE(node);
-    await setupCanonicalL2FeeJuice(new SignerlessWallet(pxe), aztecNodeConfig.l1Contracts.feeJuicePortalAddress, undefined, logger.info);
     if (initialAccounts.length) {
+        const PXEConfig = {
+            proverEnabled: aztecNodeConfig.realProofs
+        };
+        const wallet = await TestWallet.create(node, PXEConfig);
         userLog('Setting up funded test accounts...');
-        const accounts = await deployFundedSchnorrAccounts(pxe, initialAccounts);
-        const accountsWithSecrets = accounts.map((account, i)=>({
-                account,
+        const accountManagers = await deployFundedSchnorrAccounts(wallet, node, initialAccounts);
+        const accountsWithSecrets = accountManagers.map((manager, i)=>({
+                account: manager,
                 secretKey: initialAccounts[i].secret
             }));
-        const accLogs = await createAccountLogs(accountsWithSecrets, pxe);
+        const accLogs = await createAccountLogs(accountsWithSecrets, wallet);
         userLog(accLogs.join(''));
-        const deployer = await getSchnorrWallet(pxe, initialAccounts[0].address, initialAccounts[0].signingKey);
-        await setupBananaFPC(initialAccounts, deployer, userLog);
-        await setupSponsoredFPC(deployer, userLog);
+        await setupBananaFPC(initialAccounts, wallet, userLog);
+        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();
@@ -146,7 +161,6 @@ const localAnvil = foundry;
     };
     return {
         node,
-        pxe,
         stop
     };
 }
@@ -164,18 +178,6 @@ const localAnvil = foundry;
             ...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, config = {}) {
-    const pxeServiceConfig = {
-        ...getPXEServiceConfig(),
-        ...config
-    };
-    const pxe = await createPXEService(node, pxeServiceConfig);
-    return pxe;
-}

package/dest/sandbox/sponsored_fpc.d.ts

@@ -1,6 +1,4 @@
-import { type PXE, type Wallet } from '@aztec/aztec.js';
-import type { LogFn } from '@aztec/foundation/log';
-export declare function getSponsoredFPCAddress(): Promise<import("@aztec/aztec.js").AztecAddress>;
-export declare function setupSponsoredFPC(deployer: Wallet, log: LogFn): Promise<void>;
-export declare function getDeployedSponsoredFPCAddress(pxe: PXE): Promise<import("@aztec/aztec.js").AztecAddress>;
+import type { Wallet } from '@aztec/aztec.js/wallet';
+export declare function getSponsoredFPCAddress(): Promise<import("@aztec/aztec.js/addresses").AztecAddress>;
+export declare function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet): Promise<import("@aztec/aztec.js/addresses").AztecAddress>;
 //# sourceMappingURL=sponsored_fpc.d.ts.map

package/dest/sandbox/sponsored_fpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sponsored_fpc.d.ts","sourceRoot":"","sources":["../../src/sandbox/sponsored_fpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,GAAG,EACR,KAAK,MAAM,EAEZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAWnD,wBAAsB,sBAAsB,oDAE3C;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAMnE;AAED,wBAAsB,8BAA8B,CAAC,GAAG,EAAE,GAAG,mDAO5D"}
+{"version":3,"file":"sponsored_fpc.d.ts","sourceRoot":"","sources":["../../src/sandbox/sponsored_fpc.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAUrD,wBAAsB,sBAAsB,8DAE3C;AAED,wBAAsB,iDAAiD,CAAC,MAAM,EAAE,MAAM,6DAKrF"}

package/dest/sandbox/sponsored_fpc.js

@@ -1,26 +1,18 @@
-import { Fr, getContractInstanceFromDeployParams } from '@aztec/aztec.js';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { SPONSORED_FPC_SALT } from '@aztec/constants';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
-const SPONSORED_FPC_SALT = new Fr(0);
 async function getSponsoredFPCInstance() {
-    return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, {
-        salt: SPONSORED_FPC_SALT
+    return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+        salt: new Fr(SPONSORED_FPC_SALT)
     });
 }
 export async function getSponsoredFPCAddress() {
     return (await getSponsoredFPCInstance()).address;
 }
-export async function setupSponsoredFPC(deployer, log) {
-    const deployed = await SponsoredFPCContract.deploy(deployer).send({
-        contractAddressSalt: SPONSORED_FPC_SALT,
-        universalDeploy: true
-    }).deployed();
-    log(`SponsoredFPC: ${deployed.address}`);
-}
-export async function getDeployedSponsoredFPCAddress(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;
+export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet) {
+    const fpc = await getSponsoredFPCInstance();
+    // The following is no-op if the contract is already registered
+    await wallet.registerContract(fpc, SponsoredFPCContract.artifact);
+    return fpc.address;
 }

package/dest/testing/anvil_test_watcher.d.ts

@@ -0,0 +1,34 @@
+import type { ViemClient } from '@aztec/ethereum';
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+/**
+ * Represents a watcher for a rollup contract.
+ *
+ * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
+ * it will periodically check if the current slot have already been filled, e.g., there was an L2
+ * block within the slot. And if so, it will time travel into the next slot.
+ */
+export declare class AnvilTestWatcher {
+    private cheatcodes;
+    private dateProvider?;
+    private isSandbox;
+    private rollup;
+    private rollupCheatCodes;
+    private l2SlotDuration;
+    private filledRunningPromise?;
+    private syncDateProviderPromise?;
+    private markingAsProvenRunningPromise?;
+    private logger;
+    private isMarkingAsProven;
+    constructor(cheatcodes: EthCheatCodes, rollupAddress: EthAddress, l1Client: ViemClient, dateProvider?: TestDateProvider | undefined);
+    setIsMarkingAsProven(isMarkingAsProven: boolean): void;
+    setIsSandbox(isSandbox: boolean): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    trigger(): Promise<void>;
+    markAsProven(): Promise<void>;
+    syncDateProviderToL1IfBehind(): Promise<void>;
+    warpTimeIfNeeded(): Promise<void>;
+}
+//# sourceMappingURL=anvil_test_watcher.d.ts.map

package/dest/testing/anvil_test_watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anvil_test_watcher.d.ts","sourceRoot":"","sources":["../../src/testing/anvil_test_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAKhE;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAgBzB,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,YAAY,CAAC;IAlBvB,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO,CAAC,MAAM,CAAsD;IACpE,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,cAAc,CAAU;IAEhC,OAAO,CAAC,oBAAoB,CAAC,CAAiB;IAC9C,OAAO,CAAC,uBAAuB,CAAC,CAAiB;IACjD,OAAO,CAAC,6BAA6B,CAAC,CAAiB;IAEvD,OAAO,CAAC,MAAM,CAAiD;IAE/D,OAAO,CAAC,iBAAiB,CAAQ;gBAGvB,UAAU,EAAE,aAAa,EACjC,aAAa,EAAE,UAAU,EACzB,QAAQ,EAAE,UAAU,EACZ,YAAY,CAAC,EAAE,gBAAgB,YAAA;IAezC,oBAAoB,CAAC,iBAAiB,EAAE,OAAO;IAK/C,YAAY,CAAC,SAAS,EAAE,OAAO;IAIzB,KAAK;IA2BL,IAAI;IAMJ,OAAO;IAMP,YAAY;IAOZ,4BAA4B;IAiB5B,gBAAgB;CAwCvB"}

package/dest/testing/anvil_test_watcher.js

@@ -0,0 +1,142 @@
+import { RollupCheatCodes } from '@aztec/ethereum/test';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { getAddress, getContract } from 'viem';
+/**
+ * Represents a watcher for a rollup contract.
+ *
+ * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
+ * it will periodically check if the current slot have already been filled, e.g., there was an L2
+ * block within the slot. And if so, it will time travel into the next slot.
+ */ export class AnvilTestWatcher {
+    cheatcodes;
+    dateProvider;
+    isSandbox;
+    rollup;
+    rollupCheatCodes;
+    l2SlotDuration;
+    filledRunningPromise;
+    syncDateProviderPromise;
+    markingAsProvenRunningPromise;
+    logger;
+    isMarkingAsProven;
+    constructor(cheatcodes, rollupAddress, l1Client, dateProvider){
+        this.cheatcodes = cheatcodes;
+        this.dateProvider = dateProvider;
+        this.isSandbox = false;
+        this.logger = createLogger(`aztecjs:utils:watcher`);
+        this.isMarkingAsProven = true;
+        this.rollup = getContract({
+            address: getAddress(rollupAddress.toString()),
+            abi: RollupAbi,
+            client: l1Client
+        });
+        this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
+            rollupAddress
+        });
+        this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
+    }
+    setIsMarkingAsProven(isMarkingAsProven) {
+        this.logger.warn(`Watcher is now ${isMarkingAsProven ? 'marking' : 'not marking'} blocks as proven`);
+        this.isMarkingAsProven = isMarkingAsProven;
+    }
+    setIsSandbox(isSandbox) {
+        this.isSandbox = isSandbox;
+    }
+    async start() {
+        if (this.filledRunningPromise) {
+            throw new Error('Watcher already watching for filled slot');
+        }
+        const config = await this.rollupCheatCodes.getConfig();
+        this.l2SlotDuration = config.slotDuration;
+        // If auto mining is not supported (e.g., we are on a real network), then we
+        // will simple do nothing. But if on an anvil or the like, this make sure that
+        // the sandbox and tests don't break because time is frozen and we never get to
+        // the next slot.
+        const isAutoMining = await this.cheatcodes.isAutoMining();
+        if (isAutoMining) {
+            this.filledRunningPromise = new RunningPromise(()=>this.warpTimeIfNeeded(), this.logger, 200);
+            this.filledRunningPromise.start();
+            this.syncDateProviderPromise = new RunningPromise(()=>this.syncDateProviderToL1IfBehind(), this.logger, 200);
+            this.syncDateProviderPromise.start();
+            this.markingAsProvenRunningPromise = new RunningPromise(()=>this.markAsProven(), this.logger, 200);
+            this.markingAsProvenRunningPromise.start();
+            this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
+        } else {
+            this.logger.info(`Watcher not started because not auto mining`);
+        }
+    }
+    async stop() {
+        await this.filledRunningPromise?.stop();
+        await this.syncDateProviderPromise?.stop();
+        await this.markingAsProvenRunningPromise?.stop();
+    }
+    async trigger() {
+        await this.filledRunningPromise?.trigger();
+        await this.syncDateProviderPromise?.trigger();
+        await this.markingAsProvenRunningPromise?.trigger();
+    }
+    async markAsProven() {
+        if (!this.isMarkingAsProven) {
+            return;
+        }
+        await this.rollupCheatCodes.markAsProven();
+    }
+    async syncDateProviderToL1IfBehind() {
+        // this doesn't apply to the sandbox, because we don't have a date provider in the sandbox
+        if (!this.dateProvider) {
+            return;
+        }
+        const l1Time = await this.cheatcodes.timestamp() * 1000;
+        const wallTime = this.dateProvider.now();
+        if (l1Time > wallTime) {
+            this.logger.warn(`L1 is ahead of wall time. Syncing wall time to L1 time`);
+            this.dateProvider.setTime(l1Time);
+        } else if (l1Time + Number(this.l2SlotDuration) * 1000 < wallTime) {
+            this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to wall time`);
+            await this.cheatcodes.warp(Math.ceil(wallTime / 1000));
+        }
+    }
+    async warpTimeIfNeeded() {
+        try {
+            const currentSlot = await this.rollup.read.getCurrentSlot();
+            const pendingBlockNumber = BigInt(await this.rollup.read.getPendingBlockNumber());
+            const blockLog = await this.rollup.read.getBlock([
+                pendingBlockNumber
+            ]);
+            const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([
+                currentSlot + 1n
+            ]));
+            if (currentSlot === blockLog.slotNumber) {
+                // We should jump to the next slot
+                try {
+                    await this.cheatcodes.warp(nextSlotTimestamp, {
+                        resetBlockInterval: true
+                    });
+                } catch (e) {
+                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+                }
+                this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+                return;
+            }
+            // If we are not in sandbox, we don't need to warp time
+            if (!this.isSandbox) {
+                return;
+            }
+            const currentTimestamp = this.dateProvider?.now() ?? Date.now();
+            if (currentTimestamp > nextSlotTimestamp * 1000) {
+                try {
+                    await this.cheatcodes.warp(nextSlotTimestamp, {
+                        resetBlockInterval: true
+                    });
+                } catch (e) {
+                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+                }
+                this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+            }
+        } catch  {
+            this.logger.error('mineIfSlotFilled failed');
+        }
+    }
+}

package/dest/testing/cheat_codes.d.ts

@@ -0,0 +1,43 @@
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { SequencerClient } from '@aztec/sequencer-client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+/**
+ * A class that provides utility functions for interacting with the chain.
+ * @deprecated There used to be 3 kinds of cheat codes: eth, rollup and aztec. We have nuked the Aztec ones because
+ * they became unused (we now have better testing tools). If you are introducing a new functionality to the cheat
+ * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
+ */
+export declare class CheatCodes {
+    /** Cheat codes for L1.*/
+    eth: EthCheatCodes;
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    rollup: RollupCheatCodes;
+    constructor(
+    /** Cheat codes for L1.*/
+    eth: EthCheatCodes, 
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    rollup: RollupCheatCodes);
+    static create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes>;
+    /**
+     * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
+     * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
+     * by the slot number, which advances in fixed intervals.
+     * This is useful for testing time-dependent contract behavior.
+     * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+     * @param node - The Aztec node used to query if a new block has been mined.
+     * @param targetTimestamp - The target timestamp to warp to (in seconds)
+     */
+    warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number): Promise<void>;
+    /**
+     * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
+     * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
+     * number, which advances in fixed intervals.
+     * This is useful for testing time-dependent contract behavior.
+     * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+     * @param node - The Aztec node used to query if a new block has been mined.
+     * @param duration - The duration to advance time by (in seconds)
+     */
+    warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number): Promise<void>;
+}
+//# sourceMappingURL=cheat_codes.d.ts.map

package/dest/testing/cheat_codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/testing/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;;;;GAKG;AACH,qBAAa,UAAU;IAEnB,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;;IAH/B,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;WAGpB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IASxG;;;;;;;;OAQG;IACG,mBAAmB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM;IAyB7G;;;;;;;;OAQG;IACG,mBAAmB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;CAKvG"}

package/dest/testing/cheat_codes.js

@@ -0,0 +1,62 @@
+import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import { retryUntil } from '@aztec/foundation/retry';
+/**
+ * A class that provides utility functions for interacting with the chain.
+ * @deprecated There used to be 3 kinds of cheat codes: eth, rollup and aztec. We have nuked the Aztec ones because
+ * they became unused (we now have better testing tools). If you are introducing a new functionality to the cheat
+ * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
+ */ export class CheatCodes {
+    eth;
+    rollup;
+    constructor(/** Cheat codes for L1.*/ eth, /** Cheat codes for the Aztec Rollup contract on L1. */ rollup){
+        this.eth = eth;
+        this.rollup = rollup;
+    }
+    static async create(rpcUrls, node, dateProvider) {
+        const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
+        const rollupCheatCodes = new RollupCheatCodes(ethCheatCodes, await node.getNodeInfo().then((n)=>n.l1ContractAddresses));
+        return new CheatCodes(ethCheatCodes, rollupCheatCodes);
+    }
+    /**
+   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
+   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
+   * by the slot number, which advances in fixed intervals.
+   * This is useful for testing time-dependent contract behavior.
+   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+   * @param node - The Aztec node used to query if a new block has been mined.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds)
+   */ async warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp) {
+        const currentL2BlockNumber = await node.getBlockNumber();
+        // We warp the L1 timestamp
+        await this.eth.warp(targetTimestamp, {
+            resetBlockInterval: true
+        });
+        // Wait until an L2 block is mined
+        const sequencer = sequencerClient.getSequencer();
+        const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
+        sequencer.updateConfig({
+            minTxsPerBlock: 0
+        });
+        await retryUntil(async ()=>{
+            const newL2BlockNumber = await node.getBlockNumber();
+            return newL2BlockNumber > currentL2BlockNumber;
+        }, 'new block after warping L2 time', 36, 1);
+        // Restore original minTxsPerBlock
+        sequencer.updateConfig({
+            minTxsPerBlock
+        });
+    }
+    /**
+   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
+   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
+   * number, which advances in fixed intervals.
+   * This is useful for testing time-dependent contract behavior.
+   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
+   * @param node - The Aztec node used to query if a new block has been mined.
+   * @param duration - The duration to advance time by (in seconds)
+   */ async warpL2TimeAtLeastBy(sequencerClient, node, duration) {
+        const currentTimestamp = await this.eth.timestamp();
+        const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
+        await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+    }
+}

package/dest/testing/index.d.ts

@@ -0,0 +1,4 @@
+export { AnvilTestWatcher } from './anvil_test_watcher.js';
+export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+export { CheatCodes } from './cheat_codes.js';
+//# sourceMappingURL=index.d.ts.map