@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/dest/private_kernel/private_kernel_execution_prover.js

@@ -0,0 +1,285 @@
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { pushTestData } from '@aztec/foundation/testing';
+import { Timer } from '@aztec/foundation/timer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractsList } from '@aztec/protocol-contracts';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { HidingKernelToPublicPrivateInputs, HidingKernelToRollupPrivateInputs, PaddedSideEffectAmounts, PrivateCallData, PrivateKernelCircuitPublicInputs, PrivateKernelData, PrivateKernelInitCircuitPrivateInputs, PrivateKernelInnerCircuitPrivateInputs, PrivateKernelTailCircuitPrivateInputs, PrivateVerificationKeyHints } from '@aztec/stdlib/kernel';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { collectNoteHashLeafIndexMap, collectNoteHashNullifierCounterMap, getFinalMinRevertibleSideEffectCounter } from '@aztec/stdlib/tx';
+import { VerificationKeyAsFields, VerificationKeyData, VkData } from '@aztec/stdlib/vks';
+import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
+const NULL_SIMULATE_OUTPUT = {
+    publicInputs: PrivateKernelCircuitPublicInputs.empty(),
+    verificationKey: VerificationKeyData.empty(),
+    outputWitness: new Map(),
+    bytecode: Buffer.from([])
+};
+/**
+ * The PrivateKernelExecutionProver class is responsible for taking a transaction request and sequencing the
+ * the execution of the private functions within, sequenced with private kernel "glue" to check protocol rules.
+ * The result can be a chonk proof of the private transaction portion, or just a simulation that can e.g.
+ * inform state tree updates.
+ */ export class PrivateKernelExecutionProver {
+    oracle;
+    proofCreator;
+    fakeProofs;
+    log;
+    constructor(oracle, proofCreator, fakeProofs = false){
+        this.oracle = oracle;
+        this.proofCreator = proofCreator;
+        this.fakeProofs = fakeProofs;
+        this.log = createLogger('pxe:private-kernel-execution-prover');
+    }
+    /**
+   * Generate a proof for a given transaction request and execution result.
+   * The function iterates through the nested executions in the execution result, creates private call data,
+   * and generates a proof using the provided ProofCreator instance. It also maintains an index of new notes
+   * created during the execution and returns them as a part of the KernelProverOutput.
+   *
+   * @param txRequest - The authenticated transaction request object.
+   * @param executionResult - The execution result object containing nested executions and preimages.
+   * @param profile - Set true to profile the gate count for each circuit
+   * @returns A Promise that resolves to a KernelProverOutput object containing proof, public inputs, and output notes.
+   */ async proveWithKernels(txRequest, executionResult, { simulate, skipFeeEnforcement, profileMode } = {
+        simulate: false,
+        skipFeeEnforcement: false,
+        profileMode: 'none'
+    }) {
+        const skipProofGeneration = this.fakeProofs || simulate;
+        const generateWitnesses = !skipProofGeneration || profileMode !== 'none';
+        const timer = new Timer();
+        const isPrivateOnlyTx = executionResult.publicFunctionCalldata.length === 0;
+        // Initialize an executionStack, beginning with the PrivateCallExecutionResult
+        // of the entrypoint function of the tx.
+        const executionStack = [
+            executionResult.entrypoint
+        ];
+        let firstIteration = true;
+        let output = NULL_SIMULATE_OUTPUT;
+        const executionSteps = [];
+        const noteHashLeafIndexMap = collectNoteHashLeafIndexMap(executionResult);
+        const noteHashNullifierCounterMap = collectNoteHashNullifierCounterMap(executionResult);
+        const validationRequestsSplitCounter = isPrivateOnlyTx ? 0 : getFinalMinRevertibleSideEffectCounter(executionResult);
+        while(executionStack.length){
+            if (!firstIteration) {
+                let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, executionStack, noteHashNullifierCounterMap, validationRequestsSplitCounter);
+                while(resetBuilder.needsReset()){
+                    const witgenTimer = new Timer();
+                    const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
+                    output = generateWitnesses ? await this.proofCreator.generateResetOutput(privateInputs) : await this.proofCreator.simulateReset(privateInputs);
+                    executionSteps.push({
+                        functionName: 'private_kernel_reset',
+                        bytecode: output.bytecode,
+                        witness: output.outputWitness,
+                        vk: output.verificationKey.keyAsBytes,
+                        timings: {
+                            witgen: witgenTimer.ms()
+                        }
+                    });
+                    resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, executionStack, noteHashNullifierCounterMap, validationRequestsSplitCounter);
+                }
+            }
+            const currentExecution = executionStack.pop();
+            executionStack.push(...[
+                ...currentExecution.nestedExecutionResults
+            ].reverse());
+            const functionName = await this.oracle.getDebugFunctionName(currentExecution.publicInputs.callContext.contractAddress, currentExecution.publicInputs.callContext.functionSelector);
+            executionSteps.push({
+                functionName: functionName,
+                bytecode: currentExecution.acir,
+                witness: currentExecution.partialWitness,
+                vk: currentExecution.vk,
+                timings: {
+                    witgen: currentExecution.profileResult?.timings.witgen ?? 0,
+                    oracles: currentExecution.profileResult?.timings.oracles
+                }
+            });
+            const privateCallData = await this.createPrivateCallData(currentExecution);
+            if (firstIteration) {
+                const witgenTimer = new Timer();
+                const proofInput = new PrivateKernelInitCircuitPrivateInputs(txRequest, getVKTreeRoot(), ProtocolContractsList, privateCallData, isPrivateOnlyTx, executionResult.firstNullifier);
+                this.log.debug(`Calling private kernel init with isPrivateOnly ${isPrivateOnlyTx} and firstNullifierHint ${proofInput.firstNullifierHint}`);
+                pushTestData('private-kernel-inputs-init', proofInput);
+                output = generateWitnesses ? await this.proofCreator.generateInitOutput(proofInput) : await this.proofCreator.simulateInit(proofInput);
+                executionSteps.push({
+                    functionName: 'private_kernel_init',
+                    bytecode: output.bytecode,
+                    witness: output.outputWitness,
+                    vk: output.verificationKey.keyAsBytes,
+                    timings: {
+                        witgen: witgenTimer.ms()
+                    }
+                });
+            } else {
+                const witgenTimer = new Timer();
+                const vkData = await this.getVkData(output.verificationKey);
+                const previousKernelData = new PrivateKernelData(output.publicInputs, vkData);
+                const proofInput = new PrivateKernelInnerCircuitPrivateInputs(previousKernelData, privateCallData);
+                pushTestData('private-kernel-inputs-inner', proofInput);
+                output = generateWitnesses ? await this.proofCreator.generateInnerOutput(proofInput) : await this.proofCreator.simulateInner(proofInput);
+                executionSteps.push({
+                    functionName: 'private_kernel_inner',
+                    bytecode: output.bytecode,
+                    witness: output.outputWitness,
+                    vk: output.verificationKey.keyAsBytes,
+                    timings: {
+                        witgen: witgenTimer.ms()
+                    }
+                });
+            }
+            firstIteration = false;
+        }
+        // Reset.
+        let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, [], noteHashNullifierCounterMap, validationRequestsSplitCounter);
+        while(resetBuilder.needsReset()){
+            const witgenTimer = new Timer();
+            const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
+            output = generateWitnesses ? await this.proofCreator.generateResetOutput(privateInputs) : await this.proofCreator.simulateReset(privateInputs);
+            executionSteps.push({
+                functionName: 'private_kernel_reset',
+                bytecode: output.bytecode,
+                witness: output.outputWitness,
+                vk: output.verificationKey.keyAsBytes,
+                timings: {
+                    witgen: witgenTimer.ms()
+                }
+            });
+            resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, [], noteHashNullifierCounterMap, validationRequestsSplitCounter);
+        }
+        if (output.publicInputs.feePayer.isZero() && skipFeeEnforcement) {
+            if (!skipProofGeneration) {
+                throw new Error('Fee payment must be enforced when creating real proof.');
+            }
+            output.publicInputs.feePayer = new AztecAddress(Fr.MAX_FIELD_VALUE);
+        }
+        // Private tail.
+        const vkData = await this.getVkData(output.verificationKey);
+        const previousKernelData = new PrivateKernelData(output.publicInputs, vkData);
+        this.log.debug(`Calling private kernel tail with hwm ${previousKernelData.publicInputs.minRevertibleSideEffectCounter}`);
+        // TODO: Enable padding once we better understand the final amounts to pad to.
+        const paddedSideEffectAmounts = PaddedSideEffectAmounts.empty();
+        // Use the aggregated includeByTimestamp set throughout the tx execution.
+        // TODO: Call `computeTxIncludeByTimestamp` to round the value down and reduce precision, improving privacy.
+        const includeByTimestampUpperBound = previousKernelData.publicInputs.includeByTimestamp;
+        const anchorBlockTimestamp = previousKernelData.publicInputs.constants.anchorBlockHeader.globalVariables.timestamp;
+        if (includeByTimestampUpperBound <= anchorBlockTimestamp) {
+            throw new Error(`Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${includeByTimestampUpperBound}.`);
+        }
+        const privateInputs = new PrivateKernelTailCircuitPrivateInputs(previousKernelData, paddedSideEffectAmounts, includeByTimestampUpperBound);
+        const witgenTimer = new Timer();
+        const tailOutput = generateWitnesses ? await this.proofCreator.generateTailOutput(privateInputs) : await this.proofCreator.simulateTail(privateInputs);
+        executionSteps.push({
+            functionName: 'private_kernel_tail',
+            bytecode: tailOutput.bytecode,
+            witness: tailOutput.outputWitness,
+            vk: tailOutput.verificationKey.keyAsBytes,
+            timings: {
+                witgen: witgenTimer.ms()
+            }
+        });
+        // Hiding circuit is only executed if we are generating witnesses.
+        // For simulation, we can end with the tail, since the hiding circuit will simply return the same tail output.
+        if (generateWitnesses) {
+            const previousKernelVkData = await this.getVkData(tailOutput.verificationKey);
+            const witgenTimer = new Timer();
+            let hidingOutput;
+            if (tailOutput.publicInputs.forPublic) {
+                const privateInputs = new HidingKernelToPublicPrivateInputs(tailOutput.publicInputs.toPrivateToPublicKernelCircuitPublicInputs(), previousKernelVkData);
+                hidingOutput = await this.proofCreator.generateHidingToPublicOutput(privateInputs);
+            } else {
+                const privateInputs = new HidingKernelToRollupPrivateInputs(tailOutput.publicInputs.toPrivateToRollupKernelCircuitPublicInputs(), previousKernelVkData);
+                hidingOutput = await this.proofCreator.generateHidingToRollupOutput(privateInputs);
+            }
+            executionSteps.push({
+                functionName: 'hiding_kernel',
+                bytecode: hidingOutput.bytecode,
+                witness: hidingOutput.outputWitness,
+                vk: hidingOutput.verificationKey.keyAsBytes,
+                timings: {
+                    witgen: witgenTimer.ms()
+                }
+            });
+        }
+        if (profileMode == 'gates' || profileMode == 'full') {
+            for (const entry of executionSteps){
+                const gateCountTimer = new Timer();
+                const gateCount = await this.proofCreator.computeGateCountForCircuit(entry.bytecode, entry.functionName);
+                entry.gateCount = gateCount;
+                entry.timings.gateCount = gateCountTimer.ms();
+            }
+        }
+        if (profileMode === 'gates') {
+            for (const entry of executionSteps){
+                // These buffers are often a few megabytes in size - prevent accidentally serializing them if not requested.
+                entry.bytecode = Buffer.from([]);
+                entry.witness = new Map();
+            }
+        }
+        if (generateWitnesses) {
+            this.log.info(`Private kernel witness generation took ${timer.ms()}ms`);
+        }
+        let chonkProof;
+        // TODO(#7368) how do we 'bincode' encode these inputs?
+        let provingTime;
+        if (!skipProofGeneration) {
+            const provingTimer = new Timer();
+            const proofWithPublicInputs = await this.proofCreator.createChonkProof(executionSteps);
+            provingTime = provingTimer.ms();
+            this.ensurePublicInputsMatch(proofWithPublicInputs, tailOutput.publicInputs);
+            chonkProof = proofWithPublicInputs.removePublicInputs();
+        } else {
+            chonkProof = ChonkProof.random();
+        }
+        return {
+            publicInputs: tailOutput.publicInputs,
+            executionSteps,
+            chonkProof,
+            timings: provingTime ? {
+                proving: provingTime
+            } : undefined
+        };
+    }
+    /**
+   * Checks that the public inputs of the chonk proof match the public inputs of the tail circuit.
+   * This can only mismatch if there is a circuit / noir / bb bug.
+   * @param chonkProof - The chonk proof with public inputs.
+   * @param tailPublicInputs - The public inputs resulting from witness generation of the tail circuit.
+   */ ensurePublicInputsMatch(chonkProof, tailPublicInputs) {
+        const serializedChonkProofPublicInputs = chonkProof.getPublicInputs();
+        const serializedTailPublicInputs = tailPublicInputs.publicInputs().toFields();
+        if (serializedChonkProofPublicInputs.length !== serializedTailPublicInputs.length) {
+            throw new Error(`Public inputs length mismatch: ${serializedChonkProofPublicInputs.length} !== ${serializedTailPublicInputs.length}`);
+        }
+        if (!serializedChonkProofPublicInputs.every((input, index)=>input.equals(serializedTailPublicInputs[index]))) {
+            throw new Error(`Public inputs mismatch between kernel and chonk proof`);
+        }
+    }
+    async getVkData(verificationKey) {
+        const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(verificationKey.keyAsFields);
+        return new VkData(verificationKey, Number(previousVkMembershipWitness.leafIndex), previousVkMembershipWitness.siblingPath);
+    }
+    async createPrivateCallData({ publicInputs, vk: vkAsBuffer }) {
+        const { contractAddress, functionSelector } = publicInputs.callContext;
+        const vkAsFields = await vkAsFieldsMegaHonk(vkAsBuffer);
+        const vk = await VerificationKeyAsFields.fromKey(vkAsFields);
+        const { currentContractClassId, publicKeys, saltedInitializationHash } = await this.oracle.getContractAddressPreimage(contractAddress);
+        const functionLeafMembershipWitness = await this.oracle.getFunctionMembershipWitness(currentContractClassId, functionSelector);
+        const { artifactHash: contractClassArtifactHash, publicBytecodeCommitment: contractClassPublicBytecodeCommitment } = await this.oracle.getContractClassIdPreimage(currentContractClassId);
+        const updatedClassIdHints = await this.oracle.getUpdatedClassIdHints(contractAddress);
+        return PrivateCallData.from({
+            publicInputs,
+            vk,
+            verificationKeyHints: PrivateVerificationKeyHints.from({
+                publicKeys,
+                contractClassArtifactHash,
+                contractClassPublicBytecodeCommitment,
+                saltedInitializationHash,
+                functionLeafMembershipWitness,
+                updatedClassIdHints
+            })
+        });
+    }
+}

