@aztec/pxe 0.0.0-test.0 → 0.0.1-commit.001888fc

package/dest/private_kernel/hints/test_utils.js

@@ -0,0 +1,203 @@
+import { MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_KEY_VALIDATION_REQUESTS_PER_TX, MAX_NOTE_HASHES_PER_CALL, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NULLIFIERS_PER_CALL, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_TX, MAX_PRIVATE_LOGS_PER_CALL, MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ClaimedLengthArray, KeyValidationRequest, KeyValidationRequestAndSeparator, NoteHash, Nullifier, PrivateCircuitPublicInputs, PrivateKernelCircuitPublicInputs, ReadRequest, ScopedKeyValidationRequestAndSeparator, ScopedNoteHash, ScopedNullifier, ScopedReadRequest } from '@aztec/stdlib/kernel';
+import { PrivateLogData, ScopedPrivateLogData } from '@aztec/stdlib/kernel';
+import { PrivateLog } from '@aztec/stdlib/logs';
+import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+const DEFAULT_CONTRACT_ADDRESS = AztecAddress.fromBigInt(987654n);
+/**
+ * Builds a ClaimedLengthArray from a list of items, padding to the required size.
+ */ function makeClaimed(items, emptyFactory, maxSize) {
+    const padded = makeTuple(maxSize, (i)=>items[i] ?? emptyFactory.empty());
+    return new ClaimedLengthArray(padded, items.length);
+}
+/** Builder for PrivateKernelCircuitPublicInputs with fluent API for adding side effects. */ export class PrivateKernelCircuitPublicInputsBuilder {
+    contractAddress;
+    noteHashes;
+    nullifiers;
+    noteHashReadRequests;
+    nullifierReadRequests;
+    keyValidationRequests;
+    privateLogs;
+    nextCounter;
+    constructor(contractAddress = DEFAULT_CONTRACT_ADDRESS, startCounter = 1){
+        this.contractAddress = contractAddress;
+        this.noteHashes = [];
+        this.nullifiers = [];
+        this.noteHashReadRequests = [];
+        this.nullifierReadRequests = [];
+        this.keyValidationRequests = [];
+        this.privateLogs = [];
+        this.nextCounter = startCounter;
+    }
+    getCounter(sideEffectCounter) {
+        if (sideEffectCounter !== undefined) {
+            this.nextCounter = sideEffectCounter + 1;
+            return sideEffectCounter;
+        }
+        return this.nextCounter++;
+    }
+    /** Adds a note hash to the accumulated data. Defaults are generated randomly. */ addNoteHash(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        const addr = opts?.contractAddress ?? this.contractAddress;
+        this.noteHashes.push(new NoteHash(value, counter).scope(addr));
+        return this;
+    }
+    /** Adds a nullifier to the accumulated data. Defaults are generated randomly. */ addNullifier(opts) {
+        const value = opts?.value ?? Fr.random();
+        const noteHash = opts?.noteHash ?? Fr.ZERO;
+        const counter = this.getCounter(opts?.counter);
+        const addr = opts?.contractAddress ?? this.contractAddress;
+        this.nullifiers.push(new Nullifier(value, noteHash, counter).scope(addr));
+        return this;
+    }
+    /** Adds a pending note hash read request (non-empty contract address, can match a pending note hash). */ addPendingNoteHashReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        const addr = opts?.contractAddress ?? this.contractAddress;
+        this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), addr));
+        return this;
+    }
+    /** Adds a settled note hash read request (empty contract address, resolved against the note hash tree). */ addSettledNoteHashReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+        return this;
+    }
+    /** Adds a pending nullifier read request (non-empty contract address, can match a pending nullifier). */ addPendingNullifierReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        const addr = opts?.contractAddress ?? this.contractAddress;
+        this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), addr));
+        return this;
+    }
+    /** Adds a settled nullifier read request (empty contract address, resolved against the nullifier tree). */ addSettledNullifierReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+        return this;
+    }
+    /** Adds a key validation request to validation requests. */ addKeyValidationRequest(opts) {
+        const addr = opts?.contractAddress ?? this.contractAddress;
+        this.keyValidationRequests.push(new ScopedKeyValidationRequestAndSeparator(new KeyValidationRequestAndSeparator(new KeyValidationRequest(new Point(Fr.random(), Fr.random(), false), Fr.random()), Fr.random()), addr));
+        return this;
+    }
+    /** Adds a private log to the accumulated data. Defaults are generated randomly. */ addPrivateLog(opts) {
+        const noteHashCounter = opts?.noteHashCounter ?? 0;
+        const counter = this.getCounter(opts?.counter);
+        const addr = opts?.contractAddress ?? this.contractAddress;
+        this.privateLogs.push(new ScopedPrivateLogData(new PrivateLogData(PrivateLog.empty(), noteHashCounter, counter), addr));
+        return this;
+    }
+    /** Builds the PrivateKernelCircuitPublicInputs with all added side effects. */ build() {
+        const publicInputs = PrivateKernelCircuitPublicInputs.empty();
+        publicInputs.end.noteHashes = makeClaimed(this.noteHashes, ScopedNoteHash, MAX_NOTE_HASHES_PER_TX);
+        publicInputs.end.nullifiers = makeClaimed(this.nullifiers, ScopedNullifier, MAX_NULLIFIERS_PER_TX);
+        publicInputs.end.privateLogs = makeClaimed(this.privateLogs, ScopedPrivateLogData, MAX_PRIVATE_LOGS_PER_TX);
+        publicInputs.validationRequests.noteHashReadRequests = makeClaimed(this.noteHashReadRequests, ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+        publicInputs.validationRequests.nullifierReadRequests = makeClaimed(this.nullifierReadRequests, ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+        publicInputs.validationRequests.scopedKeyValidationRequestsAndSeparators = makeClaimed(this.keyValidationRequests, ScopedKeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_TX);
+        return publicInputs;
+    }
+}
+/** Builder for PrivateCircuitPublicInputs (call-level) with fluent API for adding side effects. */ export class PrivateCircuitPublicInputsBuilder {
+    contractAddress;
+    noteHashes;
+    nullifiers;
+    noteHashReadRequests;
+    nullifierReadRequests;
+    keyValidationRequests;
+    privateLogs;
+    nextCounter;
+    constructor(contractAddress = DEFAULT_CONTRACT_ADDRESS, startCounter = 1){
+        this.contractAddress = contractAddress;
+        this.noteHashes = [];
+        this.nullifiers = [];
+        this.noteHashReadRequests = [];
+        this.nullifierReadRequests = [];
+        this.keyValidationRequests = [];
+        this.privateLogs = [];
+        this.nextCounter = startCounter;
+    }
+    getCounter(sideEffectCounter) {
+        if (sideEffectCounter !== undefined) {
+            this.nextCounter = sideEffectCounter + 1;
+            return sideEffectCounter;
+        }
+        return this.nextCounter++;
+    }
+    /** Adds a note hash. Defaults are generated randomly. */ addNoteHash(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.noteHashes.push(new NoteHash(value, counter));
+        return this;
+    }
+    /** Adds a nullifier. Defaults are generated randomly. */ addNullifier(opts) {
+        const value = opts?.value ?? Fr.random();
+        const noteHash = opts?.noteHash ?? Fr.ZERO;
+        const counter = this.getCounter(opts?.counter);
+        this.nullifiers.push(new Nullifier(value, noteHash, counter));
+        return this;
+    }
+    /** Adds a pending note hash read request (non-empty contract address, can match a pending note hash). */ addPendingNoteHashReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), this.contractAddress));
+        return this;
+    }
+    /** Adds a settled note hash read request (empty contract address, resolved against the note hash tree). */ addSettledNoteHashReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.noteHashReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+        return this;
+    }
+    /** Adds a pending nullifier read request (non-empty contract address, can match a pending nullifier). */ addPendingNullifierReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), this.contractAddress));
+        return this;
+    }
+    /** Adds a settled nullifier read request (empty contract address, resolved against the nullifier tree). */ addSettledNullifierReadRequest(opts) {
+        const value = opts?.value ?? Fr.random();
+        const counter = this.getCounter(opts?.counter);
+        this.nullifierReadRequests.push(new ScopedReadRequest(new ReadRequest(value, counter), AztecAddress.ZERO));
+        return this;
+    }
+    /** Adds a key validation request. */ addKeyValidationRequest() {
+        this.keyValidationRequests.push(new KeyValidationRequestAndSeparator(new KeyValidationRequest(new Point(Fr.random(), Fr.random(), false), Fr.random()), Fr.random()));
+        return this;
+    }
+    /** Adds a private log. Defaults are generated randomly. */ addPrivateLog(opts) {
+        const noteHashCounter = opts?.noteHashCounter ?? 0;
+        const counter = this.getCounter(opts?.counter);
+        this.privateLogs.push(new PrivateLogData(PrivateLog.empty(), noteHashCounter, counter));
+        return this;
+    }
+    /** Builds the PrivateCircuitPublicInputs with all added side effects. */ build() {
+        const publicInputs = PrivateCircuitPublicInputs.empty();
+        publicInputs.callContext.contractAddress = this.contractAddress;
+        publicInputs.noteHashes = makeClaimed(this.noteHashes, NoteHash, MAX_NOTE_HASHES_PER_CALL);
+        publicInputs.nullifiers = makeClaimed(this.nullifiers, Nullifier, MAX_NULLIFIERS_PER_CALL);
+        publicInputs.privateLogs = makeClaimed(this.privateLogs, PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL);
+        publicInputs.noteHashReadRequests = makeClaimed(this.noteHashReadRequests, ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL);
+        publicInputs.nullifierReadRequests = makeClaimed(this.nullifierReadRequests, ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL);
+        publicInputs.keyValidationRequestsAndSeparators = makeClaimed(this.keyValidationRequests, KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL);
+        return publicInputs;
+    }
+}
+/** Wraps a PrivateKernelCircuitPublicInputs in a PrivateKernelSimulateOutput. */ export function makeKernelOutput(publicInputs) {
+    return {
+        publicInputs: publicInputs ?? PrivateKernelCircuitPublicInputs.empty(),
+        verificationKey: VerificationKeyData.empty(),
+        outputWitness: new Map(),
+        bytecode: Buffer.from([])
+    };
+}
+/** Wraps a PrivateCircuitPublicInputs in a PrivateCallExecutionResult. */ export function makeExecutionResult(publicInputs) {
+    return new PrivateCallExecutionResult(Buffer.alloc(0), Buffer.alloc(0), new Map(), publicInputs ?? PrivateCircuitPublicInputs.empty(), [], new Map(), [], [], [], [], []);
+}

