@aztec/simulator 0.0.0-test.0

package/dest/public/public_processor/public_processor.js

@@ -0,0 +1,379 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { Gas } from '@aztec/stdlib/gas';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { NestedProcessReturnValues, Tx, TxExecutionPhase, makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '@aztec/stdlib/tx';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { ForkCheckpoint } from '@aztec/world-state/native';
+import { WorldStateDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicProcessorMetrics } from './public_processor_metrics.js';
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */ export class PublicProcessorFactory {
+    contractDataSource;
+    dateProvider;
+    telemetryClient;
+    constructor(contractDataSource, dateProvider, telemetryClient = getTelemetryClient()){
+        this.contractDataSource = contractDataSource;
+        this.dateProvider = dateProvider;
+        this.telemetryClient = telemetryClient;
+    }
+    /**
+   * Creates a new instance of a PublicProcessor.
+   * @param historicalHeader - The header of a block previous to the one in which the tx is included.
+   * @param globalVariables - The global variables for the block being processed.
+   * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
+   * @returns A new instance of a PublicProcessor.
+   */ create(merkleTree, globalVariables, skipFeeEnforcement) {
+        const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
+        const publicTxSimulator = this.createPublicTxSimulator(merkleTree, worldStateDB, globalVariables, /*doMerkleOperations=*/ true, skipFeeEnforcement, this.telemetryClient);
+        return new PublicProcessor(merkleTree, globalVariables, worldStateDB, publicTxSimulator, this.dateProvider, this.telemetryClient);
+    }
+    createPublicTxSimulator(db, worldStateDB, globalVariables, doMerkleOperations, skipFeeEnforcement, telemetryClient) {
+        return new PublicTxSimulator(db, worldStateDB, globalVariables, doMerkleOperations, skipFeeEnforcement, telemetryClient);
+    }
+}
+class PublicProcessorTimeoutError extends Error {
+    constructor(message = 'Timed out while processing tx'){
+        super(message);
+        this.name = 'PublicProcessorTimeoutError';
+    }
+}
+/**
+ * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
+ * any public function calls in them. Txs with private calls only are unaffected.
+ */ export class PublicProcessor {
+    db;
+    globalVariables;
+    worldStateDB;
+    publicTxSimulator;
+    dateProvider;
+    log;
+    metrics;
+    constructor(db, globalVariables, worldStateDB, publicTxSimulator, dateProvider, telemetryClient = getTelemetryClient(), log = createLogger('simulator:public-processor')){
+        this.db = db;
+        this.globalVariables = globalVariables;
+        this.worldStateDB = worldStateDB;
+        this.publicTxSimulator = publicTxSimulator;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    /**
+   * Run each tx through the public circuit and the public kernel circuit if needed.
+   * @param txs - Txs to process.
+   * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
+   * @returns The list of processed txs with their circuit simulation outputs.
+   */ async process(txs, limits = {}, validators = {}) {
+        const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
+        const { preprocessValidator, postprocessValidator, nullifierCache } = validators;
+        const result = [];
+        const failed = [];
+        const timer = new Timer();
+        let totalSizeInBytes = 0;
+        let returns = [];
+        let totalPublicGas = new Gas(0, 0);
+        let totalBlockGas = new Gas(0, 0);
+        for await (const origTx of txs){
+            // Only process up to the max tx limit
+            if (maxTransactions !== undefined && result.length >= maxTransactions) {
+                this.log.debug(`Stopping tx processing due to reaching the max tx limit.`);
+                break;
+            }
+            // Bail if we've hit the deadline
+            if (deadline && this.dateProvider.now() > +deadline) {
+                this.log.warn(`Stopping tx processing due to timeout.`);
+                break;
+            }
+            // Skip this tx if it'd exceed max block size
+            const txHash = (await origTx.getTxHash()).toString();
+            const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
+            if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
+                this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
+                    txHash,
+                    sizeInBytes: preTxSizeInBytes,
+                    totalSizeInBytes,
+                    maxBlockSize
+                });
+                continue;
+            }
+            // Skip this tx if its gas limit would exceed the block gas limit
+            const txGasLimit = origTx.data.constants.txContext.gasSettings.gasLimits;
+            if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
+                this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
+                    txHash,
+                    txGasLimit,
+                    totalBlockGas,
+                    maxBlockGas
+                });
+                continue;
+            }
+            // The processor modifies the tx objects in place, so we need to clone them.
+            const tx = Tx.clone(origTx);
+            // We validate the tx before processing it, to avoid unnecessary work.
+            if (preprocessValidator) {
+                const result = await preprocessValidator.validateTx(tx);
+                const txHash = await tx.getTxHash();
+                if (result.result === 'invalid') {
+                    const reason = result.reason.join(', ');
+                    this.log.warn(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
+                    failed.push({
+                        tx,
+                        error: new Error(`Tx failed preprocess validation: ${reason}`)
+                    });
+                    returns.push(new NestedProcessReturnValues([]));
+                    continue;
+                } else if (result.result === 'skipped') {
+                    const reason = result.reason.join(', ');
+                    this.log.warn(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
+                    returns.push(new NestedProcessReturnValues([]));
+                    continue;
+                } else {
+                    this.log.trace(`Tx ${txHash.toString()} is valid before processing.`);
+                }
+            }
+            // We checkpoint the transaction here, then within the try/catch we
+            // 1. Revert the checkpoint if the tx fails or needs to be discarded for any reason
+            // 2. Commit the transaction in the finally block. Note that by using the ForkCheckpoint lifecycle only the first commit/revert takes effect
+            const checkpoint = await ForkCheckpoint.new(this.worldStateDB);
+            try {
+                const [processedTx, returnValues] = await this.processTx(tx, deadline);
+                // If the actual size of this tx would exceed block size, skip it
+                const txSize = processedTx.txEffect.getDASize();
+                if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
+                    this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
+                        txHash,
+                        sizeInBytes: txSize,
+                        totalSizeInBytes,
+                        maxBlockSize
+                    });
+                    // Need to revert the checkpoint here and don't go any further
+                    await checkpoint.revert();
+                    continue;
+                }
+                // Re-validate the transaction
+                if (postprocessValidator) {
+                    // Only accept processed transactions that are not double-spends,
+                    // public functions emitting nullifiers would pass earlier check but fail here.
+                    // Note that we're checking all nullifiers generated in the private execution twice,
+                    // we could store the ones already checked and skip them here as an optimization.
+                    // TODO(palla/txs): Can we get into this case? AVM validates this. We should be able to remove it.
+                    const result = await postprocessValidator.validateTx(processedTx);
+                    if (result.result !== 'valid') {
+                        const reason = result.reason.join(', ');
+                        this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
+                        failed.push({
+                            tx,
+                            error: new Error(`Tx failed post-process validation: ${reason}`)
+                        });
+                        // Need to revert the checkpoint here and don't go any further
+                        await checkpoint.revert();
+                        continue;
+                    } else {
+                        this.log.trace(`Tx ${txHash.toString()} is valid post processing.`);
+                    }
+                }
+                if (!tx.hasPublicCalls()) {
+                    // If there are no public calls, perform all tree insertions for side effects from private
+                    // When there are public calls, the PublicTxSimulator & AVM handle tree insertions.
+                    await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
+                    // Add any contracts registered/deployed in this private-only tx to the block-level cache
+                    // (add to tx-level cache and then commit to block-level cache)
+                    await this.worldStateDB.addNewContracts(tx);
+                    this.worldStateDB.commitContractsForTx();
+                }
+                nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map((n)=>n.toBuffer()));
+                result.push(processedTx);
+                returns = returns.concat(returnValues);
+                totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
+                totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
+                totalSizeInBytes += txSize;
+            } catch (err) {
+                // Roll back state to start of TX before proceeding to next TX
+                await checkpoint.revert();
+                if (err?.name === 'PublicProcessorTimeoutError') {
+                    this.log.warn(`Stopping tx processing due to timeout.`);
+                    break;
+                }
+                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
+                failed.push({
+                    tx,
+                    error: err instanceof Error ? err : new Error(errorMessage)
+                });
+                returns.push(new NestedProcessReturnValues([]));
+            } finally{
+                // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was reverted
+                await checkpoint.commit();
+                // The tx-level contracts cache should not live on to the next tx
+                this.worldStateDB.clearContractsForTx();
+            }
+        }
+        const duration = timer.s();
+        const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
+        this.metrics.recordAllTxs(totalPublicGas, rate);
+        this.log.info(`Processed ${result.length} successful txs and ${failed.length} failed txs in ${duration}s`, {
+            duration,
+            rate,
+            totalPublicGas,
+            totalBlockGas,
+            totalSizeInBytes
+        });
+        return [
+            result,
+            failed,
+            returns
+        ];
+    }
+    async processTx(tx, deadline) {
+        const [time, [processedTx, returnValues]] = await elapsed(()=>this.processTxWithinDeadline(tx, deadline));
+        this.log.verbose(!tx.hasPublicCalls() ? `Processed tx ${processedTx.hash} with no public calls in ${time}ms` : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls in ${time}ms`, {
+            txHash: processedTx.hash,
+            txFee: processedTx.txEffect.transactionFee.toBigInt(),
+            revertCode: processedTx.txEffect.revertCode.getCode(),
+            revertReason: processedTx.revertReason,
+            gasUsed: processedTx.gasUsed,
+            publicDataWriteCount: processedTx.txEffect.publicDataWrites.length,
+            nullifierCount: processedTx.txEffect.nullifiers.length,
+            noteHashCount: processedTx.txEffect.noteHashes.length,
+            contractClassLogCount: processedTx.txEffect.contractClassLogs.length,
+            publicLogCount: processedTx.txEffect.publicLogs.length,
+            privateLogCount: processedTx.txEffect.privateLogs.length,
+            l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
+            durationMs: time
+        });
+        return [
+            processedTx,
+            returnValues ?? []
+        ];
+    }
+    async doTreeInsertionsForPrivateOnlyTx(processedTx, txValidator) {
+        const treeInsertionStart = process.hrtime.bigint();
+        // Update the state so that the next tx in the loop has the correct .startState
+        // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
+        // a) had only 1 tx with public calls per block, so this loop had len 1
+        // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
+        // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
+        // The below is taken from buildBaseRollupHints:
+        await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
+        try {
+            await this.db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((n)=>n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+        } catch (error) {
+            if (txValidator) {
+                // Ideally the validator has already caught this above, but just in case:
+                throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
+            } else {
+                // We have no validator and assume this call should blindly process txs with duplicates being caught later
+                this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
+            }
+        }
+        // The only public data write should be for fee payment
+        await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, processedTx.txEffect.publicDataWrites.map((x)=>x.toBuffer()));
+        const treeInsertionEnd = process.hrtime.bigint();
+        this.metrics.recordTreeInsertions(Number(treeInsertionEnd - treeInsertionStart) / 1_000);
+    }
+    /** Processes the given tx within deadline. Returns timeout if deadline is hit. */ async processTxWithinDeadline(tx, deadline) {
+        const processFn = tx.hasPublicCalls() ? ()=>this.processTxWithPublicCalls(tx) : ()=>this.processPrivateOnlyTx(tx);
+        if (!deadline) {
+            return await processFn();
+        }
+        const txHash = await tx.getTxHash();
+        const timeout = +deadline - this.dateProvider.now();
+        if (timeout <= 0) {
+            throw new PublicProcessorTimeoutError();
+        }
+        this.log.debug(`Processing tx ${txHash.toString()} within ${timeout}ms`, {
+            deadline: deadline.toISOString(),
+            now: new Date(this.dateProvider.now()).toISOString(),
+            txHash
+        });
+        return await executeTimeout(()=>processFn(), timeout, ()=>new PublicProcessorTimeoutError());
+    }
+    /**
+   * Creates the public data write for paying the tx fee.
+   * This is used in private only txs, since for txs with public calls
+   * the avm handles the fee payment itself.
+   */ async getFeePaymentPublicDataWrite(txFee, feePayer) {
+        const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
+        const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
+        const leafSlot = await computeFeePayerBalanceLeafSlot(feePayer);
+        this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
+        const balance = await this.worldStateDB.storageRead(feeJuiceAddress, balanceSlot);
+        if (balance.lt(txFee)) {
+            throw new Error(`Not enough balance for fee payer to pay for transaction (got ${balance.toBigInt()} needs ${txFee.toBigInt()})`);
+        }
+        const updatedBalance = balance.sub(txFee);
+        await this.worldStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
+        return new PublicDataWrite(leafSlot, updatedBalance);
+    }
+    async processPrivateOnlyTx(tx) {
+        const gasFees = this.globalVariables.gasFees;
+        const transactionFee = tx.data.gasUsed.computeFee(gasFees);
+        const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
+        const processedTx = await makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, this.globalVariables);
+        const siloedContractClassLogs = await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true);
+        this.metrics.recordClassRegistration(...siloedContractClassLogs.filter((log)=>ContractClassRegisteredEvent.isContractClassRegisteredEvent(log)).map((log)=>ContractClassRegisteredEvent.fromLog(log)));
+        return [
+            processedTx,
+            undefined
+        ];
+    }
+    async processTxWithPublicCalls(tx) {
+        const timer = new Timer();
+        const { avmProvingRequest, gasUsed, revertCode, revertReason, processedPhases } = await this.publicTxSimulator.simulate(tx);
+        if (!avmProvingRequest) {
+            this.metrics.recordFailedTx();
+            throw new Error('Avm proving result was not generated.');
+        }
+        processedPhases.forEach((phase)=>{
+            if (phase.reverted) {
+                this.metrics.recordRevertedPhase(phase.phase);
+            } else {
+                this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
+            }
+        });
+        const siloedContractClassLogs = await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true);
+        this.metrics.recordClassRegistration(...siloedContractClassLogs.filter((log)=>ContractClassRegisteredEvent.isContractClassRegisteredEvent(log)).map((log)=>ContractClassRegisteredEvent.fromLog(log)));
+        const phaseCount = processedPhases.length;
+        const durationMs = timer.ms();
+        this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
+        const processedTx = await makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason);
+        const returnValues = processedPhases.find(({ phase })=>phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
+        return [
+            processedTx,
+            returnValues
+        ];
+    }
+}
+_ts_decorate([
+    trackSpan('PublicProcessor.processTx', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], PublicProcessor.prototype, "processTx", null);
+_ts_decorate([
+    trackSpan('PublicProcessor.processPrivateOnlyTx', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], PublicProcessor.prototype, "processPrivateOnlyTx", null);
+_ts_decorate([
+    trackSpan('PublicProcessor.processTxWithPublicCalls', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], PublicProcessor.prototype, "processTxWithPublicCalls", null);

package/dest/public/public_processor/public_processor_metrics.d.ts

@@ -0,0 +1,27 @@
+import type { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+export declare class PublicProcessorMetrics {
+    readonly tracer: Tracer;
+    private txDuration;
+    private txCount;
+    private txPhaseCount;
+    private phaseDuration;
+    private phaseCount;
+    private bytecodeDeployed;
+    private totalGas;
+    private totalGasHistogram;
+    private gasRate;
+    private txGas;
+    private treeInsertionDuration;
+    constructor(client: TelemetryClient, name?: string);
+    recordPhaseDuration(phaseName: TxExecutionPhase, durationMs: number): void;
+    recordTx(phaseCount: number, durationMs: number, gasUsed: Gas): void;
+    recordAllTxs(totalGas: Gas, gasRate: number): void;
+    recordFailedTx(): void;
+    recordRevertedPhase(phaseName: TxExecutionPhase): void;
+    recordClassRegistration(...events: ContractClassRegisteredEvent[]): void;
+    recordTreeInsertions(durationUs: number): void;
+}
+//# sourceMappingURL=public_processor_metrics.d.ts.map

package/dest/public/public_processor/public_processor_metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor_metrics.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAC/F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,sBAAsB;IACjC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,gBAAgB,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,KAAK,CAAY;IAEzB,OAAO,CAAC,qBAAqB,CAAY;gBAE7B,MAAM,EAAE,eAAe,EAAE,IAAI,SAAoB;IA4D7D,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM;IAKnE,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG;IAc7D,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;IAkB3C,cAAc;IAMd,mBAAmB,CAAC,SAAS,EAAE,gBAAgB;IAI/C,uBAAuB,CAAC,GAAG,MAAM,EAAE,4BAA4B,EAAE;IAWjE,oBAAoB,CAAC,UAAU,EAAE,MAAM;CAGxC"}

package/dest/public/public_processor/public_processor_metrics.js

@@ -0,0 +1,125 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class PublicProcessorMetrics {
+    tracer;
+    txDuration;
+    txCount;
+    txPhaseCount;
+    phaseDuration;
+    phaseCount;
+    bytecodeDeployed;
+    totalGas;
+    totalGasHistogram;
+    gasRate;
+    txGas;
+    treeInsertionDuration;
+    constructor(client, name = 'PublicProcessor'){
+        this.tracer = client.getTracer(name);
+        const meter = client.getMeter(name);
+        this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION, {
+            description: 'How long it takes to process a transaction',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.txCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
+            description: 'Number of transactions processed'
+        });
+        this.txPhaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT, {
+            description: 'Number of phases processed'
+        });
+        this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION, {
+            description: 'How long it takes to process a phase',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.phaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
+            description: 'Number of failed phases'
+        });
+        this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE, {
+            description: 'Size of deployed bytecode',
+            unit: 'By'
+        });
+        this.totalGas = meter.createGauge(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS, {
+            description: 'Total gas used in block',
+            unit: 'gas'
+        });
+        this.totalGasHistogram = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM, {
+            description: 'Total gas used in block as histogram',
+            unit: 'gas/block'
+        });
+        this.txGas = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_GAS, {
+            description: 'Gas used in transaction',
+            unit: 'gas/tx'
+        });
+        this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE, {
+            description: 'L2 gas per second for complete block',
+            unit: 'gas/s'
+        });
+        this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION, {
+            description: 'How long it takes for tree insertion',
+            unit: 'us',
+            valueType: ValueType.INT
+        });
+    }
+    recordPhaseDuration(phaseName, durationMs) {
+        this.phaseCount.add(1, {
+            [Attributes.TX_PHASE_NAME]: phaseName,
+            [Attributes.OK]: true
+        });
+        this.phaseDuration.record(Math.ceil(durationMs), {
+            [Attributes.TX_PHASE_NAME]: phaseName
+        });
+    }
+    recordTx(phaseCount, durationMs, gasUsed) {
+        this.txPhaseCount.add(phaseCount);
+        this.txDuration.record(Math.ceil(durationMs));
+        this.txCount.add(1, {
+            [Attributes.OK]: true
+        });
+        this.txGas.record(gasUsed.daGas, {
+            [Attributes.GAS_DIMENSION]: 'DA'
+        });
+        this.txGas.record(gasUsed.l2Gas, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+    }
+    recordAllTxs(totalGas, gasRate) {
+        this.totalGas.record(totalGas.daGas, {
+            [Attributes.GAS_DIMENSION]: 'DA'
+        });
+        this.totalGas.record(totalGas.l2Gas, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+        this.gasRate.record(gasRate, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+        this.totalGasHistogram.record(totalGas.daGas, {
+            [Attributes.GAS_DIMENSION]: 'DA'
+        });
+        this.totalGasHistogram.record(totalGas.l2Gas, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+    }
+    recordFailedTx() {
+        this.txCount.add(1, {
+            [Attributes.OK]: false
+        });
+    }
+    recordRevertedPhase(phaseName) {
+        this.phaseCount.add(1, {
+            [Attributes.TX_PHASE_NAME]: phaseName,
+            [Attributes.OK]: false
+        });
+    }
+    recordClassRegistration(...events) {
+        let totalBytecode = 0;
+        for (const event of events){
+            totalBytecode += event.packedPublicBytecode.length;
+        }
+        if (totalBytecode > 0) {
+            this.bytecodeDeployed.record(totalBytecode);
+        }
+    }
+    recordTreeInsertions(durationUs) {
+        this.treeInsertionDuration.record(Math.ceil(durationUs));
+    }
+}

package/dest/public/public_tx_simulator/public_tx_context.d.ts

@@ -0,0 +1,137 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { type PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
+import { type GlobalVariables, type PublicExecutionRequest, type StateReference, type Tx, TxExecutionPhase, type TxHash } from '@aztec/stdlib/tx';
+import { AvmPersistableStateManager } from '../avm/index.js';
+import type { WorldStateDB } from '../public_db_sources.js';
+import { SideEffectTrace } from '../side_effect_trace.js';
+/**
+ * The transaction-level context for public execution.
+ */
+export declare class PublicTxContext {
+    readonly txHash: TxHash;
+    readonly state: PhaseStateManager;
+    private readonly globalVariables;
+    private readonly startStateReference;
+    private readonly gasSettings;
+    private readonly gasUsedByPrivate;
+    private readonly gasAllocatedToPublic;
+    private readonly setupCallRequests;
+    private readonly appLogicCallRequests;
+    private readonly teardownCallRequests;
+    private readonly setupExecutionRequests;
+    private readonly appLogicExecutionRequests;
+    private readonly teardownExecutionRequests;
+    readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData;
+    readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData;
+    readonly feePayer: AztecAddress;
+    trace: SideEffectTrace;
+    private log;
+    private gasUsedByPublic;
+    teardownGasUsed: Gas;
+    private halted;
+    private revertCode;
+    revertReason: SimulationError | undefined;
+    avmProvingRequest: AvmProvingRequest | undefined;
+    constructor(txHash: TxHash, state: PhaseStateManager, globalVariables: GlobalVariables, startStateReference: StateReference, gasSettings: GasSettings, gasUsedByPrivate: Gas, gasAllocatedToPublic: Gas, setupCallRequests: PublicCallRequest[], appLogicCallRequests: PublicCallRequest[], teardownCallRequests: PublicCallRequest[], setupExecutionRequests: PublicExecutionRequest[], appLogicExecutionRequests: PublicExecutionRequest[], teardownExecutionRequests: PublicExecutionRequest[], nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData, revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData, feePayer: AztecAddress, trace: SideEffectTrace);
+    static create(db: MerkleTreeReadOperations, worldStateDB: WorldStateDB, tx: Tx, globalVariables: GlobalVariables, doMerkleOperations: boolean): Promise<PublicTxContext>;
+    /**
+     * Signal that the entire transaction execution is done.
+     * All phases have been processed.
+     * Actual transaction fee and actual total consumed gas can now be queried.
+     */
+    halt(): Promise<void>;
+    /**
+     * Revert execution a phase. Populate revertReason & revertCode.
+     * If in setup, throw an error (transaction will be thrown out).
+     * NOTE: this does not "halt" the entire transaction execution.
+     */
+    revert(phase: TxExecutionPhase, revertReason?: SimulationError | undefined, culprit?: string): void;
+    /**
+     * Get the revert code.
+     * @returns The revert code.
+     */
+    getFinalRevertCode(): RevertCode;
+    /**
+     * Are there any call requests for the speciiied phase?
+     */
+    hasPhase(phase: TxExecutionPhase): boolean;
+    /**
+     * Get the call requests for the specified phase (including args hashes).
+     */
+    getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequest[];
+    /**
+     * Get the call requests for the specified phase (including actual args).
+     */
+    getExecutionRequestsForPhase(phase: TxExecutionPhase): PublicExecutionRequest[];
+    /**
+     * How much gas is left as of the specified phase?
+     */
+    getGasLeftAtPhase(phase: TxExecutionPhase): Gas;
+    /**
+     * Consume gas. Track gas for teardown phase separately.
+     */
+    consumeGas(phase: TxExecutionPhase, gas: Gas): void;
+    /**
+     * The gasUsed by public and private,
+     * as if the entire teardown gas limit was consumed.
+     */
+    getTotalGasUsed(): Gas;
+    /**
+     * Compute the gas used using the actual gas used during teardown instead
+     * of the teardown gas limit.
+     * Note that this.gasUsed is initialized from private's gasUsed which includes
+     * teardown gas limit.
+     */
+    getActualGasUsed(): Gas;
+    /**
+     * Compute the public gas used using the actual gas used during teardown instead
+     * of the teardown gas limit.
+     */
+    getActualPublicGasUsed(): Gas;
+    /**
+     * Get the transaction fee as is available to the specified phase.
+     * Only teardown should have access to the actual transaction fee.
+     */
+    getTransactionFee(phase: TxExecutionPhase): Fr;
+    /**
+     * Compute the transaction fee.
+     * Should only be called during or after teardown.
+     */
+    private getTransactionFeeUnsafe;
+    /**
+     * Generate the public inputs for the AVM circuit.
+     */
+    private generateAvmCircuitPublicInputs;
+    /**
+     * Generate the proving request for the AVM circuit.
+     */
+    generateProvingRequest(endStateReference: StateReference): Promise<AvmProvingRequest>;
+}
+/**
+ * Thin wrapper around the state manager to handle forking and merging for phases.
+ *
+ * This lets us keep track of whether the state has already been forked
+ * so that we can conditionally fork at the start of a phase.
+ *
+ * There is a state manager that lives at the level of the entire transaction,
+ * but for app logic and teardown the active state manager will be a fork of the
+ * transaction level one.
+ */
+declare class PhaseStateManager {
+    private readonly txStateManager;
+    private log;
+    private currentlyActiveStateManager;
+    constructor(txStateManager: AvmPersistableStateManager);
+    fork(): Promise<void>;
+    getActiveStateManager(): AvmPersistableStateManager;
+    isForked(): boolean;
+    mergeForkedState(): Promise<void>;
+    discardForkedState(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=public_tx_context.d.ts.map