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

package/dest/account_manager/deploy_account_sent_tx.js

@@ -1,29 +0,0 @@
-import { DefaultWaitOpts, SentTx } from '../contract/sent_tx.js';
-/**
- * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
- */ export class DeployAccountSentTx extends SentTx {
-    getWalletPromise;
-    constructor(pxe, txHashPromise, getWalletPromise){
-        super(pxe, txHashPromise), this.getWalletPromise = getWalletPromise;
-    }
-    /**
-   * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The deployed contract instance.
-   */ async getWallet(opts) {
-        const receipt = await this.wait(opts);
-        return receipt.wallet;
-    }
-    /**
-   * Awaits for the tx to be mined and returns the receipt along with a wallet instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt with the wallet for the deployed account contract.
-   */ async wait(opts = DefaultWaitOpts) {
-        const receipt = await super.wait(opts);
-        const wallet = await this.getWalletPromise;
-        return {
-            ...receipt,
-            wallet
-        };
-    }
-}

package/dest/account_manager/index.d.ts

@@ -1,108 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { AccountContract } from '../account/contract.js';
-import type { Salt, Wallet } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { Contract } from '../contract/index.js';
-import { type WaitOpts } from '../contract/sent_tx.js';
-import { AccountWalletWithSecretKey } from '../wallet/index.js';
-import { DeployAccountMethod } from './deploy_account_method.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-/**
- * Options to deploy an account contract.
- */
-export type DeployAccountOptions = Pick<DeployOptions, 'fee' | 'skipClassRegistration' | 'skipPublicDeployment' | 'skipInitialization'> & {
-    /**
-     * Wallet used for deploying the account contract. Must be funded in order to pay for the fee.
-     */
-    deployWallet?: Wallet;
-};
-/**
- * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
- * and creating and registering the user wallet in the PXE Service.
- */
-export declare class AccountManager {
-    private pxe;
-    private secretKey;
-    private accountContract;
-    private instance;
-    /**
-     * Deployment salt for the account contract
-     */
-    readonly salt: Salt;
-    private constructor();
-    static create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt): Promise<AccountManager>;
-    protected getPublicKeys(): import("@aztec/stdlib/keys").PublicKeys;
-    protected getPublicKeysHash(): Fr | Promise<Fr>;
-    /**
-     * Returns the entrypoint for this account as defined by its account contract.
-     * @returns An entrypoint.
-     */
-    getAccount(): Promise<AccountInterface>;
-    /**
-     * Gets the calculated complete address associated with this account.
-     * Does not require the account to be deployed or registered.
-     * @returns The address, partial address, and encryption public key.
-     */
-    getCompleteAddress(): Promise<CompleteAddress>;
-    /**
-     * Gets the address for this given account.
-     * Does not require the account to be deployed or registered.
-     * @returns The address.
-     */
-    getAddress(): import("@aztec/stdlib/aztec-address").AztecAddress;
-    /**
-     * Returns the contract instance definition associated with this account.
-     * Does not require the account to be deployed or registered.
-     * @returns ContractInstance instance.
-     */
-    getInstance(): ContractInstanceWithAddress;
-    /**
-     * Returns a Wallet instance associated with this account. Use it to create Contract
-     * instances to be interacted with from this account.
-     * @returns A Wallet instance.
-     */
-    getWallet(): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Registers this account in the PXE Service and returns the associated wallet. Registering
-     * the account on the PXE Service is required for managing private state associated with it.
-     * Use the returned wallet to create Contract instances to be interacted with from this account.
-     * @param opts - Options to wait for the account to be synched.
-     * @returns A Wallet instance.
-     */
-    register(): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Returns the pre-populated deployment method to deploy the account contract that backs this account.
-     * Typically you will not need this method and can call `deploy` directly. Use this for having finer
-     * grained control on when to create, simulate, and send the deployment tx.
-     * @param deployWallet - Wallet used for deploying the account contract.
-     * @returns A DeployMethod instance that deploys this account contract.
-     */
-    getDeployMethod(deployWallet?: Wallet): Promise<DeployMethod<Contract> | DeployAccountMethod>;
-    /**
-     * Deploys the account contract that backs this account.
-     * Does not register the associated class nor publicly deploy the instance by default.
-     * Uses the salt provided in the constructor or a randomly generated one.
-     * Registers the account in the PXE Service before deploying the contract.
-     * @param opts - Fee options to be used for the deployment.
-     * @returns A SentTx object that can be waited to get the associated Wallet.
-     */
-    deploy(opts?: DeployAccountOptions): DeployAccountSentTx;
-    /**
-     * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
-     * Uses the salt provided in the constructor or a randomly generated one. If no initialization
-     * is required it skips the transaction, and only registers the account in the PXE Service.
-     * @param opts - Options to wait for the tx to be mined.
-     * @returns A Wallet instance.
-     */
-    waitSetup(opts?: DeployAccountOptions & WaitOpts): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Returns whether this account contract has a constructor and needs deployment.
-     */
-    isDeployable(): Promise<boolean>;
-}
-export { DeployAccountMethod } from './deploy_account_method.js';
-export { type DeployAccountTxReceipt, DeployAccountSentTx } from './deploy_account_sent_tx.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/account_manager/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/account_manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,KAAK,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE3F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAExE,OAAO,EAAE,0BAA0B,EAAoB,MAAM,oBAAoB,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,aAAa,EACb,KAAK,GAAG,uBAAuB,GAAG,sBAAsB,GAAG,oBAAoB,CAChF,GAAG;IACF;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ;IAChB;;OAEG;aACa,IAAI,EAAE,IAAI;IAR5B,OAAO;WAWM,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,IAAI;IAc1F,SAAS,CAAC,aAAa;IAIvB,SAAS,CAAC,iBAAiB;IAI3B;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAMpD;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;IAIrD;;;;OAIG;IACI,UAAU;IAIjB;;;;OAIG;IACI,WAAW,IAAI,2BAA2B;IAIjD;;;;OAIG;IACU,SAAS,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAK7D;;;;;;OAMG;IACU,QAAQ,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAW5D;;;;;;OAMG;IACU,eAAe,CAAC,YAAY,CAAC,EAAE,MAAM;IA2ClD;;;;;;;OAOG;IACI,MAAM,CAAC,IAAI,CAAC,EAAE,oBAAoB,GAAG,mBAAmB;IAgB/D;;;;;;OAMG;IACU,SAAS,CAAC,IAAI,GAAE,oBAAoB,GAAG,QAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAKpH;;OAEG;IACU,YAAY;CAG1B;AAED,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,KAAK,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC"}

