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

package/dest/local-network/local-network.d.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env -S node --no-warnings
+import { AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { type BlobClientInterface } from '@aztec/blob-client/client';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { GenesisData } from '@aztec/stdlib/world-state';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { type Hex } from 'viem';
+/**
+ * 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 declare function deployContractsToL1(aztecNodeConfig: AztecNodeConfig, privateKey: Hex, opts?: {
+    genesisArchiveRoot?: Fr;
+    feeJuicePortalInitialBalance?: bigint;
+}): Promise<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 declare function createLocalNetwork(config: Partial<LocalNetworkConfig> | undefined, userLog: LogFn): Promise<{
+    node: AztecNodeService;
+    stop: () => Promise<void>;
+}>;
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */
+export declare function createAztecNode(config?: Partial<AztecNodeConfig>, deps?: {
+    telemetry?: TelemetryClient;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+}, options?: {
+    genesis?: GenesisData;
+}): Promise<AztecNodeService>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtbmV0d29yay5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xvY2FsLW5ldHdvcmsvbG9jYWwtbmV0d29yay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBRUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDckQsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFvQixNQUFNLDBCQUEwQixDQUFDO0FBQ2xGLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBb0IsTUFBTSwyQkFBMkIsQ0FBQztBQU92RixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBSWpGLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxZQUFZLEVBQW9CLE1BQU0seUJBQXlCLENBQUM7QUFLekUsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUV4RSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM3RCxPQUFPLEVBQ0wsS0FBSyxlQUFlLEVBR3JCLE1BQU0seUJBQXlCLENBQUM7QUFLakMsT0FBTyxFQUFFLEtBQUssR0FBRyxFQUEyRCxNQUFNLE1BQU0sQ0FBQztBQXVCekY7Ozs7R0FJRztBQUNILHdCQUFzQixtQkFBbUIsQ0FDdkMsZUFBZSxFQUFFLGVBQWUsRUFDaEMsVUFBVSxFQUFFLEdBQUcsRUFDZixJQUFJLEdBQUU7SUFDSixrQkFBa0IsQ0FBQyxFQUFFLEVBQUUsQ0FBQztJQUN4Qiw0QkFBNEIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNsQyxHQUNMLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQW1COUI7QUFFRCw4QkFBOEI7QUFDOUIsTUFBTSxNQUFNLGtCQUFrQixHQUFHLGVBQWUsR0FBRztJQUNqRCwwREFBMEQ7SUFDMUQsVUFBVSxFQUFFLE1BQU0sQ0FBQztJQUNuQiw2REFBNkQ7SUFDN0QsWUFBWSxFQUFFLE9BQU8sQ0FBQztDQUN2QixDQUFDO0FBRUY7Ozs7R0FJRztBQUNILHdCQUFzQixrQkFBa0IsQ0FBQyxNQUFNLHlDQUFrQyxFQUFFLE9BQU8sRUFBRSxLQUFLOzs7R0EwS2hHO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQXNCLGVBQWUsQ0FDbkMsTUFBTSxHQUFFLE9BQU8sQ0FBQyxlQUFlLENBQU0sRUFDckMsSUFBSSxHQUFFO0lBQ0osU0FBUyxDQUFDLEVBQUUsZUFBZSxDQUFDO0lBQzVCLFVBQVUsQ0FBQyxFQUFFLG1CQUFtQixDQUFDO0lBQ2pDLFlBQVksQ0FBQyxFQUFFLFlBQVksQ0FBQztJQUM1QixZQUFZLENBQUMsRUFBRSxnQkFBZ0IsQ0FBQztDQUM1QixFQUNOLE9BQU8sR0FBRTtJQUFFLE9BQU8sQ0FBQyxFQUFFLFdBQVcsQ0FBQTtDQUFPLDZCQWN4QyJ9

package/dest/local-network/local-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-network.d.ts","sourceRoot":"","sources":["../../src/local-network/local-network.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,KAAK,eAAe,EAAoB,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAE5C,OAAO,EAAE,KAAK,mBAAmB,EAAoB,MAAM,2BAA2B,CAAC;AAOvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAIjF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAKzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAKjC,OAAO,EAAE,KAAK,GAAG,EAA2D,MAAM,MAAM,CAAC;AAuBzF;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,eAAe,EAAE,eAAe,EAChC,UAAU,EAAE,GAAG,EACf,IAAI,GAAE;IACJ,kBAAkB,CAAC,EAAE,EAAE,CAAC;IACxB,4BAA4B,CAAC,EAAE,MAAM,CAAC;CAClC,GACL,OAAO,CAAC,mBAAmB,CAAC,CAmB9B;AAED,8BAA8B;AAC9B,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,yCAAkC,EAAE,OAAO,EAAE,KAAK;;;GA0KhG;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,EACrC,IAAI,GAAE;IACJ,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,gBAAgB,CAAC;CAC5B,EACN,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,WAAW,CAAA;CAAO,6BAcxC"}

package/dest/local-network/local-network.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env -S node --no-warnings
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { AztecNodeService } from '@aztec/aztec-node';
+import { getConfigEnvVars } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { 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 { EthCheatCodes } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { 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 { TxStatus } from '@aztec/stdlib/tx';
+import { 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 { 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, privateKey, opts = {}) {
+    await waitForPublicClient(aztecNodeConfig);
+    const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
+        ...getL1ContractsConfigEnvVars(),
+        ...aztecNodeConfig,
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractsHash,
+        genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+        feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+        aztecTargetCommitteeSize: 0,
+        slasherEnabled: false,
+        realVerifier: false
+    });
+    Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
+    aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
+    return l1Contracts.l1ContractAddresses;
+}
+/**
+ * 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 = {}, userLog) {
+    // 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 = {
+        ...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')}`)
+        ];
+    }
+    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;
+    let rollupAddress;
+    let watcher;
+    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)
+            ])
+        });
+        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 = 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;
+    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 = {}, deps = {}, options = {}) {
+    // 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 = {
+        ...getConfigEnvVars(),
+        ...config
+    };
+    const node = await AztecNodeService.createAndSync(aztecNodeConfig, {
+        ...deps,
+        proverNodeDeps: {
+            broker: deps.proverBroker
+        }
+    }, options);
+    return node;
+}

package/dest/local-network/sponsored_fpc.d.ts

@@ -0,0 +1,5 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+export declare function getSponsoredFPCAddress(): Promise<AztecAddress>;
+export declare function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet): Promise<AztecAddress>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BvbnNvcmVkX2ZwYy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xvY2FsLW5ldHdvcmsvc3BvbnNvcmVkX2ZwYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQU05RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQVVyRCx3QkFBc0Isc0JBQXNCLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUVwRTtBQUVELHdCQUFzQixpREFBaUQsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FLN0cifQ==

package/dest/local-network/sponsored_fpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sponsored_fpc.d.ts","sourceRoot":"","sources":["../../src/local-network/sponsored_fpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAM9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAUrD,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,YAAY,CAAC,CAEpE;AAED,wBAAsB,iDAAiD,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAK7G"}

package/dest/local-network/sponsored_fpc.js

@@ -0,0 +1,18 @@
+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';
+async function getSponsoredFPCInstance() {
+    return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+        salt: new Fr(SPONSORED_FPC_SALT)
+    });
+}
+export async function getSponsoredFPCAddress() {
+    return (await getSponsoredFPCInstance()).address;
+}
+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/mnemonic.d.ts

@@ -1,2 +1,2 @@
 export declare const DefaultMnemonic = "test test test test test test test test test test test junk";
-//# sourceMappingURL=mnemonic.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW5lbW9uaWMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9tbmVtb25pYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxlQUFPLE1BQU0sZUFBZSxnRUFBZ0UsQ0FBQyJ9

package/dest/splash.d.ts

@@ -1,3 +1,3 @@
 export declare const splash: string;
 export declare const github = "https://github.com/AztecProtocol";
-//# sourceMappingURL=splash.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsYXNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc3BsYXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQU8sTUFBTSxNQUFNLEVBQUUsTUFPa0IsQ0FBQztBQUV4QyxlQUFPLE1BQU0sTUFBTSxxQ0FBcUMsQ0FBQyJ9

package/dest/testing/anvil_test_watcher.d.ts

@@ -0,0 +1,54 @@
+import { EthCheatCodes } from '@aztec/ethereum/test';
+import type { ViemClient } from '@aztec/ethereum/types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { TestDateProvider } from '@aztec/foundation/timer';
+export type AnvilTestWatcherOpts = {
+    isLocalNetwork?: boolean;
+    isMarkingAsProven?: boolean;
+};
+/**
+ * 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 isLocalNetwork;
+    private isMarkingAsProven;
+    private rollup;
+    private rollupCheatCodes;
+    private l2SlotDuration;
+    private filledRunningPromise?;
+    private syncDateProviderPromise?;
+    private markingAsProvenRunningPromise?;
+    private logger;
+    private getPendingTxCount?;
+    private isSequencerBuilding?;
+    private unfilledSlotFirstSeen?;
+    private proposedTargetSlot?;
+    constructor(cheatcodes: EthCheatCodes, rollupAddress: EthAddress, l1Client: ViemClient, dateProvider?: TestDateProvider | undefined, opts?: AnvilTestWatcherOpts);
+    setIsMarkingAsProven(isMarkingAsProven: boolean): void;
+    setisLocalNetwork(isLocalNetwork: boolean): void;
+    /** Sets a callback to check for pending txs, used to skip unfilled slots faster when txs are waiting. */
+    setGetPendingTxCount(fn: () => Promise<number>): void;
+    /** Sets a callback to check if the sequencer is actively building, to avoid warping while it works. */
+    setIsSequencerBuilding(fn: () => boolean): void;
+    /**
+     * Records the target slot for which the proposer has built a block destined for L1. Used by
+     * the local-network watcher to fast-forward L1 (and the injected date provider) ahead of the
+     * pipelined publisher's `sendRequestsAt` sleep so it ends promptly instead of waiting a full
+     * wall-clock slot. Only ratchets up — late warps for stale slots are no-ops.
+     */
+    setProposedTargetSlot(slot: number): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    trigger(): Promise<void>;
+    markAsProven(): Promise<void>;
+    syncDateProviderToL1IfBehind(): Promise<void>;
+    warpTimeIfNeeded(): Promise<void>;
+    private warpToTimestamp;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW52aWxfdGVzdF93YXRjaGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9hbnZpbF90ZXN0X3dhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBb0IsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV4RCxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBS2hFLE1BQU0sTUFBTSxvQkFBb0IsR0FBRztJQUNqQyxjQUFjLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDekIsaUJBQWlCLENBQUMsRUFBRSxPQUFPLENBQUM7Q0FDN0IsQ0FBQztBQUVGOzs7Ozs7R0FNRztBQUNILHFCQUFhLGdCQUFnQjtJQThCekIsT0FBTyxDQUFDLFVBQVU7SUFHbEIsT0FBTyxDQUFDLFlBQVksQ0FBQztJQWhDdkIsT0FBTyxDQUFDLGNBQWMsQ0FBQztJQUN2QixPQUFPLENBQUMsaUJBQWlCLENBQUM7SUFFMUIsT0FBTyxDQUFDLE1BQU0sQ0FBc0Q7SUFDcEUsT0FBTyxDQUFDLGdCQUFnQixDQUFtQjtJQUMzQyxPQUFPLENBQUMsY0FBYyxDQUFVO0lBRWhDLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxDQUFpQjtJQUM5QyxPQUFPLENBQUMsdUJBQXVCLENBQUMsQ0FBaUI7SUFDakQsT0FBTyxDQUFDLDZCQUE2QixDQUFDLENBQWlCO0lBRXZELE9BQU8sQ0FBQyxNQUFNLENBQWlEO0lBRy9ELE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxDQUF3QjtJQUdsRCxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FBZ0I7SUFHNUMsT0FBTyxDQUFDLHFCQUFxQixDQUFDLENBQXFDO0lBTW5FLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFTO0lBRXBDLFlBQ1UsVUFBVSxFQUFFLGFBQWEsRUFDakMsYUFBYSxFQUFFLFVBQVUsRUFDekIsUUFBUSxFQUFFLFVBQVUsRUFDWixZQUFZLENBQUMsOEJBQWtCLEVBQ3ZDLElBQUksR0FBRSxvQkFBeUIsRUFnQmhDO0lBRUQsb0JBQW9CLENBQUMsaUJBQWlCLEVBQUUsT0FBTyxRQUc5QztJQUVELGlCQUFpQixDQUFDLGNBQWMsRUFBRSxPQUFPLFFBRXhDO0lBRUQseUdBQXlHO0lBQ3pHLG9CQUFvQixDQUFDLEVBQUUsRUFBRSxNQUFNLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFFN0M7SUFFRCx1R0FBdUc7SUFDdkcsc0JBQXNCLENBQUMsRUFBRSxFQUFFLE1BQU0sT0FBTyxRQUV2QztJQUVEOzs7OztPQUtHO0lBQ0gscUJBQXFCLENBQUMsSUFBSSxFQUFFLE1BQU0sUUFJakM7SUFFSyxLQUFLLGtCQXlCVjtJQUVLLElBQUksa0JBSVQ7SUFFSyxPQUFPLGtCQUlaO0lBRUssWUFBWSxrQkFLakI7SUFFSyw0QkFBNEIsa0JBc0JqQztJQUVLLGdCQUFnQixrQkEwRXJCO1lBTWEsZUFBZTtDQWdCOUIifQ==

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,EAAE,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAKhE,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,gBAAgB;IA8BzB,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,YAAY,CAAC;IAhCvB,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,iBAAiB,CAAC;IAE1B,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;IAG/D,OAAO,CAAC,iBAAiB,CAAC,CAAwB;IAGlD,OAAO,CAAC,mBAAmB,CAAC,CAAgB;IAG5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAMnE,OAAO,CAAC,kBAAkB,CAAC,CAAS;IAEpC,YACU,UAAU,EAAE,aAAa,EACjC,aAAa,EAAE,UAAU,EACzB,QAAQ,EAAE,UAAU,EACZ,YAAY,CAAC,8BAAkB,EACvC,IAAI,GAAE,oBAAyB,EAgBhC;IAED,oBAAoB,CAAC,iBAAiB,EAAE,OAAO,QAG9C;IAED,iBAAiB,CAAC,cAAc,EAAE,OAAO,QAExC;IAED,yGAAyG;IACzG,oBAAoB,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,QAE7C;IAED,uGAAuG;IACvG,sBAAsB,CAAC,EAAE,EAAE,MAAM,OAAO,QAEvC;IAED;;;;;OAKG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM,QAIjC;IAEK,KAAK,kBAyBV;IAEK,IAAI,kBAIT;IAEK,OAAO,kBAIZ;IAEK,YAAY,kBAKjB;IAEK,4BAA4B,kBAsBjC;IAEK,gBAAgB,kBA0ErB;YAMa,eAAe;CAgB9B"}

package/dest/testing/anvil_test_watcher.js

@@ -0,0 +1,235 @@
+import { RollupCheatCodes } from '@aztec/ethereum/test';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+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;
+    isLocalNetwork;
+    isMarkingAsProven;
+    rollup;
+    rollupCheatCodes;
+    l2SlotDuration;
+    filledRunningPromise;
+    syncDateProviderPromise;
+    markingAsProvenRunningPromise;
+    logger;
+    // Optional callback to check if there are pending txs in the mempool.
+    getPendingTxCount;
+    // Optional callback to check if the sequencer is actively building a block.
+    isSequencerBuilding;
+    // Tracks when we first observed the current unfilled slot with pending txs (real wall time).
+    unfilledSlotFirstSeen;
+    // Latest target slot for which the proposer has built a block destined for L1 but which has
+    // not yet been committed. Set by the proposer-pipelining hook from `block-proposed` events so
+    // the watcher can advance L1 (and the injected date provider) to the target slot ahead of the
+    // publisher's `sendRequestsAt` sleep, instead of waiting a full wall-clock slot.
+    proposedTargetSlot;
+    constructor(cheatcodes, rollupAddress, l1Client, dateProvider, opts = {}){
+        this.cheatcodes = cheatcodes;
+        this.dateProvider = dateProvider;
+        this.logger = createLogger(`aztecjs:utils:watcher`);
+        this.rollup = getContract({
+            address: getAddress(rollupAddress.toString()),
+            abi: RollupAbi,
+            client: l1Client
+        });
+        this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
+            rollupAddress
+        });
+        this.isLocalNetwork = opts.isLocalNetwork ?? false;
+        this.isMarkingAsProven = opts.isMarkingAsProven ?? true;
+        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;
+    }
+    setisLocalNetwork(isLocalNetwork) {
+        this.isLocalNetwork = isLocalNetwork;
+    }
+    /** Sets a callback to check for pending txs, used to skip unfilled slots faster when txs are waiting. */ setGetPendingTxCount(fn) {
+        this.getPendingTxCount = fn;
+    }
+    /** Sets a callback to check if the sequencer is actively building, to avoid warping while it works. */ setIsSequencerBuilding(fn) {
+        this.isSequencerBuilding = fn;
+    }
+    /**
+   * Records the target slot for which the proposer has built a block destined for L1. Used by
+   * the local-network watcher to fast-forward L1 (and the injected date provider) ahead of the
+   * pipelined publisher's `sendRequestsAt` sleep so it ends promptly instead of waiting a full
+   * wall-clock slot. Only ratchets up — late warps for stale slots are no-ops.
+   */ setProposedTargetSlot(slot) {
+        if (this.proposedTargetSlot === undefined || slot > this.proposedTargetSlot) {
+            this.proposedTargetSlot = slot;
+        }
+    }
+    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 local network 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 local network, because we don't have a date provider in the local network
+        if (!this.dateProvider) {
+            return;
+        }
+        const l1Time = await this.cheatcodes.lastBlockTimestamp() * 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) {
+            // Warp L1 to the slot boundary at-or-before wall time. Rounding to a slot boundary (rather than
+            // `ceil(wallTime / 1000)`) keeps this loop's target aligned with `warpTimeIfNeeded`'s
+            // `nextSlotTimestamp` target, avoiding a race where the two loops pick timestamps a fraction of
+            // a second apart and one of them is then rejected by anvil as non-monotonic.
+            const wallSec = Math.floor(wallTime / 1000);
+            const targetSlot = await this.rollup.read.getSlotAt([
+                BigInt(wallSec)
+            ]);
+            const targetTimestamp = Number(await this.rollup.read.getTimestampForSlot([
+                targetSlot
+            ]));
+            this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to slot ${targetSlot} boundary`);
+            await this.warpToTimestamp(targetTimestamp);
+        }
+    }
+    async warpTimeIfNeeded() {
+        try {
+            const currentSlot = SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+            const pendingCheckpointNumber = await this.rollup.read.getPendingCheckpointNumber();
+            const checkpointLog = await this.rollup.read.getCheckpoint([
+                pendingCheckpointNumber
+            ]);
+            const nextSlot = SlotNumber(currentSlot + 1);
+            const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([
+                BigInt(nextSlot)
+            ]));
+            if (BigInt(currentSlot) === checkpointLog.slotNumber) {
+                // The current slot has been filled, we should jump to the next slot.
+                if (await this.warpToTimestamp(nextSlotTimestamp)) {
+                    this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+                }
+                return;
+            }
+            // If we are not in local network, we don't need to warp time
+            if (!this.isLocalNetwork) {
+                return;
+            }
+            // Pipelined-publish shortcut: if the proposer has built a block destined for a slot
+            // beyond the current L1 slot, fast-forward L1 to that slot's timestamp so the publisher's
+            // `sendRequestsAt(targetSlot)` sleep ends and the multicall mines inside the target slot.
+            // Without this, the publisher waits up to a full real-time slot for wall clock to catch up.
+            if (this.proposedTargetSlot !== undefined && this.proposedTargetSlot > currentSlot) {
+                const targetSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([
+                    BigInt(this.proposedTargetSlot)
+                ]));
+                if (await this.warpToTimestamp(targetSlotTimestamp)) {
+                    this.logger.info(`Warped L1 to target slot ${this.proposedTargetSlot} for pipelined publish`);
+                }
+                return;
+            }
+            // If there are pending txs and the sequencer missed them, warp quickly (after a 2s real-time debounce) so the
+            // sequencer can retry in the next slot. Without this, we'd have to wait a full real-time slot duration (~36s) for
+            // the dateProvider to catch up to the next slot timestamp. We skip the warp if the sequencer is actively building
+            // to avoid invalidating its in-progress work.
+            if (this.getPendingTxCount) {
+                const pendingTxs = await this.getPendingTxCount();
+                if (pendingTxs > 0) {
+                    if (this.isSequencerBuilding?.()) {
+                        this.unfilledSlotFirstSeen = undefined;
+                        return;
+                    }
+                    const realNow = Date.now();
+                    if (!this.unfilledSlotFirstSeen || this.unfilledSlotFirstSeen.slot !== currentSlot) {
+                        this.unfilledSlotFirstSeen = {
+                            slot: currentSlot,
+                            realTime: realNow
+                        };
+                        return;
+                    }
+                    if (realNow - this.unfilledSlotFirstSeen.realTime > 2000) {
+                        if (await this.warpToTimestamp(nextSlotTimestamp)) {
+                            this.logger.info(`Slot ${currentSlot} was missed with pending txs, jumped to next slot`);
+                        }
+                        this.unfilledSlotFirstSeen = undefined;
+                    }
+                    return;
+                }
+            }
+            // Fallback: warp when the dateProvider time has passed the next slot timestamp.
+            const currentTimestamp = this.dateProvider?.now() ?? Date.now();
+            if (currentTimestamp > nextSlotTimestamp * 1000) {
+                if (await this.warpToTimestamp(nextSlotTimestamp)) {
+                    this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
+                }
+            }
+        } catch  {
+            this.logger.error('mineIfSlotFilled failed');
+        }
+    }
+    /**
+   * Warps L1 to `timestamp`, unless L1 is already at or past it. Returns true when a warp actually
+   * happened, false when skipped or on error. Callers use the return value to gate success logs.
+   */ async warpToTimestamp(timestamp) {
+        try {
+            // Anvil rejects evm_setNextBlockTimestamp values <= the current block's timestamp. The two
+            // watcher loops can race and pick targets a fraction of a second apart; skip here rather than
+            // letting the second one error out noisily.
+            const lastTimestamp = await this.cheatcodes.lastBlockTimestamp();
+            if (timestamp <= lastTimestamp) {
+                return false;
+            }
+            await this.cheatcodes.warp(timestamp, {
+                resetBlockInterval: true
+            });
+            return true;
+        } catch (e) {
+            this.logger.error(`Failed to warp to timestamp ${timestamp}: ${e}`);
+            return false;
+        }
+    }
+}