package/dest/{kernel_prover/proving_data_oracle.d.ts → private_kernel/private_kernel_oracle.d.ts}

@@ -1,6 +1,6 @@
-import type { FUNCTION_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
+import { FUNCTION_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
-import type { MembershipWitness } from '@aztec/foundation/trees';
+import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
@@ -8,10 +8,10 @@ import type { PublicKeys } from '@aztec/stdlib/keys';
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 /**
- * Provides functionality to fetch membership witnesses for verification keys,
- * contract addresses, and function selectors in their respective merkle trees.
+ * Provides functionality needed by the private kernel for interacting with our state trees.
+ * This is either PrivateKernelOracleImpl, or a mocked test implementation.
  */
-export interface ProvingDataOracle {
+export interface PrivateKernelOracle {
     /** Retrieves the preimage of a contract address from the registered contract instances db. */
     getContractAddressPreimage(address: AztecAddress): Promise<{
         saltedInitializationHash: Fr;
@@ -26,37 +26,23 @@ export interface ProvingDataOracle {
         privateFunctionsRoot: Fr;
     }>;
     /**
-     * Retrieve the function membership witness for the given contract class and function selector.
-     * The function membership witness represents a proof that the function belongs to the specified contract.
-     * Throws an error if the contract address or function selector is unknown.
-     *
-     * @param contractClassId - The id of the class.
-     * @param selector - The function selector.
-     * @returns A promise that resolves with the MembershipWitness instance for the specified contract's function.
+     * Returns a membership witness with the sibling path and leaf index in our private functions tree.
      */
     getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector): Promise<MembershipWitness<typeof FUNCTION_TREE_HEIGHT>>;
     /**
-     * Retrieve the membership witness corresponding to a verification key.
-     * This function currently returns a random membership witness of the specified height,
-     * which is a placeholder implementation until a concrete membership witness calculation
-     * is implemented.
-     *
-     * @param vk - The VerificationKey for which the membership witness is needed.
-     * @returns A Promise that resolves to the MembershipWitness instance.
+     * Returns a membership witness with the sibling path and leaf index in our protocol VK indexed merkle tree.
+     * Used to validate the previous kernel's verification key.
      */
     getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<typeof VK_TREE_HEIGHT>>;
     /**
-     * Get the note membership witness for a note in the note hash tree at the given leaf index.
-     *
-     * @param leafIndex - The leaf index of the note in the note hash tree.
-     * @returns the MembershipWitness for the note.
+     * Returns a membership witness with the sibling path and leaf index in our private function indexed merkle tree.
+     */ getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
+    /**
+     * Returns a membership witness with the sibling path and leaf index in our nullifier indexed merkle tree.
      */
-    getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
     getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
     /**
-     * Get the root of the note hash tree.
-     *
-     * @returns the root of the note hash tree.
+     * Returns the root of our note hash merkle tree.
      */
     getNoteHashTreeRoot(): Promise<Fr>;
     /**
@@ -67,7 +53,10 @@ export interface ProvingDataOracle {
      * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
      */
     getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinScalar>;
+    /** Use debug data to get the function name corresponding to a selector. */
     getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    /** Returns a membership witness and leaf index to our public data indexed merkle tree,
+     * along with an associated DelayedPublicMutable containing the class ID to update. */
     getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints>;
 }
-//# sourceMappingURL=proving_data_oracle.d.ts.map
+//# sourceMappingURL=private_kernel_oracle.d.ts.map

package/dest/private_kernel/private_kernel_oracle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_kernel_oracle.d.ts","sourceRoot":"","sources":["../../src/private_kernel/private_kernel_oracle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/F,OAAO,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,8FAA8F;IAC9F,0BAA0B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC;QACzD,wBAAwB,EAAE,EAAE,CAAC;QAC7B,UAAU,EAAE,UAAU,CAAC;QACvB,sBAAsB,EAAE,EAAE,CAAC;QAC3B,uBAAuB,EAAE,EAAE,CAAC;KAC7B,CAAC,CAAC;IAEH,kFAAkF;IAClF,0BAA0B,CACxB,eAAe,EAAE,EAAE,GAClB,OAAO,CAAC;QAAE,YAAY,EAAE,EAAE,CAAC;QAAC,wBAAwB,EAAE,EAAE,CAAC;QAAC,oBAAoB,EAAE,EAAE,CAAA;KAAE,CAAC,CAAC;IAEzF;;OAEG;IACH,4BAA4B,CAC1B,eAAe,EAAE,EAAE,EACnB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,iBAAiB,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;IAE3D;;;OAGG;IACH,sBAAsB,CAAC,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC;IAEvG;;OAEG,CAAC,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC;IAE9G;;OAEG;IACH,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAAC;IAC9F;;OAEG;IACH,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC,CAAC;IAEnC;;;;;;OAMG;IACH,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEpE,2EAA2E;IAC3E,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAE7G;0FACsF;IACtF,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrF"}

package/dest/private_kernel/private_kernel_oracle.js

@@ -0,0 +1,4 @@
+/**
+ * Provides functionality needed by the private kernel for interacting with our state trees.
+ * This is either PrivateKernelOracleImpl, or a mocked test implementation.
+ */ export { };

package/dest/{kernel_oracle/index.d.ts → private_kernel/private_kernel_oracle_impl.d.ts}

@@ -1,4 +1,4 @@
-import { type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
+import { NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { KeyStore } from '@aztec/key-store';
@@ -9,12 +9,12 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
 import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
 import type { VerificationKeyAsFields } from '@aztec/stdlib/vks';
-import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
-import type { ProvingDataOracle } from './../kernel_prover/proving_data_oracle.js';
+import type { ContractDataProvider } from '../storage/index.js';
+import type { PrivateKernelOracle } from './private_kernel_oracle.js';
 /**
  * A data oracle that provides information needed for simulating a transaction.
  */
-export declare class KernelOracle implements ProvingDataOracle {
+export declare class PrivateKernelOracleImpl implements PrivateKernelOracle {
     private contractDataProvider;
     private keyStore;
     private node;
@@ -28,13 +28,13 @@ export declare class KernelOracle implements ProvingDataOracle {
         currentContractClassId: Fr;
         originalContractClassId: Fr;
         initializationHash: Fr;
-        publicKeys: import("@aztec/aztec.js").PublicKeys;
+        publicKeys: import("@aztec/stdlib/keys").PublicKeys;
         address: AztecAddress;
         saltedInitializationHash: Fr;
     }>;
     getContractClassIdPreimage(contractClassId: Fr): Promise<import("@aztec/stdlib/contract").ContractClassIdPreimage>;
-    getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector): Promise<MembershipWitness<5>>;
-    getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<6>>;
+    getFunctionMembershipWitness(contractClassId: Fr, selector: FunctionSelector): Promise<MembershipWitness<7>>;
+    getVkMembershipWitness(vk: VerificationKeyAsFields): Promise<MembershipWitness<7>>;
     getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
     getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
     getNoteHashTreeRoot(): Promise<Fr>;
@@ -42,4 +42,4 @@ export declare class KernelOracle implements ProvingDataOracle {
     getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
     getUpdatedClassIdHints(contractAddress: AztecAddress): Promise<UpdatedClassIdHints>;
 }
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=private_kernel_oracle_impl.d.ts.map

package/dest/private_kernel/private_kernel_oracle_impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_kernel_oracle_impl.d.ts","sourceRoot":"","sources":["../../src/private_kernel/private_kernel_oracle_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAA2C,MAAM,kBAAkB,CAAC;AAClG,OAAO,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAKtE;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAE/D,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,GAAG;gBAJH,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,SAAS,EACf,WAAW,GAAE,aAAwB,EACrC,GAAG,yCAAoC;IAGpC,0BAA0B,CAAC,OAAO,EAAE,YAAY;;;;;;;;;;;IAWhD,0BAA0B,CAAC,eAAe,EAAE,EAAE;IAQ9C,4BAA4B,CAAC,eAAe,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB;IAUlF,sBAAsB,CAAC,EAAE,EAAE,uBAAuB;IAKnD,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAS/G,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC;IAIvF,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC;IAQjC,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC;IAInE,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1F,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA+BjG"}

package/dest/{kernel_oracle/index.js → private_kernel/private_kernel_oracle_impl.js}

@@ -4,14 +4,14 @@ import { MembershipWitness } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { computeContractClassIdPreimage, computeSaltedInitializationHash } from '@aztec/stdlib/contract';
+import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import { UpdatedClassIdHints } from '@aztec/stdlib/kernel';
-import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
 // TODO: Block number should not be "latest".
 // It should be fixed at the time the proof is being simulated. I.e., it should be the same as the value defined in the constant data.
 /**
  * A data oracle that provides information needed for simulating a transaction.
- */ export class KernelOracle {
+ */ export class PrivateKernelOracleImpl {
     contractDataProvider;
     keyStore;
     node;
@@ -26,6 +26,9 @@ import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/
     }
     async getContractAddressPreimage(address) {
         const instance = await this.contractDataProvider.getContractInstance(address);
+        if (!instance) {
+            throw new Error(`Contract instance not found when getting address preimage. Contract address: ${address}.`);
+        }
         return {
             saltedInitializationHash: await computeSaltedInitializationHash(instance),
             ...instance
@@ -33,10 +36,17 @@ import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/
     }
     async getContractClassIdPreimage(contractClassId) {
         const contractClass = await this.contractDataProvider.getContractClass(contractClassId);
+        if (!contractClass) {
+            throw new Error(`Contract class not found when getting class id preimage. Class id: ${contractClassId}.`);
+        }
         return computeContractClassIdPreimage(contractClass);
     }
     async getFunctionMembershipWitness(contractClassId, selector) {
-        return await this.contractDataProvider.getFunctionMembershipWitness(contractClassId, selector);
+        const membershipWitness = await this.contractDataProvider.getFunctionMembershipWitness(contractClassId, selector);
+        if (!membershipWitness) {
+            throw new Error(`Membership witness not found for contract class id ${contractClassId} and selector ${selector}.`);
+        }
+        return membershipWitness;
     }
     getVkMembershipWitness(vk) {
         const leafIndex = getVKIndex(vk);
@@ -63,14 +73,14 @@ import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/
         return this.contractDataProvider.getDebugFunctionName(contractAddress, selector);
     }
     async getUpdatedClassIdHints(contractAddress) {
-        const { sharedMutableSlot, sharedMutableHashSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-        const hashLeafSlot = await computePublicDataTreeLeafSlot(ProtocolContractAddress.ContractInstanceDeployer, sharedMutableHashSlot);
-        const updatedClassIdWitness = await this.node.getPublicDataTreeWitness(this.blockNumber, hashLeafSlot);
+        const { delayedPublicMutableSlot, delayedPublicMutableHashSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
+        const hashLeafSlot = await computePublicDataTreeLeafSlot(ProtocolContractAddress.ContractInstanceRegistry, delayedPublicMutableHashSlot);
+        const updatedClassIdWitness = await this.node.getPublicDataWitness(this.blockNumber, hashLeafSlot);
         if (!updatedClassIdWitness) {
             throw new Error(`No public data tree witness found for ${hashLeafSlot}`);
         }
-        const readStorage = (storageSlot)=>this.node.getPublicStorageAt(this.blockNumber, ProtocolContractAddress.ContractInstanceDeployer, storageSlot);
-        const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, readStorage);
-        return new UpdatedClassIdHints(new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, updatedClassIdWitness.index, updatedClassIdWitness.siblingPath.toTuple()), updatedClassIdWitness.leafPreimage, sharedMutableValues);
+        const readStorage = (storageSlot)=>this.node.getPublicStorageAt(this.blockNumber, ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
+        const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, readStorage);
+        return new UpdatedClassIdHints(new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, updatedClassIdWitness.index, updatedClassIdWitness.siblingPath.toTuple()), updatedClassIdWitness.leafPreimage, delayedPublicMutableValues);
     }
 }