package/dest/account_manager/index.js

@@ -1,159 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress } from '@aztec/stdlib/contract';
-import { getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
-import { deriveKeys } from '@aztec/stdlib/keys';
-import { DeployMethod } from '../contract/deploy_method.js';
-import { Contract } from '../contract/index.js';
-import { DefaultWaitOpts } from '../contract/sent_tx.js';
-import { DefaultMultiCallEntrypoint } from '../entrypoint/default_multi_call_entrypoint.js';
-import { AccountWalletWithSecretKey, SignerlessWallet } from '../wallet/index.js';
-import { DeployAccountMethod } from './deploy_account_method.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-/**
- * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
- * and creating and registering the user wallet in the PXE Service.
- */ export class AccountManager {
-    pxe;
-    secretKey;
-    accountContract;
-    instance;
-    salt;
-    constructor(pxe, secretKey, accountContract, instance, /**
-     * Deployment salt for the account contract
-     */ salt){
-        this.pxe = pxe;
-        this.secretKey = secretKey;
-        this.accountContract = accountContract;
-        this.instance = instance;
-        this.salt = salt;
-    }
-    static async create(pxe, secretKey, accountContract, salt) {
-        const { publicKeys } = await deriveKeys(secretKey);
-        salt = salt !== undefined ? new Fr(salt) : Fr.random();
-        const artifact = await accountContract.getContractArtifact();
-        const instance = await getContractInstanceFromDeployParams(artifact, {
-            constructorArgs: await accountContract.getDeploymentArgs(),
-            salt: salt,
-            publicKeys
-        });
-        return new AccountManager(pxe, secretKey, accountContract, instance, salt);
-    }
-    getPublicKeys() {
-        return this.instance.publicKeys;
-    }
-    getPublicKeysHash() {
-        return this.getPublicKeys().hash();
-    }
-    /**
-   * Returns the entrypoint for this account as defined by its account contract.
-   * @returns An entrypoint.
-   */ async getAccount() {
-        const nodeInfo = await this.pxe.getNodeInfo();
-        const completeAddress = await this.getCompleteAddress();
-        return this.accountContract.getInterface(completeAddress, nodeInfo);
-    }
-    /**
-   * Gets the calculated complete address associated with this account.
-   * Does not require the account to be deployed or registered.
-   * @returns The address, partial address, and encryption public key.
-   */ getCompleteAddress() {
-        return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
-    }
-    /**
-   * Gets the address for this given account.
-   * Does not require the account to be deployed or registered.
-   * @returns The address.
-   */ getAddress() {
-        return this.instance.address;
-    }
-    /**
-   * Returns the contract instance definition associated with this account.
-   * Does not require the account to be deployed or registered.
-   * @returns ContractInstance instance.
-   */ getInstance() {
-        return this.instance;
-    }
-    /**
-   * Returns a Wallet instance associated with this account. Use it to create Contract
-   * instances to be interacted with from this account.
-   * @returns A Wallet instance.
-   */ async getWallet() {
-        const entrypoint = await this.getAccount();
-        return new AccountWalletWithSecretKey(this.pxe, entrypoint, this.secretKey, this.salt);
-    }
-    /**
-   * Registers this account in the PXE Service and returns the associated wallet. Registering
-   * the account on the PXE Service is required for managing private state associated with it.
-   * Use the returned wallet to create Contract instances to be interacted with from this account.
-   * @param opts - Options to wait for the account to be synched.
-   * @returns A Wallet instance.
-   */ async register() {
-        await this.pxe.registerContract({
-            artifact: await this.accountContract.getContractArtifact(),
-            instance: this.getInstance()
-        });
-        await this.pxe.registerAccount(this.secretKey, (await this.getCompleteAddress()).partialAddress);
-        return this.getWallet();
-    }
-    /**
-   * Returns the pre-populated deployment method to deploy the account contract that backs this account.
-   * Typically you will not need this method and can call `deploy` directly. Use this for having finer
-   * grained control on when to create, simulate, and send the deployment tx.
-   * @param deployWallet - Wallet used for deploying the account contract.
-   * @returns A DeployMethod instance that deploys this account contract.
-   */ async getDeployMethod(deployWallet) {
-        const artifact = await this.accountContract.getContractArtifact();
-        if (!await this.isDeployable()) {
-            throw new Error(`Account contract ${artifact.name} does not require deployment.`);
-        }
-        const completeAddress = await this.getCompleteAddress();
-        await this.pxe.registerAccount(this.secretKey, completeAddress.partialAddress);
-        const args = await this.accountContract.getDeploymentArgs() ?? [];
-        if (deployWallet) {
-            // If deploying using an existing wallet/account, treat it like regular contract deployment.
-            const thisWallet = await this.getWallet();
-            return new DeployMethod(this.getPublicKeys(), deployWallet, artifact, (address)=>Contract.at(address, artifact, thisWallet), args, 'constructor');
-        }
-        const { l1ChainId: chainId, protocolVersion } = await this.pxe.getNodeInfo();
-        // We use a signerless wallet with the multi call entrypoint in order to make multiple calls in one go.
-        // If we used getWallet, the deployment would get routed via the account contract entrypoint
-        // and it can't be used unless the contract is initialized.
-        const wallet = new SignerlessWallet(this.pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion));
-        return new DeployAccountMethod(this.accountContract.getAuthWitnessProvider(completeAddress), this.getPublicKeys(), wallet, artifact, args, 'constructor', 'entrypoint');
-    }
-    /**
-   * Deploys the account contract that backs this account.
-   * Does not register the associated class nor publicly deploy the instance by default.
-   * Uses the salt provided in the constructor or a randomly generated one.
-   * Registers the account in the PXE Service before deploying the contract.
-   * @param opts - Fee options to be used for the deployment.
-   * @returns A SentTx object that can be waited to get the associated Wallet.
-   */ deploy(opts) {
-        const sentTx = this.getDeployMethod(opts?.deployWallet).then((deployMethod)=>deployMethod.send({
-                contractAddressSalt: new Fr(this.salt),
-                skipClassRegistration: opts?.skipClassRegistration ?? true,
-                skipPublicDeployment: opts?.skipPublicDeployment ?? true,
-                skipInitialization: opts?.skipInitialization ?? false,
-                universalDeploy: true,
-                fee: opts?.fee
-            })).then((tx)=>tx.getTxHash());
-        return new DeployAccountSentTx(this.pxe, sentTx, this.getWallet());
-    }
-    /**
-   * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
-   * Uses the salt provided in the constructor or a randomly generated one. If no initialization
-   * is required it skips the transaction, and only registers the account in the PXE Service.
-   * @param opts - Options to wait for the tx to be mined.
-   * @returns A Wallet instance.
-   */ async waitSetup(opts = DefaultWaitOpts) {
-        await (await this.isDeployable() ? this.deploy(opts).wait(opts) : this.register());
-        return this.getWallet();
-    }
-    /**
-   * Returns whether this account contract has a constructor and needs deployment.
-   */ async isDeployable() {
-        return await this.accountContract.getDeploymentArgs() !== undefined;
-    }
-}
-export { DeployAccountMethod } from './deploy_account_method.js';
-export { DeployAccountSentTx } from './deploy_account_sent_tx.js';

