@aztec/pxe 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/dest/{pxe_service/pxe_service.js → pxe.js}

@@ -4,36 +4,34 @@ import { SerialQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
 import { KeyStore } from '@aztec/key-store';
 import { L2TipsKVStore } from '@aztec/kv-store/stores';
-import { ProtocolContractAddress, protocolContractNames } from '@aztec/protocol-contracts';
-import { EventSelector, FunctionSelector, FunctionType, decodeFromAbi, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
+import { protocolContractNames } from '@aztec/protocol-contracts';
+import { FunctionSelector, FunctionType, decodeFromAbi, decodeFunctionSignature, encodeArguments } from '@aztec/stdlib/abi';
 import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { siloNullifier } from '@aztec/stdlib/hash';
-import { computeL2ToL1MembershipWitness, getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { UniqueNote } from '@aztec/stdlib/note';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { PrivateSimulationResult, TxProfileResult, TxProvingResult, TxSimulationResult } from '@aztec/stdlib/tx';
 import { inspect } from 'util';
-import { getPackageInfo } from '../config/package_info.js';
-import { ContractFunctionSimulator, generateSimulatedProvingResult } from '../contract_function_simulator/contract_function_simulator.js';
-import { readCurrentClassId } from '../contract_function_simulator/oracle/private_execution.js';
-import { ProxiedContractDataProviderFactory } from '../contract_function_simulator/proxied_contract_data_source.js';
-import { ProxiedNodeFactory } from '../contract_function_simulator/proxied_node.js';
-import { PXEOracleInterface } from '../contract_function_simulator/pxe_oracle_interface.js';
-import { PrivateKernelExecutionProver } from '../private_kernel/private_kernel_execution_prover.js';
-import { PrivateKernelOracleImpl } from '../private_kernel/private_kernel_oracle_impl.js';
-import { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
-import { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
-import { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
-import { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
-import { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
-import { SyncDataProvider } from '../storage/sync_data_provider/sync_data_provider.js';
-import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
-import { Synchronizer } from '../synchronizer/index.js';
+import { ContractFunctionSimulator, generateSimulatedProvingResult } from './contract_function_simulator/contract_function_simulator.js';
+import { readCurrentClassId } from './contract_function_simulator/oracle/private_execution.js';
+import { ProxiedContractDataProviderFactory } from './contract_function_simulator/proxied_contract_data_source.js';
+import { ProxiedNodeFactory } from './contract_function_simulator/proxied_node.js';
+import { PXEOracleInterface } from './contract_function_simulator/pxe_oracle_interface.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
+import { PrivateKernelExecutionProver } from './private_kernel/private_kernel_execution_prover.js';
+import { PrivateKernelOracleImpl } from './private_kernel/private_kernel_oracle_impl.js';
+import { AddressDataProvider } from './storage/address_data_provider/address_data_provider.js';
+import { CapsuleDataProvider } from './storage/capsule_data_provider/capsule_data_provider.js';
+import { ContractDataProvider } from './storage/contract_data_provider/contract_data_provider.js';
+import { NoteDataProvider } from './storage/note_data_provider/note_data_provider.js';
+import { PrivateEventDataProvider } from './storage/private_event_data_provider/private_event_data_provider.js';
+import { SyncDataProvider } from './storage/sync_data_provider/sync_data_provider.js';
+import { TaggingDataProvider } from './storage/tagging_data_provider/tagging_data_provider.js';
+import { Synchronizer } from './synchronizer/index.js';
 /**
- * A Private eXecution Environment (PXE) implementation.
- */ export class PXEService {
+ * Private eXecution Environment (PXE) is a library used by wallets to simulate private phase of transactions and to
+ * manage private state of users.
+ */ export class PXE {
     node;
     synchronizer;
     keyStore;
@@ -45,14 +43,12 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     addressDataProvider;
     privateEventDataProvider;
     simulator;
-    packageVersion;
     proverEnabled;
     proofCreator;
     protocolContractsProvider;
     log;
     jobQueue;
-    #nodeInfo;
-    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
+    constructor(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue){
         this.node = node;
         this.synchronizer = synchronizer;
         this.keyStore = keyStore;
@@ -64,7 +60,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         this.addressDataProvider = addressDataProvider;
         this.privateEventDataProvider = privateEventDataProvider;
         this.simulator = simulator;
-        this.packageVersion = packageVersion;
         this.proverEnabled = proverEnabled;
         this.proofCreator = proofCreator;
         this.protocolContractsProvider = protocolContractsProvider;
@@ -72,14 +67,13 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         this.jobQueue = jobQueue;
     }
     /**
-   * Creates an instance of a PXE Service by instantiating all the necessary data providers and services.
+   * Creates an instance of a PXE by instantiating all the necessary data providers and services.
    * Also triggers the registration of the protocol contracts and makes sure the provided node
    * can be contacted.
    *
-   * @returns A promise that resolves PXE service is ready to be used.
+   * @returns A promise that resolves PXE is ready to be used.
    */ static async create(node, store, proofCreator, simulator, protocolContractsProvider, config, loggerOrSuffix) {
         const log = !loggerOrSuffix || typeof loggerOrSuffix === 'string' ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`) : loggerOrSuffix;
-        const packageVersion = getPackageInfo().version;
         const proverEnabled = !!config.proverEnabled;
         const addressDataProvider = new AddressDataProvider(store);
         const privateEventDataProvider = new PrivateEventDataProvider(store);
@@ -92,50 +86,12 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         const tipsStore = new L2TipsKVStore(store, 'pxe');
         const synchronizer = new Synchronizer(node, syncDataProvider, noteDataProvider, taggingDataProvider, tipsStore, config, loggerOrSuffix);
         const jobQueue = new SerialQueue();
-        const pxeService = new PXEService(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, packageVersion, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
-        pxeService.jobQueue.start();
-        await pxeService.#registerProtocolContracts();
-        const info = await pxeService.getNodeInfo();
+        const pxe = new PXE(node, synchronizer, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, simulator, proverEnabled, proofCreator, protocolContractsProvider, log, jobQueue);
+        pxe.jobQueue.start();
+        await pxe.#registerProtocolContracts();
+        const info = await node.getNodeInfo();
         log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.rollupVersion}`);
-        return pxeService;
-    }
-    // Aztec node proxy methods
-    isL1ToL2MessageSynced(l1ToL2Message) {
-        return this.node.isL1ToL2MessageSynced(l1ToL2Message);
-    }
-    async getL2ToL1MembershipWitness(blockNumber, l2Tol1Message) {
-        const result = await computeL2ToL1MembershipWitness(this.node, blockNumber, l2Tol1Message);
-        if (!result) {
-            throw new Error(`L2 to L1 message not found in block ${blockNumber}`);
-        }
-        return [
-            result.leafIndex,
-            result.siblingPath
-        ];
-    }
-    getTxReceipt(txHash) {
-        return this.node.getTxReceipt(txHash);
-    }
-    getTxEffect(txHash) {
-        return this.node.getTxEffect(txHash);
-    }
-    getBlockNumber() {
-        return this.node.getBlockNumber();
-    }
-    getProvenBlockNumber() {
-        return this.node.getProvenBlockNumber();
-    }
-    getPublicLogs(filter) {
-        return this.node.getPublicLogs(filter);
-    }
-    getContractClassLogs(filter) {
-        return this.node.getContractClassLogs(filter);
-    }
-    getPublicStorageAt(contract, slot) {
-        return this.node.getPublicStorageAt('latest', contract, slot);
-    }
-    async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
-        return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
+        return pxe;
     }
     // Internal methods
     #getSimulatorForTx(overrides) {
@@ -190,7 +146,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
     async #getFunctionCall(functionName, args, to) {
         const contract = await this.contractDataProvider.getContract(to);
         if (!contract) {
-            throw new Error(`Unknown contract ${to}: add it to PXE Service by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`);
+            throw new Error(`Unknown contract ${to}: add it to PXE by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`);
         }
         const functionDao = contract.functions.find((f)=>f.name === functionName);
         if (!functionDao) {
@@ -202,6 +158,7 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
             type: functionDao.functionType,
             to,
+            hideMsgSender: false,
             isStatic: functionDao.isStatic,
             returnTypes: functionDao.returnTypes
         };
@@ -277,32 +234,30 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
    * @param config - The configuration for the kernel execution prover.
    * @returns An object that contains the output of the kernel execution, including the ClientIvcProof if proving is enabled.
    */ async #prove(txExecutionRequest, proofCreator, privateExecutionResult, config) {
-        const block = privateExecutionResult.getSimulationBlockNumber();
-        const kernelOracle = new PrivateKernelOracleImpl(this.contractDataProvider, this.keyStore, this.node, block);
+        const simulationAnchorBlock = privateExecutionResult.getSimulationAnchorBlockNumber();
+        const kernelOracle = new PrivateKernelOracleImpl(this.contractDataProvider, this.keyStore, this.node, simulationAnchorBlock);
         const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
         this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
         return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
     }
     // Public API
-    /** Returns an estimate of the db size in bytes. */ async estimateDbSize() {
-        const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
-        const dbSizes = await Promise.all([
-            this.addressDataProvider.getSize(),
-            this.capsuleDataProvider.getSize(),
-            this.contractDataProvider.getSize(),
-            this.noteDataProvider.getSize(),
-            this.syncDataProvider.getSize(),
-            this.taggingDataProvider.getSize()
-        ]);
-        return [
-            ...dbSizes,
-            treeRootsSize
-        ].reduce((sum, size)=>sum + size, 0);
-    }
     getContractInstance(address) {
         return this.contractDataProvider.getContractInstance(address);
     }
-    async getContractClassMetadata(id, includeArtifact = false) {
+    /**
+   * Returns the contract class metadata given a contract class id.
+   * The metadata consists of its contract class, whether it has been publicly registered, and its artifact.
+   * @remark - it queries the node to check whether the contract class with the given id has been publicly registered.
+   * @param id - Identifier of the class.
+   * @param includeArtifact - Identifier of the class.
+   * @returns - It returns the contract class metadata, with the artifact field being optional, and will only be returned if true is passed in
+   * for `includeArtifact`
+   * TODO(@spalladino): The PXE actually holds artifacts and not classes, what should we return? Also,
+   * should the pxe query the node for contract public info, and merge it with its own definitions?
+   * TODO(@spalladino): This method is strictly needed to decide whether to publicly register a class or not
+   * during a public deployment. We probably want a nicer and more general API for this, but it'll have to
+   * do for the time being.
+   */ async getContractClassMetadata(id, includeArtifact = false) {
         const artifact = await this.contractDataProvider.getContractArtifact(id);
         if (!artifact) {
             this.log.warn(`No artifact found for contract class ${id.toString()} when looking for its metadata`);
@@ -313,7 +268,17 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             artifact: includeArtifact ? artifact : undefined
         };
     }
-    async getContractMetadata(address) {
+    /**
+   * Returns the contract metadata given an address.
+   * The metadata consists of its contract instance, which includes the contract class identifier,
+   * initialization hash, deployment salt, and public keys hash; whether the contract instance has been initialized;
+   * and whether the contract instance with the given address has been publicly deployed.
+   * @remark - it queries the node to check whether the contract instance has been initialized / publicly deployed through a node.
+   * This query is not dependent on the PXE.
+   * @param address - The address that the contract instance resides at.
+   * @returns - It returns the contract metadata
+   * TODO(@spalladino): Should we return the public keys in plain as well here?
+   */ async getContractMetadata(address) {
         let instance;
         try {
             instance = await this.contractDataProvider.getContractInstance(address);
@@ -326,7 +291,16 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             isContractPublished: await this.#isContractPublished(address)
         };
     }
-    async registerAccount(secretKey, partialAddress) {
+    /**
+   * Registers a user account in PXE given its master encryption private key.
+   * Once a new account is registered, the PXE will trial-decrypt all published notes on
+   * the chain and store those that correspond to the registered account. Will do nothing if the
+   * account is already registered.
+   *
+   * @param secretKey - Secret key of the corresponding user master public key.
+   * @param partialAddress - The partial address of the account contract corresponding to the account being registered.
+   * @returns The complete address of the account.
+   */ async registerAccount(secretKey, partialAddress) {
         const accounts = await this.keyStore.getAccounts();
         const accountCompleteAddress = await this.keyStore.addAccount(secretKey, partialAddress);
         if (accounts.includes(accountCompleteAddress.address)) {
@@ -340,7 +314,15 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         await this.noteDataProvider.addScope(accountCompleteAddress.address);
         return accountCompleteAddress;
     }
-    async registerSender(address) {
+    /**
+   * Registers a user contact in PXE.
+   *
+   * Once a new contact is registered, the PXE will be able to receive notes tagged from this contact.
+   * Will do nothing if the account is already registered.
+   *
+   * @param address - Address of the user to add to the address book
+   * @returns The address address of the account.
+   */ async registerSender(address) {
         const accounts = await this.keyStore.getAccounts();
         if (accounts.includes(address)) {
             this.log.info(`Sender:\n "${address.toString()}"\n already registered.`);
@@ -354,10 +336,15 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         }
         return address;
     }
-    getSenders() {
+    /**
+   * Retrieves the addresses stored as senders on this PXE.
+   * @returns An array of the senders on this PXE.
+   */ getSenders() {
         return this.taggingDataProvider.getSenderAddresses();
     }
-    async removeSender(address) {
+    /**
+   * Removes a sender in the address book.
+   */ async removeSender(address) {
         const wasRemoved = await this.taggingDataProvider.removeSenderAddress(address);
         if (wasRemoved) {
             this.log.info(`Removed sender:\n ${address.toString()}`);
@@ -365,19 +352,33 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             this.log.info(`Sender:\n "${address.toString()}"\n not in address book.`);
         }
     }
-    async getRegisteredAccounts() {
+    /**
+   * Retrieves the user accounts registered on this PXE.
+   * @returns An array of the accounts registered on this PXE.
+   */ async getRegisteredAccounts() {
         // Get complete addresses of both the recipients and the accounts
         const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
         // Filter out the addresses not corresponding to accounts
         const accounts = await this.keyStore.getAccounts();
         return completeAddresses.filter((completeAddress)=>accounts.find((address)=>address.equals(completeAddress.address)));
     }
-    async registerContractClass(artifact) {
+    /**
+   * Registers a contract class in the PXE without registering any associated contract instance with it.
+   *
+   * @param artifact - The build artifact for the contract class.
+   */ async registerContractClass(artifact) {
         const { id: contractClassId } = await getContractClassFromArtifact(artifact);
         await this.contractDataProvider.addContractArtifact(contractClassId, artifact);
         this.log.info(`Added contract class ${artifact.name} with id ${contractClassId}`);
     }
-    async registerContract(contract) {
+    /**
+   * Adds deployed contracts to the PXE. Deployed contract information is used to access the
+   * contract code when simulating local transactions. This is automatically called by aztec.js when
+   * deploying a contract. Dapps that wish to interact with contracts already deployed should register
+   * these contracts in their users' PXE through this method.
+   *
+   * @param contract - A contract instance to register, with an optional artifact which can be omitted if the contract class has already been registered.
+   */ async registerContract(contract) {
         const { instance } = contract;
         let { artifact } = contract;
         if (artifact) {
@@ -404,7 +405,15 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
         await this.contractDataProvider.addContractInstance(instance);
         this.log.info(`Added contract ${artifact.name} at ${instance.address.toString()} with class ${instance.currentContractClassId}`);
     }
-    updateContract(contractAddress, artifact) {
+    /**
+   * Updates a deployed contract in the PXE. This is used to update the contract artifact when
+   * an update has happened, so the new code can be used in the simulation of local transactions.
+   * This is called by aztec.js when instantiating a contract in a given address with a mismatching artifact.
+   * @param contractAddress - The address of the contract to update.
+   * @param artifact - The updated artifact for the contract.
+   * @throws If the artifact's contract class is not found in the PXE or if the contract class is different from
+   * the current one (current one from the point of view of the node to which the PXE is connected).
+   */ updateContract(contractAddress, artifact) {
         // We disable concurrently updating contracts to avoid concurrently syncing with the node, or changing a contract's
         // class while we're simulating it.
         return this.#putInJobQueue(async ()=>{
@@ -427,53 +436,58 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
         });
     }
-    getContracts() {
+    /**
+   * Retrieves the addresses of contracts added to this PXE.
+   * @returns An array of contracts addresses registered on this PXE.
+   */ getContracts() {
         return this.contractDataProvider.getContractsAddresses();
     }
-    async getNotes(filter) {
-        // We need to manually trigger private state sync to have a guarantee that all the events are available.
+    /**
+   * A debugging utility to get notes based on the provided filter.
+   *
+   * Note that this should not be used in production code because the structure of notes is considered to be
+   * an implementation detail of contracts. This is only meant to be used for debugging purposes. If you need to obtain
+   * note-related information in production code, please implement a custom utility function on your contract and call
+   * that function instead (e.g. `get_balance(owner: AztecAddress) -> u128` utility function on a Token contract).
+   *
+   * @param filter - The filter to apply to the notes.
+   * @returns The requested notes.
+   */ async getNotes(filter) {
+        // We need to manually trigger private state sync to have a guarantee that all the notes are available.
         await this.simulateUtility('sync_private_state', [], filter.contractAddress);
         const noteDaos = await this.noteDataProvider.getNotes(filter);
-        const extendedNotes = noteDaos.map(async (dao)=>{
-            let recipient = filter.recipient;
-            if (recipient === undefined) {
-                const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
-                const completeAddressIndex = completeAddresses.findIndex((completeAddress)=>completeAddress.address.equals(dao.recipient));
-                const completeAddress = completeAddresses[completeAddressIndex];
-                if (completeAddress === undefined) {
-                    throw new Error(`Cannot find complete address for recipient ${dao.recipient.toString()}`);
-                }
-                recipient = completeAddress.address;
+        const uniqueNotes = noteDaos.map(async (dao)=>{
+            const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
+            const completeAddressIndex = completeAddresses.findIndex((completeAddress)=>completeAddress.address.equals(dao.recipient));
+            const completeAddress = completeAddresses[completeAddressIndex];
+            if (completeAddress === undefined) {
+                throw new Error(`Cannot find complete address for recipient ${dao.recipient.toString()}`);
             }
+            const recipient = completeAddress.address;
             return new UniqueNote(dao.note, recipient, dao.contractAddress, dao.storageSlot, dao.txHash, dao.noteNonce);
         });
-        return Promise.all(extendedNotes);
-    }
-    async getBlock(blockNumber) {
-        // If a negative block number is provided the current block number is fetched.
-        if (blockNumber < 0) {
-            blockNumber = await this.node.getBlockNumber();
-        }
-        return await this.node.getBlock(blockNumber);
-    }
-    async getCurrentBaseFees() {
-        return await this.node.getCurrentBaseFees();
+        return Promise.all(uniqueNotes);
     }
-    proveTx(txRequest, privateExecutionResult) {
+    /**
+   * Proves the private portion of a simulated transaction, ready to send to the network
+   * (where validators prove the public portion).
+   *
+   * @param txRequest - An authenticated tx request ready for proving
+   * @returns A result containing the proof and public inputs of the tail circuit.
+   * @throws If contract code not found, or public simulation reverts.
+   * Also throws if simulatePublic is true and public simulation reverts.
+   */ proveTx(txRequest) {
+        let privateExecutionResult;
         // We disable proving concurrently mostly out of caution, since it accesses some of our stores. Proving is so
         // computationally demanding that it'd be rare for someone to try to do it concurrently regardless.
         return this.#putInJobQueue(async ()=>{
             const totalTimer = new Timer();
             try {
-                let syncTime;
-                let contractFunctionSimulator;
-                if (!privateExecutionResult) {
-                    const syncTimer = new Timer();
-                    await this.synchronizer.sync();
-                    syncTime = syncTimer.ms();
-                    contractFunctionSimulator = this.#getSimulatorForTx();
-                    privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
-                }
+                const syncTimer = new Timer();
+                await this.synchronizer.sync();
+                const syncTime = syncTimer.ms();
+                const contractFunctionSimulator = this.#getSimulatorForTx();
+                privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest);
                 const { publicInputs, clientIvcProof, executionSteps, timings: { proving } = {} } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
                     simulate: false,
                     skipFeeEnforcement: false,
@@ -495,16 +509,34 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
                 this.log.debug(`Proving completed in ${totalTime}ms`, {
                     timings
                 });
-                return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof, {
+                const txProvingResult = new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof, {
                     timings,
                     nodeRPCCalls: contractFunctionSimulator?.getStats().nodeRPCCalls
                 });
+                const preTagsUsedInTheTx = privateExecutionResult.entrypoint.preTags;
+                if (preTagsUsedInTheTx.length > 0) {
+                    await this.taggingDataProvider.setLastUsedIndexesAsSender(preTagsUsedInTheTx);
+                    this.log.debug(`Stored used pre tags as sender for the tx`, {
+                        preTagsUsedInTheTx
+                    });
+                } else {
+                    this.log.debug(`No pre tags used in the tx`);
+                }
+                return txProvingResult;
             } catch (err) {
                 throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
             }
         });
     }
-    profileTx(txRequest, profileMode, skipProofGeneration = true) {
+    /**
+   * Profiles a transaction, reporting gate counts (unless disabled) and returns an execution trace.
+   *
+   * @param txRequest - An authenticated tx request ready for simulation
+   * @param msgSender - (Optional) The message sender to use for the simulation.
+   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @returns A trace of the program execution with gate counts.
+   * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
+   */ profileTx(txRequest, profileMode, skipProofGeneration = true) {
         // We disable concurrent profiles for consistency with simulateTx.
         return this.#putInJobQueue(async ()=>{
             const totalTimer = new Timer();
@@ -556,8 +588,29 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             }
         });
     }
-    // TODO(#7456) Prevent msgSender being defined here for the first call
-    simulateTx(txRequest, simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, overrides, scopes) {
+    /**
+   * Simulates a transaction based on the provided preauthenticated execution request.
+   * This will run a local simulation of private execution (and optionally of public as well), run the
+   * kernel circuits to ensure adherence to protocol rules (without generating a proof), and return the
+   * simulation results .
+   *
+   *
+   * Note that this is used with `ContractFunctionInteraction::simulateTx` to bypass certain checks.
+   * In that case, the transaction returned is only potentially ready to be sent to the network for execution.
+   *
+   *
+   * @param txRequest - An authenticated tx request ready for simulation
+   * @param simulatePublic - Whether to simulate the public part of the transaction.
+   * @param skipTxValidation - (Optional) If false, this function throws if the transaction is unable to be included in a block at the current state.
+   * @param skipFeeEnforcement - (Optional) If false, fees are enforced.
+   * @param overrides - (Optional) State overrides for the simulation, such as msgSender, contract instances and artifacts.
+   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @returns A simulated transaction result object that includes public and private return values.
+   * @throws If the code for the functions executed in this transaction have not been made available via `addContracts`.
+   * Also throws if simulatePublic is true and public simulation reverts.
+   *
+   * TODO(#7456) Prevent msgSender being defined here for the first call
+   */ simulateTx(txRequest, simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, overrides, scopes) {
         // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
         // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
         // delete the same read value, or reading values that another simulation is currently modifying).
@@ -654,19 +707,18 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             }
         });
     }
-    async sendTx(tx) {
-        const txHash = tx.getTxHash();
-        if (await this.node.getTxEffect(txHash)) {
-            throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
-        }
-        this.log.debug(`Sending transaction ${txHash}`);
-        await this.node.sendTx(tx).catch((err)=>{
-            throw this.#contextualizeError(err, inspect(tx));
-        });
-        this.log.info(`Sent transaction ${txHash}`);
-        return txHash;
-    }
-    simulateUtility(functionName, args, to, authwits, _from, scopes) {
+    /**
+   * Simulate the execution of a contract utility function.
+   *
+   * @param functionName - The name of the utility contract function to be called.
+   * @param args - The arguments to be provided to the function.
+   * @param to - The address of the contract to be called.
+   * @param authwits - (Optional) The authentication witnesses required for the function call.
+   * @param from - (Optional) The msg sender to set for the call.
+   * @param scopes - (Optional) The accounts whose notes we can access in this call. Currently optional and will
+   * default to all.
+   * @returns The result of the utility function call, structured based on the function ABI.
+   */ simulateUtility(functionName, args, to, authwits, _from, scopes) {
         // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
         // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
         // delete the same read value, or reading values that another simulation is currently modifying).
@@ -676,7 +728,6 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
                 const syncTimer = new Timer();
                 await this.synchronizer.sync();
                 const syncTime = syncTimer.ms();
-                // TODO - Should check if `from` has the permission to call the view function.
                 const functionCall = await this.#getFunctionCall(functionName, args, to);
                 const functionTimer = new Timer();
                 const contractFunctionSimulator = this.#getSimulatorForTx();
@@ -709,42 +760,15 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             }
         });
     }
-    async getNodeInfo() {
-        // This assumes we're connected to a single node, so we cache the info to avoid repeated calls.
-        // Load balancers and a myriad other configurations can break this assumption, so review this!
-        // Temporary measure to avoid hammering full nodes with requests on testnet.
-        if (!this.#nodeInfo) {
-            const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
-                this.node.getNodeVersion(),
-                this.node.getVersion(),
-                this.node.getChainId(),
-                this.node.getEncodedEnr(),
-                this.node.getL1ContractAddresses(),
-                this.node.getProtocolContractAddresses()
-            ]);
-            this.#nodeInfo = {
-                nodeVersion,
-                l1ChainId: chainId,
-                rollupVersion,
-                enr,
-                l1ContractAddresses: contractAddresses,
-                protocolContractAddresses: protocolContractAddresses
-            };
-        }
-        return this.#nodeInfo;
-    }
-    getPXEInfo() {
-        return Promise.resolve({
-            pxeVersion: this.packageVersion,
-            protocolContractAddresses: {
-                classRegistry: ProtocolContractAddress.ContractClassRegistry,
-                feeJuice: ProtocolContractAddress.FeeJuice,
-                instanceRegistry: ProtocolContractAddress.ContractInstanceRegistry,
-                multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint
-            }
-        });
-    }
-    async getPrivateEvents(contractAddress, eventMetadataDef, from, numBlocks, recipients) {
+    /**
+   * Returns the private events given search parameters.
+   * @param contractAddress - The address of the contract to get events from.
+   * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
+   * @param from - The block number to search from.
+   * @param numBlocks - The amount of blocks to search.
+   * @param recipients - The addresses that decrypted the logs.
+   * @returns - The deserialized events.
+   */ async getPrivateEvents(contractAddress, eventMetadataDef, from, numBlocks, recipients) {
         if (recipients.length === 0) {
             throw new Error('Recipients are required to get private events');
         }
@@ -757,32 +781,9 @@ import { enrichPublicSimulationError, enrichSimulationError } from './error_enri
             ], event));
         return decodedEvents;
     }
-    async getPublicEvents(eventMetadataDef, from, limit) {
-        const { logs } = await this.node.getPublicLogs({
-            fromBlock: from,
-            toBlock: from + limit
-        });
-        const decodedEvents = logs.map((log)=>{
-            // +1 for the event selector
-            const expectedLength = eventMetadataDef.fieldNames.length + 1;
-            if (log.log.emittedLength !== expectedLength) {
-                throw new Error(`Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.emittedLength}.`);
-            }
-            const logFields = log.log.getEmittedFields();
-            // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
-            if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
-                return undefined;
-            }
-            return decodeFromAbi([
-                eventMetadataDef.abiType
-            ], log.log.fields);
-        }).filter((log)=>log !== undefined);
-        return decodedEvents;
-    }
-    async resetNoteSyncData() {
-        return await this.taggingDataProvider.resetNoteSyncData();
-    }
-    stop() {
+    /**
+   * Stops the PXE's job queue.
+   */ stop() {
         return this.jobQueue.end();
     }
 }

package/dest/storage/address_data_provider/address_data_provider.d.ts

@@ -1,13 +1,11 @@
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress } from '@aztec/stdlib/contract';
-import type { DataProvider } from '../data_provider.js';
-export declare class AddressDataProvider implements DataProvider {
+export declare class AddressDataProvider {
     #private;
     constructor(store: AztecAsyncKVStore);
     addCompleteAddress(completeAddress: CompleteAddress): Promise<boolean>;
     getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined>;
     getCompleteAddresses(): Promise<CompleteAddress[]>;
-    getSize(): Promise<number>;
 }
 //# sourceMappingURL=address_data_provider.d.ts.map