package/dest/private_kernel/index.d.ts

@@ -0,0 +1,3 @@
+export * from './private_kernel_execution_prover.js';
+export * from './private_kernel_oracle.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlX2tlcm5lbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsNEJBQTRCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/private_kernel/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC"}

package/dest/private_kernel/index.js

@@ -0,0 +1,2 @@
+export * from './private_kernel_execution_prover.js';
+export * from './private_kernel_oracle.js';

package/dest/private_kernel/private_kernel_execution_prover.d.ts

@@ -0,0 +1,45 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
+import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+import { type PrivateKernelExecutionProofOutput, type PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { type PrivateExecutionResult, TxRequest } from '@aztec/stdlib/tx';
+import type { PrivateKernelOracle } from './private_kernel_oracle.js';
+export interface PrivateKernelExecutionProverConfig {
+    simulate: boolean;
+    skipFeeEnforcement: boolean;
+    profileMode: 'gates' | 'execution-steps' | 'full' | 'none';
+}
+/**
+ * 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 declare class PrivateKernelExecutionProver {
+    private oracle;
+    private proofCreator;
+    private fakeProofs;
+    private log;
+    constructor(oracle: PrivateKernelOracle, proofCreator: PrivateKernelProver, fakeProofs?: boolean, bindings?: LoggerBindings);
+    /**
+     * 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.
+     */
+    proveWithKernels(txRequest: TxRequest, executionResult: PrivateExecutionResult, { simulate, skipFeeEnforcement, profileMode }?: PrivateKernelExecutionProverConfig): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>>;
+    /**
+     * 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.
+     */
+    private ensurePublicInputsMatch;
+    private getVkData;
+    private createPrivateCallData;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9rZXJuZWxfZXhlY3V0aW9uX3Byb3Zlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL3ByaXZhdGVfa2VybmVsX2V4ZWN1dGlvbl9wcm92ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBTXZGLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDM0UsT0FBTyxFQVFMLEtBQUssaUNBQWlDLEVBS3RDLEtBQUssb0NBQW9DLEVBRTFDLE1BQU0sc0JBQXNCLENBQUM7QUFFOUIsT0FBTyxFQUVMLEtBQUssc0JBQXNCLEVBQzNCLFNBQVMsRUFHVixNQUFNLGtCQUFrQixDQUFDO0FBSTFCLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFTdEUsTUFBTSxXQUFXLGtDQUFrQztJQUNqRCxRQUFRLEVBQUUsT0FBTyxDQUFDO0lBQ2xCLGtCQUFrQixFQUFFLE9BQU8sQ0FBQztJQUM1QixXQUFXLEVBQUUsT0FBTyxHQUFHLGlCQUFpQixHQUFHLE1BQU0sR0FBRyxNQUFNLENBQUM7Q0FDNUQ7QUFFRDs7Ozs7R0FLRztBQUNILHFCQUFhLDRCQUE0QjtJQUlyQyxPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxZQUFZO0lBQ3BCLE9BQU8sQ0FBQyxVQUFVO0lBTHBCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFFcEIsWUFDVSxNQUFNLEVBQUUsbUJBQW1CLEVBQzNCLFlBQVksRUFBRSxtQkFBbUIsRUFDakMsVUFBVSxVQUFRLEVBQzFCLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0csZ0JBQWdCLENBQ3BCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGVBQWUsRUFBRSxzQkFBc0IsRUFDdkMsRUFBRSxRQUFRLEVBQUUsa0JBQWtCLEVBQUUsV0FBVyxFQUFFLEdBQUUsa0NBSTlDLEdBQ0EsT0FBTyxDQUFDLGlDQUFpQyxDQUFDLG9DQUFvQyxDQUFDLENBQUMsQ0EyUmxGO0lBRUQ7Ozs7O09BS0c7SUFDSCxPQUFPLENBQUMsdUJBQXVCO1lBb0JqQixTQUFTO1lBU1QscUJBQXFCO0NBK0JwQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"private_kernel_execution_prover.d.ts","sourceRoot":"","sources":["../../src/private_kernel/private_kernel_execution_prover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAMvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAQL,KAAK,iCAAiC,EAKtC,KAAK,oCAAoC,EAE1C,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAEL,KAAK,sBAAsB,EAC3B,SAAS,EAGV,MAAM,kBAAkB,CAAC;AAI1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAStE,MAAM,WAAW,kCAAkC;IACjD,QAAQ,EAAE,OAAO,CAAC;IAClB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,OAAO,GAAG,iBAAiB,GAAG,MAAM,GAAG,MAAM,CAAC;CAC5D;AAED;;;;;GAKG;AACH,qBAAa,4BAA4B;IAIrC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,UAAU;IALpB,OAAO,CAAC,GAAG,CAAS;IAEpB,YACU,MAAM,EAAE,mBAAmB,EAC3B,YAAY,EAAE,mBAAmB,EACjC,UAAU,UAAQ,EAC1B,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED;;;;;;;;;;OAUG;IACG,gBAAgB,CACpB,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,sBAAsB,EACvC,EAAE,QAAQ,EAAE,kBAAkB,EAAE,WAAW,EAAE,GAAE,kCAI9C,GACA,OAAO,CAAC,iCAAiC,CAAC,oCAAoC,CAAC,CAAC,CA2RlF;IAED;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;YAoBjB,SAAS;YAST,qBAAqB;CA+BpC"}

package/dest/private_kernel/private_kernel_execution_prover.js

@@ -0,0 +1,293 @@
+import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto/keys';
+import { Fr } from '@aztec/foundation/curves/bn254';
+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 { collectNoteHashNullifierCounterMap, getFinalMinRevertibleSideEffectCounter } from '@aztec/stdlib/tx';
+import { VerificationKeyAsFields, VerificationKeyData, VkData } from '@aztec/stdlib/vks';
+import { PrivateKernelResetPrivateInputsBuilder } from './hints/private_kernel_reset_private_inputs_builder.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, bindings){
+        this.oracle = oracle;
+        this.proofCreator = proofCreator;
+        this.fakeProofs = fakeProofs;
+        this.log = createLogger('pxe:private-kernel-execution-prover', bindings);
+    }
+    /**
+   * 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 noteHashNullifierCounterMap = collectNoteHashNullifierCounterMap(executionResult);
+        const minRevertibleSideEffectCounter = getFinalMinRevertibleSideEffectCounter(executionResult);
+        const splitCounter = isPrivateOnlyTx ? 0 : minRevertibleSideEffectCounter;
+        while(executionStack.length){
+            if (!firstIteration) {
+                let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, executionStack, noteHashNullifierCounterMap, splitCounter);
+                while(resetBuilder.needsReset()){
+                    // Inner reset: without siloing.
+                    const witgenTimer = new Timer();
+                    const privateInputs = await resetBuilder.build(this.oracle);
+                    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, splitCounter);
+                }
+            }
+            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, minRevertibleSideEffectCounter);
+                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;
+        }
+        // Final reset: include siloing of note hashes, nullifiers and private logs.
+        const finalResetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, [], noteHashNullifierCounterMap, splitCounter);
+        if (!finalResetBuilder.needsReset()) {
+            // The final reset must be performed exactly once, because each tx has at least one nullifier that requires
+            // siloing, and siloing cannot be done multiple times.
+            // While, in theory, it might be possible to silo note hashes first and then run another reset to silo nullifiers
+            // and/or private logs, we currently don't have standalone dimensions for the arrays that require siloing. As a
+            // result, all necessary siloing must be done together in a single reset.
+            // Refer to the possible combinations of dimensions in private_kernel_reset_config.json.
+            throw new Error('Nothing to reset for the final reset.');
+        } else {
+            const witgenTimer = new Timer();
+            const privateInputs = await finalResetBuilder.build(this.oracle);
+            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()
+                }
+            });
+        }
+        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 expirationTimestamp set throughout the tx execution.
+        // TODO: Call `computeTxExpirationTimestamp` to round the value down and reduce precision, improving privacy.
+        const expirationTimestampUpperBound = previousKernelData.publicInputs.expirationTimestamp;
+        const anchorBlockTimestamp = previousKernelData.publicInputs.constants.anchorBlockHeader.globalVariables.timestamp;
+        if (expirationTimestampUpperBound <= anchorBlockTimestamp) {
+            throw new Error(`Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${expirationTimestampUpperBound}.`);
+        }
+        const privateInputs = new PrivateKernelTailCircuitPrivateInputs(previousKernelData, paddedSideEffectAmounts, expirationTimestampUpperBound);
+        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 kernel is only executed if we are generating witnesses.
+        // For simulation, we can end with the tail, since the Hiding kernel 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/private_kernel/private_kernel_oracle.d.ts

@@ -0,0 +1,63 @@
+import { FUNCTION_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT, VK_TREE_HEIGHT } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import type { KeyStore } from '@aztec/key-store';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+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 { ContractStore } from '../storage/contract_store/contract_store.js';
+/**
+ * Provides functionality needed by the private kernel for interacting with our state trees.
+ */
+export declare class PrivateKernelOracle {
+    private contractStore;
+    private keyStore;
+    private node;
+    private blockHash;
+    constructor(contractStore: ContractStore, keyStore: KeyStore, node: AztecNode, blockHash: BlockHash);
+    /** Retrieves the preimage of a contract address from the registered contract instances db. */
+    getContractAddressPreimage(address: AztecAddress): Promise<ContractInstanceWithAddress & {
+        saltedInitializationHash: Fr;
+    }>;
+    /** Retrieves the preimage of a contract class id from the contract classes db. */
+    getContractClassIdPreimage(contractClassId: Fr): Promise<{
+        artifactHash: Fr;
+        privateFunctionsRoot: Fr;
+        publicBytecodeCommitment: Fr;
+    }>;
+    /** 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>>;
+    /**
+     * 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>>;
+    /** Returns a membership witness with the sibling path and leaf index in our note hash tree. */
+    getNoteHashMembershipWitness(noteHash: Fr): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined>;
+    /** Returns a membership witness with the sibling path and leaf index in our nullifier indexed merkle tree. */
+    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+    /** Returns the root of our note hash merkle tree. */
+    getNoteHashTreeRoot(): Promise<Fr>;
+    /**
+     * Retrieves the sk_m corresponding to the pk_m.
+     * @throws If the provided public key is not associated with any of the registered accounts.
+     * @param masterPublicKey - The master public key to get secret key for.
+     * @returns A Promise that resolves to sk_m.
+     * @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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9rZXJuZWxfb3JhY2xlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZV9rZXJuZWwvcHJpdmF0ZV9rZXJuZWxfb3JhY2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxxQkFBcUIsRUFBMkIsY0FBYyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDeEgsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDekQsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLEtBQUssRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQy9FLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBR2pELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxLQUFLLDJCQUEyQixFQUFtQyxNQUFNLHdCQUF3QixDQUFDO0FBRzNHLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLDBCQUEwQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDdEUsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUVqRSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUVqRjs7R0FFRztBQUNILHFCQUFhLG1CQUFtQjtJQUU1QixPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsUUFBUTtJQUNoQixPQUFPLENBQUMsSUFBSTtJQUNaLE9BQU8sQ0FBQyxTQUFTO0lBSm5CLFlBQ1UsYUFBYSxFQUFFLGFBQWEsRUFDNUIsUUFBUSxFQUFFLFFBQVEsRUFDbEIsSUFBSSxFQUFFLFNBQVMsRUFDZixTQUFTLEVBQUUsU0FBUyxFQUMxQjtJQUVKLDhGQUE4RjtJQUNqRiwwQkFBMEIsQ0FDckMsT0FBTyxFQUFFLFlBQVksR0FDcEIsT0FBTyxDQUFDLDJCQUEyQixHQUFHO1FBQUUsd0JBQXdCLEVBQUUsRUFBRSxDQUFBO0tBQUUsQ0FBQyxDQVN6RTtJQUVELGtGQUFrRjtJQUNyRSwwQkFBMEIsQ0FBQyxlQUFlLEVBQUUsRUFBRTs7OztPQVUxRDtJQUVELHVHQUF1RztJQUMxRiw0QkFBNEIsQ0FDdkMsZUFBZSxFQUFFLEVBQUUsRUFDbkIsUUFBUSxFQUFFLGdCQUFnQixHQUN6QixPQUFPLENBQUMsaUJBQWlCLENBQUMsT0FBTyxvQkFBb0IsQ0FBQyxDQUFDLENBUXpEO0lBRUQ7OztPQUdHO0lBQ0ksc0JBQXNCLENBQUMsRUFBRSxFQUFFLHVCQUF1QixHQUFHLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLGNBQWMsQ0FBQyxDQUFDLENBRzVHO0lBRUQsK0ZBQStGO0lBQy9GLDRCQUE0QixDQUFDLFFBQVEsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixDQUFDLE9BQU8scUJBQXFCLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FFL0c7SUFFRCw4R0FBOEc7SUFDOUcsNkJBQTZCLENBQUMsU0FBUyxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsMEJBQTBCLEdBQUcsU0FBUyxDQUFDLENBRTVGO0lBRUQscURBQXFEO0lBQy9DLG1CQUFtQixJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FNdkM7SUFFRDs7Ozs7O09BTUc7SUFDSSxrQkFBa0IsQ0FBQyxlQUFlLEVBQUUsS0FBSyxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FFekU7SUFFRCwyRUFBMkU7SUFDcEUsb0JBQW9CLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFbEg7SUFFRDs7O09BR0c7SUFDVSxzQkFBc0IsQ0FBQyxlQUFlLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQThCL0Y7Q0FDRiJ9

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,EAA2B,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACxH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAC/E,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,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,KAAK,2BAA2B,EAAmC,MAAM,wBAAwB,CAAC;AAG3G,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,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF;;GAEG;AACH,qBAAa,mBAAmB;IAE5B,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,SAAS;IAJnB,YACU,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,SAAS,EAC1B;IAEJ,8FAA8F;IACjF,0BAA0B,CACrC,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,2BAA2B,GAAG;QAAE,wBAAwB,EAAE,EAAE,CAAA;KAAE,CAAC,CASzE;IAED,kFAAkF;IACrE,0BAA0B,CAAC,eAAe,EAAE,EAAE;;;;OAU1D;IAED,uGAAuG;IAC1F,4BAA4B,CACvC,eAAe,EAAE,EAAE,EACnB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,iBAAiB,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAQzD;IAED;;;OAGG;IACI,sBAAsB,CAAC,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,cAAc,CAAC,CAAC,CAG5G;IAED,+FAA+F;IAC/F,4BAA4B,CAAC,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,GAAG,SAAS,CAAC,CAE/G;IAED,8GAA8G;IAC9G,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAE5F;IAED,qDAAqD;IAC/C,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC,CAMvC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,CAEzE;IAED,2EAA2E;IACpE,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAElH;IAED;;;OAGG;IACU,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8B/F;CACF"}