package/dest/api/cheat_codes.d.ts

@@ -1,26 +0,0 @@
-import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import { AztecCheatCodes } from '../utils/aztec_cheatcodes.js';
-import { RollupCheatCodes } from './ethereum/cheat_codes.js';
-/**
- * A class that provides utility functions for interacting with the chain.
- */
-export declare class CheatCodes {
-    /** Cheat codes for L1.*/
-    eth: EthCheatCodes;
-    /** Cheat codes for Aztec L2. */
-    aztec: AztecCheatCodes;
-    /** Cheat codes for the Aztec Rollup contract on L1. */
-    rollup: RollupCheatCodes;
-    constructor(
-    /** Cheat codes for L1.*/
-    eth: EthCheatCodes, 
-    /** Cheat codes for Aztec L2. */
-    aztec: AztecCheatCodes, 
-    /** Cheat codes for the Aztec Rollup contract on L1. */
-    rollup: RollupCheatCodes);
-    static create(rpcUrls: string[], pxe: PXE): Promise<CheatCodes>;
-    static createRollup(rpcUrls: string[], addresses: Pick<L1ContractAddresses, 'rollupAddress'>): RollupCheatCodes;
-}
-//# sourceMappingURL=cheat_codes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/api/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;GAEG;AACH,qBAAa,UAAU;IAEnB,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,gCAAgC;IACzB,KAAK,EAAE,eAAe;IAC7B,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;;IAL/B,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,gCAAgC;IACzB,KAAK,EAAE,eAAe;IAC7B,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;WAGpB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAUrE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,GAAG,gBAAgB;CAIhH"}

package/dest/api/cheat_codes.js

@@ -1,25 +0,0 @@
-import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
-import { AztecCheatCodes } from '../utils/aztec_cheatcodes.js';
-import { RollupCheatCodes } from './ethereum/cheat_codes.js';
-/**
- * A class that provides utility functions for interacting with the chain.
- */ export class CheatCodes {
-    eth;
-    aztec;
-    rollup;
-    constructor(/** Cheat codes for L1.*/ eth, /** Cheat codes for Aztec L2. */ aztec, /** Cheat codes for the Aztec Rollup contract on L1. */ rollup){
-        this.eth = eth;
-        this.aztec = aztec;
-        this.rollup = rollup;
-    }
-    static async create(rpcUrls, pxe) {
-        const ethCheatCodes = new EthCheatCodes(rpcUrls);
-        const aztecCheatCodes = new AztecCheatCodes(pxe);
-        const rollupCheatCodes = new RollupCheatCodes(ethCheatCodes, await pxe.getNodeInfo().then((n)=>n.l1ContractAddresses));
-        return new CheatCodes(ethCheatCodes, aztecCheatCodes, rollupCheatCodes);
-    }
-    static createRollup(rpcUrls, addresses) {
-        const ethCheatCodes = new EthCheatCodes(rpcUrls);
-        return new RollupCheatCodes(ethCheatCodes, addresses);
-    }
-}

package/dest/api/entrypoint.d.ts

@@ -1,2 +0,0 @@
-export * from '../entrypoint/entrypoint.js';
-//# sourceMappingURL=entrypoint.d.ts.map

package/dest/api/entrypoint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../src/api/entrypoint.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/dest/api/entrypoint.js

@@ -1 +0,0 @@
-export * from '../entrypoint/entrypoint.js';

package/dest/api/ethereum/anvil_test_watcher.d.ts

@@ -1,32 +0,0 @@
-import type { ViemPublicClient } from '@aztec/ethereum';
-import type { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
-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 filledRunningPromise?;
-    private mineIfOutdatedPromise?;
-    private markingAsProvenRunningPromise?;
-    private logger;
-    private isMarkingAsProven;
-    constructor(cheatcodes: EthCheatCodes, rollupAddress: EthAddress, publicClient: ViemPublicClient, dateProvider?: TestDateProvider | undefined);
-    setIsMarkingAsProven(isMarkingAsProven: boolean): void;
-    setIsSandbox(isSandbox: boolean): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    markAsProven(): Promise<void>;
-    mineIfOutdated(): Promise<void>;
-    warpTimeIfNeeded(): Promise<void>;
-}
-//# sourceMappingURL=anvil_test_watcher.d.ts.map

package/dest/api/ethereum/anvil_test_watcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"anvil_test_watcher.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/anvil_test_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAOhE;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAezB,OAAO,CAAC,UAAU;IAGlB,OAAO,CAAC,YAAY,CAAC;IAjBvB,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO,CAAC,MAAM,CAA4D;IAC1E,OAAO,CAAC,gBAAgB,CAAmB;IAE3C,OAAO,CAAC,oBAAoB,CAAC,CAAiB;IAC9C,OAAO,CAAC,qBAAqB,CAAC,CAAiB;IAC/C,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,YAAY,EAAE,gBAAgB,EACtB,YAAY,CAAC,8BAAkB;IAezC,oBAAoB,CAAC,iBAAiB,EAAE,OAAO;IAI/C,YAAY,CAAC,SAAS,EAAE,OAAO;IAIzB,KAAK;IAwBL,IAAI;IAMJ,YAAY;IAOZ,cAAc;IAoBd,gBAAgB;CAwCvB"}

package/dest/api/ethereum/anvil_test_watcher.js

@@ -1,133 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import { RollupAbi } from '@aztec/l1-artifacts';
-import { getAddress, getContract } from 'viem';
-import { RollupCheatCodes } from './cheat_codes.js';
-/**
- * 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;
-    filledRunningPromise;
-    mineIfOutdatedPromise;
-    markingAsProvenRunningPromise;
-    logger;
-    isMarkingAsProven;
-    constructor(cheatcodes, rollupAddress, publicClient, 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: publicClient
-        });
-        this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
-            rollupAddress
-        });
-        this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
-    }
-    setIsMarkingAsProven(isMarkingAsProven) {
-        this.isMarkingAsProven = isMarkingAsProven;
-    }
-    setIsSandbox(isSandbox) {
-        this.isSandbox = isSandbox;
-    }
-    async start() {
-        if (this.filledRunningPromise) {
-            throw new Error('Watcher already watching for filled slot');
-        }
-        // 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, 1000);
-            this.filledRunningPromise.start();
-            this.mineIfOutdatedPromise = new RunningPromise(()=>this.mineIfOutdated(), this.logger, 1000);
-            this.mineIfOutdatedPromise.start();
-            this.markingAsProvenRunningPromise = new RunningPromise(()=>this.markAsProven(), this.logger, 1000);
-            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.mineIfOutdatedPromise?.stop();
-        await this.markingAsProvenRunningPromise?.stop();
-    }
-    async markAsProven() {
-        if (!this.isMarkingAsProven) {
-            return;
-        }
-        await this.rollupCheatCodes.markAsProven();
-    }
-    async mineIfOutdated() {
-        // 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 the wall time is more than 24 seconds away from L1 time,
-        // mine a block and sync the clocks
-        if (Math.abs(wallTime - l1Time) > 24 * 1000) {
-            this.logger.warn(`Wall time is more than 24 seconds away from L1 time, mining a block and syncing clocks`);
-            await this.cheatcodes.evmMine();
-            const newL1Time = await this.cheatcodes.timestamp();
-            this.logger.info(`New L1 time: ${newL1Time}`);
-            this.dateProvider.setTime(newL1Time * 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);
-                    this.dateProvider?.setTime(nextSlotTimestamp * 1000);
-                } 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);
-                    this.dateProvider?.setTime(nextSlotTimestamp * 1000);
-                } catch (e) {
-                    this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
-                }
-                this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
-            }
-        } catch (err) {
-            this.logger.error('mineIfSlotFilled failed');
-        }
-    }
-}

package/dest/api/ethereum/chain_monitor.d.ts

@@ -1,25 +0,0 @@
-import type { RollupContract } from '@aztec/ethereum/contracts';
-/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
-export declare class ChainMonitor {
-    private readonly rollup;
-    private logger;
-    private readonly intervalMs;
-    private readonly l1Client;
-    private handle;
-    /** Current L1 block number */
-    l1BlockNumber: number;
-    /** Current L2 block number */
-    l2BlockNumber: number;
-    /** Current L2 proven block number */
-    l2ProvenBlockNumber: number;
-    /** L1 timestamp for the current L2 block */
-    l2BlockTimestamp: bigint;
-    /** L1 timestamp for the proven L2 block */
-    l2ProvenBlockTimestamp: bigint;
-    constructor(rollup: RollupContract, logger?: import("@aztec/foundation/log").Logger, intervalMs?: number);
-    start(): this;
-    stop(): void;
-    private safeRun;
-    run(): Promise<void>;
-}
-//# sourceMappingURL=chain_monitor.d.ts.map

package/dest/api/ethereum/chain_monitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain_monitor.d.ts","sourceRoot":"","sources":["../../../src/api/ethereum/chain_monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,8GAA8G;AAC9G,qBAAa,YAAY;IAgBrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,UAAU;IAjB7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,MAAM,CAA6B;IAE3C,8BAA8B;IACvB,aAAa,EAAG,MAAM,CAAC;IAC9B,8BAA8B;IACvB,aAAa,EAAG,MAAM,CAAC;IAC9B,qCAAqC;IAC9B,mBAAmB,EAAG,MAAM,CAAC;IACpC,4CAA4C;IACrC,gBAAgB,EAAG,MAAM,CAAC;IACjC,2CAA2C;IACpC,sBAAsB,EAAG,MAAM,CAAC;gBAGpB,MAAM,EAAE,cAAc,EAC/B,MAAM,yCAA8C,EAC3C,UAAU,SAAM;IAKnC,KAAK;IAQL,IAAI;IAOJ,OAAO,CAAC,OAAO;IAMT,GAAG;CAqCV"}

package/dest/api/ethereum/chain_monitor.js

@@ -1,74 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */ export class ChainMonitor {
-    rollup;
-    logger;
-    intervalMs;
-    l1Client;
-    handle;
-    /** Current L1 block number */ l1BlockNumber;
-    /** Current L2 block number */ l2BlockNumber;
-    /** Current L2 proven block number */ l2ProvenBlockNumber;
-    /** L1 timestamp for the current L2 block */ l2BlockTimestamp;
-    /** L1 timestamp for the proven L2 block */ l2ProvenBlockTimestamp;
-    constructor(rollup, logger = createLogger('aztecjs:utils:chain_monitor'), intervalMs = 200){
-        this.rollup = rollup;
-        this.logger = logger;
-        this.intervalMs = intervalMs;
-        this.l1Client = rollup.client;
-    }
-    start() {
-        if (this.handle) {
-            throw new Error('Chain monitor already started');
-        }
-        this.handle = setInterval(this.safeRun.bind(this), this.intervalMs);
-        return this;
-    }
-    stop() {
-        if (this.handle) {
-            clearInterval(this.handle);
-            this.handle = undefined;
-        }
-    }
-    safeRun() {
-        void this.run().catch((error)=>{
-            this.logger.error('Error in chain monitor loop', error);
-        });
-    }
-    async run() {
-        const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({
-            cacheTime: 0
-        }));
-        if (this.l1BlockNumber === newL1BlockNumber) {
-            return;
-        }
-        this.l1BlockNumber = newL1BlockNumber;
-        const block = await this.l1Client.getBlock({
-            blockNumber: BigInt(newL1BlockNumber),
-            includeTransactions: false
-        });
-        const timestamp = block.timestamp;
-        const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
-        let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
-        const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
-        if (this.l2BlockNumber !== newL2BlockNumber) {
-            const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
-            msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
-            this.l2BlockNumber = newL2BlockNumber;
-            this.l2BlockTimestamp = timestamp;
-        }
-        const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
-        if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-            const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
-            msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
-            this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
-            this.l2ProvenBlockTimestamp = timestamp;
-        }
-        this.logger.info(msg, {
-            l1Timestamp: timestamp,
-            l1BlockNumber: this.l1BlockNumber,
-            l2SlotNumber: await this.rollup.getSlotNumber(),
-            l2BlockNumber: this.l2BlockNumber,
-            l2ProvenBlockNumber: this.l2ProvenBlockNumber
-        });
-    }
-}