@aztec/pxe 0.87.4 → 0.87.6

package/dest/contract_function_simulator/oracle/private_execution_oracle.js

@@ -0,0 +1,325 @@
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { toACVMWitness } from '@aztec/simulator/client';
+import { FunctionSelector, countArgumentsSize } from '@aztec/stdlib/abi';
+import { computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
+import { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import { Note } from '@aztec/stdlib/note';
+import { CallContext, CountedContractClassLog, NoteAndSlot } from '@aztec/stdlib/tx';
+import { pickNotes } from '../pick_notes.js';
+import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
+import { UtilityExecutionOracle } from './utility_execution_oracle.js';
+/**
+ * The execution oracle for the private part of a transaction.
+ */ export class PrivateExecutionOracle extends UtilityExecutionOracle {
+    argsHash;
+    txContext;
+    callContext;
+    historicalHeader;
+    executionCache;
+    noteCache;
+    simulator;
+    totalPublicCalldataCount;
+    sideEffectCounter;
+    /**
+   * New notes created during this execution.
+   * It's possible that a note in this list has been nullified (in the same or other executions) and doesn't exist in the ExecutionNoteCache and the final proof data.
+   * But we still include those notes in the execution result because their commitments are still in the public inputs of this execution.
+   * This information is only for references (currently used for tests), and is not used for any sort of constrains.
+   * Users can also use this to get a clearer idea of what's happened during a simulation.
+   */ newNotes;
+    /**
+   * Notes from previous transactions that are returned to the oracle call `getNotes` during this execution.
+   * The mapping maps from the unique siloed note hash to the index for notes created in private executions.
+   * It maps from siloed note hash to the index for notes created by public functions.
+   *
+   * They are not part of the ExecutionNoteCache and being forwarded to nested contexts via `extend()`
+   * because these notes are meant to be maintained on a per-call basis
+   * They should act as references for the read requests output by an app circuit via public inputs.
+   */ noteHashLeafIndexMap;
+    noteHashNullifierCounterMap;
+    contractClassLogs;
+    nestedExecutions;
+    constructor(argsHash, txContext, callContext, /** Header of a block whose state is used during private execution (not the block the transaction is included in). */ historicalHeader, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, executionCache, noteCache, executionDataProvider, simulator, totalPublicCalldataCount, sideEffectCounter = 0, log = createLogger('simulator:client_execution_context'), scopes){
+        super(callContext.contractAddress, authWitnesses, capsules, executionDataProvider, log, scopes), this.argsHash = argsHash, this.txContext = txContext, this.callContext = callContext, this.historicalHeader = historicalHeader, this.executionCache = executionCache, this.noteCache = noteCache, this.simulator = simulator, this.totalPublicCalldataCount = totalPublicCalldataCount, this.sideEffectCounter = sideEffectCounter, this.newNotes = [], this.noteHashLeafIndexMap = new Map(), this.noteHashNullifierCounterMap = new Map(), this.contractClassLogs = [], this.nestedExecutions = [];
+    }
+    // We still need this function until we can get user-defined ordering of structs for fn arguments
+    // TODO When that is sorted out on noir side, we can use instead the utilities in serialize.ts
+    /**
+   * Writes the function inputs to the initial witness.
+   * @param abi - The function ABI.
+   * @returns The initial witness.
+   */ getInitialWitness(abi) {
+        const argumentsSize = countArgumentsSize(abi);
+        const args = this.executionCache.getPreimage(this.argsHash);
+        if (args?.length !== argumentsSize) {
+            throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args?.length}`);
+        }
+        const privateContextInputs = new PrivateContextInputs(this.callContext, this.historicalHeader, this.txContext, this.sideEffectCounter);
+        const privateContextInputsAsFields = privateContextInputs.toFields();
+        if (privateContextInputsAsFields.length !== PRIVATE_CONTEXT_INPUTS_LENGTH) {
+            throw new Error('Invalid private context inputs size');
+        }
+        const fields = [
+            ...privateContextInputsAsFields,
+            ...args
+        ];
+        return toACVMWitness(0, fields);
+    }
+    /**
+   * The KernelProver will use this to fully populate witnesses and provide hints to the kernel circuit
+   * regarding which note hash each settled read request corresponds to.
+   */ getNoteHashLeafIndexMap() {
+        return this.noteHashLeafIndexMap;
+    }
+    /**
+   * Get the data for the newly created notes.
+   */ getNewNotes() {
+        return this.newNotes;
+    }
+    getNoteHashNullifierCounterMap() {
+        return this.noteHashNullifierCounterMap;
+    }
+    /**
+   * Return the contract class logs emitted during this execution.
+   */ getContractClassLogs() {
+        return this.contractClassLogs;
+    }
+    /**
+   * Return the nested execution results during this execution.
+   */ getNestedExecutions() {
+        return this.nestedExecutions;
+    }
+    /**
+   * Store values in the execution cache.
+   * @param values - Values to store.
+   * @returns The hash of the values.
+   */ storeInExecutionCache(values, hash) {
+        return this.executionCache.store(values, hash);
+    }
+    /**
+   * Gets values from the execution cache.
+   * @param hash - Hash of the values.
+   * @returns The values.
+   */ loadFromExecutionCache(hash) {
+        const preimage = this.executionCache.getPreimage(hash);
+        if (!preimage) {
+            throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
+        }
+        return Promise.resolve(preimage);
+    }
+    /**
+   * Gets some notes for a storage slot.
+   *
+   * @remarks
+   * Check for pending notes with matching slot.
+   * Real notes coming from DB will have a leafIndex which
+   * represents their index in the note hash tree.
+   *
+   * @param storageSlot - The storage slot.
+   * @param numSelects - The number of valid selects in selectBy and selectValues.
+   * @param selectBy - An array of indices of the fields to selects.
+   * @param selectValues - The values to match.
+   * @param selectComparators - The comparators to match by.
+   * @param sortBy - An array of indices of the fields to sort.
+   * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+   * @param limit - The number of notes to retrieve per query.
+   * @param offset - The starting index for pagination.
+   * @param status - The status of notes to fetch.
+   * @returns Array of note data.
+   */ async getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
+        // Nullified pending notes are already removed from the list.
+        const pendingNotes = this.noteCache.getNotes(this.callContext.contractAddress, storageSlot);
+        const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.contractAddress);
+        const dbNotes = await this.executionDataProvider.getNotes(this.callContext.contractAddress, storageSlot, status, this.scopes);
+        const dbNotesFiltered = dbNotes.filter((n)=>!pendingNullifiers.has(n.siloedNullifier.value));
+        const notes = pickNotes([
+            ...dbNotesFiltered,
+            ...pendingNotes
+        ], {
+            selects: selectByIndexes.slice(0, numSelects).map((index, i)=>({
+                    selector: {
+                        index,
+                        offset: selectByOffsets[i],
+                        length: selectByLengths[i]
+                    },
+                    value: selectValues[i],
+                    comparator: selectComparators[i]
+                })),
+            sorts: sortByIndexes.map((index, i)=>({
+                    selector: {
+                        index,
+                        offset: sortByOffsets[i],
+                        length: sortByLengths[i]
+                    },
+                    order: sortOrder[i]
+                })),
+            limit,
+            offset
+        });
+        this.log.debug(`Returning ${notes.length} notes for ${this.callContext.contractAddress} at ${storageSlot}: ${notes.map((n)=>`${n.nonce.toString()}:[${n.note.items.map((i)=>i.toString()).join(',')}]`).join(', ')}`);
+        const noteHashesAndIndexes = await Promise.all(notes.map(async (n)=>{
+            if (n.index !== undefined) {
+                const siloedNoteHash = await siloNoteHash(n.contractAddress, n.noteHash);
+                const uniqueNoteHash = await computeUniqueNoteHash(n.nonce, siloedNoteHash);
+                return {
+                    hash: uniqueNoteHash,
+                    index: n.index
+                };
+            }
+        }));
+        noteHashesAndIndexes.filter((n)=>n !== undefined).forEach((n)=>{
+            this.noteHashLeafIndexMap.set(n.hash.toBigInt(), n.index);
+        });
+        return notes;
+    }
+    /**
+   * Keep track of the new note created during execution.
+   * It can be used in subsequent calls (or transactions when chaining txs is possible).
+   * @param contractAddress - The contract address.
+   * @param storageSlot - The storage slot.
+   * @param noteTypeId - The type ID of the note.
+   * @param noteItems - The items to be included in a Note.
+   * @param noteHash - A hash of the new note.
+   * @returns
+   */ notifyCreatedNote(storageSlot, noteTypeId, noteItems, noteHash, counter) {
+        this.log.debug(`Notified of new note with inner hash ${noteHash}`, {
+            contractAddress: this.callContext.contractAddress,
+            storageSlot,
+            noteTypeId,
+            counter
+        });
+        const note = new Note(noteItems);
+        this.noteCache.addNewNote({
+            contractAddress: this.callContext.contractAddress,
+            storageSlot,
+            nonce: Fr.ZERO,
+            note,
+            siloedNullifier: undefined,
+            noteHash
+        }, counter);
+        this.newNotes.push(new NoteAndSlot(note, storageSlot, noteTypeId));
+    }
+    /**
+   * Adding a siloed nullifier into the current set of all pending nullifiers created
+   * within the current transaction/execution.
+   * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
+   * @param noteHash - A hash of the new note.
+   */ async notifyNullifiedNote(innerNullifier, noteHash, counter) {
+        const nullifiedNoteHashCounter = await this.noteCache.nullifyNote(this.callContext.contractAddress, innerNullifier, noteHash);
+        if (nullifiedNoteHashCounter !== undefined) {
+            this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
+        }
+    }
+    /**
+   * Adding a siloed nullifier into the current set of all pending nullifiers created
+   * within the current transaction/execution.
+   * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
+   * @param noteHash - A hash of the new note.
+   */ notifyCreatedNullifier(innerNullifier) {
+        return this.noteCache.nullifierCreated(this.callContext.contractAddress, innerNullifier);
+    }
+    /**
+   * Emit a contract class log.
+   * This fn exists because we only carry a poseidon hash through the kernels, and need to
+   * keep the preimage in ts for later.
+   * @param log - The contract class log to be emitted.
+   * @param counter - The contract class log's counter.
+   */ notifyCreatedContractClassLog(log, counter) {
+        this.contractClassLogs.push(new CountedContractClassLog(log, counter));
+        const text = log.toBuffer().toString('hex');
+        this.log.verbose(`Emitted log from ContractClassRegisterer: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+    }
+    #checkValidStaticCall(childExecutionResult) {
+        if (childExecutionResult.publicInputs.noteHashes.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.nullifiers.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.l2ToL1Msgs.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.privateLogs.some((item)=>!item.isEmpty()) || childExecutionResult.publicInputs.contractClassLogsHashes.some((item)=>!item.isEmpty())) {
+            throw new Error(`Static call cannot update the state, emit L2->L1 messages or generate logs`);
+        }
+    }
+    /**
+   * Calls a private function as a nested execution.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param functionSelector - The function selector of the function to call.
+   * @param argsHash - The arguments hash to pass to the function.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The execution result.
+   */ async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+        const simulatorSetupTimer = new Timer();
+        this.log.debug(`Calling private function ${targetContractAddress}:${functionSelector} from ${this.callContext.contractAddress}`);
+        isStaticCall = isStaticCall || this.callContext.isStaticCall;
+        await verifyCurrentClassId(targetContractAddress, this.executionDataProvider, this.historicalHeader.globalVariables.blockNumber.toNumber());
+        const targetArtifact = await this.executionDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
+        const derivedTxContext = this.txContext.clone();
+        const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
+        const context = new PrivateExecutionOracle(argsHash, derivedTxContext, derivedCallContext, this.historicalHeader, this.authWitnesses, this.capsules, this.executionCache, this.noteCache, this.executionDataProvider, this.simulator, this.totalPublicCalldataCount, sideEffectCounter, this.log, this.scopes);
+        const setupTime = simulatorSetupTimer.ms();
+        const childExecutionResult = await executePrivateFunction(this.simulator, context, targetArtifact, targetContractAddress, functionSelector);
+        if (isStaticCall) {
+            this.#checkValidStaticCall(childExecutionResult);
+        }
+        this.nestedExecutions.push(childExecutionResult);
+        const publicInputs = childExecutionResult.publicInputs;
+        // Add simulator overhead to this call
+        if (childExecutionResult.profileResult) {
+            childExecutionResult.profileResult.timings.witgen += setupTime;
+        }
+        return {
+            endSideEffectCounter: publicInputs.endSideEffectCounter,
+            returnsHash: publicInputs.returnsHash
+        };
+    }
+    #onNewPublicFunctionCall(calldataHash) {
+        const calldata = this.executionCache.getPreimage(calldataHash);
+        if (!calldata) {
+            throw new Error('Calldata for public call not found in cache');
+        }
+        this.totalPublicCalldataCount += calldata.length;
+        if (this.totalPublicCalldataCount > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
+            throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS})`);
+        }
+    }
+    /**
+   * Verify relevant information when a public function is enqueued.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param calldataHash - The hash of the function selector and arguments.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   */ notifyEnqueuedPublicFunctionCall(_targetContractAddress, calldataHash, _sideEffectCounter, _isStaticCall) {
+        this.#onNewPublicFunctionCall(calldataHash);
+        return Promise.resolve();
+    }
+    /**
+   * Verify relevant information when a public teardown function is set.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param argsHash - The arguments hash to pass to the function.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   */ notifySetPublicTeardownFunctionCall(_targetContractAddress, calldataHash, _sideEffectCounter, _isStaticCall) {
+        this.#onNewPublicFunctionCall(calldataHash);
+        return Promise.resolve();
+    }
+    notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
+        return this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+    }
+    /**
+   * Derives the call context for a nested execution.
+   * @param targetContractAddress - The address of the contract being called.
+   * @param targetArtifact - The artifact of the function being called.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The derived call context.
+   */ async deriveCallContext(targetContractAddress, targetArtifact, isStaticCall = false) {
+        return new CallContext(this.contractAddress, targetContractAddress, await FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters), isStaticCall);
+    }
+    getDebugFunctionName() {
+        return this.executionDataProvider.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+    }
+    async incrementAppTaggingSecretIndexAsSender(sender, recipient) {
+        await this.executionDataProvider.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
+    }
+    async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
+        await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
+        await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
+    }
+}

package/dest/contract_function_simulator/oracle/typed_oracle.d.ts

@@ -0,0 +1,83 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { Fr, Point } from '@aztec/foundation/fields';
+import type { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import type { ContractClassLog, IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
+import type { Note, NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
+/**
+ * Information about a note needed during execution.
+ */
+export interface NoteData {
+    /** The note. */
+    note: Note;
+    /** The contract address of the note. */
+    contractAddress: AztecAddress;
+    /** The storage slot of the note. */
+    storageSlot: Fr;
+    /** The nonce of the note. */
+    nonce: Fr;
+    /** A hash of the note. */
+    noteHash: Fr;
+    /** The corresponding nullifier of the note. Undefined for pending notes. */
+    siloedNullifier?: Fr;
+    /** The note's leaf index in the note hash tree. Undefined for pending notes. */
+    index?: bigint;
+}
+/**
+ * Oracle with typed parameters and typed return values.
+ * Methods that require read and/or write will have to be implemented based on the context (public, private, or view)
+ * and are unavailable by default.
+ */
+export declare abstract class TypedOracle {
+    getRandomField(): Fr;
+    storeInExecutionCache(_values: Fr[], _hash: Fr): void;
+    loadFromExecutionCache(_hash: Fr): Promise<Fr[]>;
+    getBlockNumber(): Promise<number>;
+    getContractAddress(): Promise<AztecAddress>;
+    getChainId(): Promise<Fr>;
+    getVersion(): Promise<Fr>;
+    getKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest>;
+    getContractInstance(_address: AztecAddress): Promise<ContractInstance>;
+    getMembershipWitness(_blockNumber: number, _treeId: MerkleTreeId, _leafValue: Fr): Promise<Fr[] | undefined>;
+    getNullifierMembershipWitness(_blockNumber: number, _nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+    getPublicDataWitness(_blockNumber: number, _leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+    getLowNullifierMembershipWitness(_blockNumber: number, _nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+    getBlockHeader(_blockNumber: number): Promise<BlockHeader | undefined>;
+    getCompleteAddress(_account: AztecAddress): Promise<CompleteAddress>;
+    getAuthWitness(_messageHash: Fr): Promise<Fr[] | undefined>;
+    getNotes(_storageSlot: Fr, _numSelects: number, _selectByIndexes: number[], _selectByOffsets: number[], _selectByLengths: number[], _selectValues: Fr[], _selectComparators: number[], _sortByIndexes: number[], _sortByOffsets: number[], _sortByLengths: number[], _sortOrder: number[], _limit: number, _offset: number, _status: NoteStatus): Promise<NoteData[]>;
+    notifyCreatedNote(_storageSlot: Fr, _noteTypeId: NoteSelector, _note: Fr[], _noteHash: Fr, _counter: number): void;
+    notifyNullifiedNote(_innerNullifier: Fr, _noteHash: Fr, _counter: number): Promise<void>;
+    notifyCreatedNullifier(_innerNullifier: Fr): Promise<void>;
+    checkNullifierExists(_innerNullifier: Fr): Promise<boolean>;
+    getL1ToL2MembershipWitness(_contractAddress: AztecAddress, _messageHash: Fr, _secret: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+    storageRead(_contractAddress: AztecAddress, _startStorageSlot: Fr, _blockNumber: number, _numberOfElements: number): Promise<Fr[]>;
+    storageWrite(_startStorageSlot: Fr, _values: Fr[]): Promise<Fr[]>;
+    notifyCreatedContractClassLog(_log: ContractClassLog, _counter: number): void;
+    callPrivateFunction(_targetContractAddress: AztecAddress, _functionSelector: FunctionSelector, _argsHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<{
+        endSideEffectCounter: Fr;
+        returnsHash: Fr;
+    }>;
+    notifyEnqueuedPublicFunctionCall(_targetContractAddress: AztecAddress, _calldataHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<void>;
+    notifySetPublicTeardownFunctionCall(_targetContractAddress: AztecAddress, _calldataHash: Fr, _sideEffectCounter: number, _isStaticCall: boolean): Promise<void>;
+    notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): Promise<void>;
+    debugLog(_message: string, _fields: Fr[]): void;
+    getIndexedTaggingSecretAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<IndexedTaggingSecret>;
+    incrementAppTaggingSecretIndexAsSender(_sender: AztecAddress, _recipient: AztecAddress): Promise<void>;
+    fetchTaggedLogs(_pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;
+    deliverNote(_contractAddress: AztecAddress, _storageSlot: Fr, _nonce: Fr, _content: Fr[], _noteHash: Fr, _nullifier: Fr, _txHash: TxHash, _recipient: AztecAddress): Promise<void>;
+    getLogByTag(_tag: Fr): Promise<LogWithTxData | null>;
+    storeCapsule(_contractAddress: AztecAddress, _key: Fr, _capsule: Fr[]): Promise<void>;
+    loadCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<Fr[] | null>;
+    deleteCapsule(_contractAddress: AztecAddress, _key: Fr): Promise<void>;
+    copyCapsule(_contractAddress: AztecAddress, _srcKey: Fr, _dstKey: Fr, _numEntries: number): Promise<void>;
+    aes128Decrypt(_ciphertext: Buffer, _iv: Buffer, _symKey: Buffer): Promise<Buffer>;
+    getSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point>;
+    storePrivateEventLog(_contractAddress: AztecAddress, _recipient: AztecAddress, _eventSelector: EventSelector, _logContent: Fr[], _txHash: TxHash, _logIndexInTx: number, _txIndexInBlock: number): Promise<void>;
+}
+//# sourceMappingURL=typed_oracle.d.ts.map

package/dest/contract_function_simulator/oracle/typed_oracle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed_oracle.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/oracle/typed_oracle.ts"],"names":[],"mappings":"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"}

package/dest/contract_function_simulator/oracle/typed_oracle.js

@@ -0,0 +1,138 @@
+import { Fr } from '@aztec/foundation/fields';
+class OracleMethodNotAvailableError extends Error {
+    constructor(methodName){
+        super(`Oracle method ${methodName} is not available.`);
+    }
+}
+/**
+ * Oracle with typed parameters and typed return values.
+ * Methods that require read and/or write will have to be implemented based on the context (public, private, or view)
+ * and are unavailable by default.
+ */ export class TypedOracle {
+    getRandomField() {
+        return Fr.random();
+    }
+    storeInExecutionCache(_values, _hash) {
+        throw new OracleMethodNotAvailableError('storeInExecutionCache');
+    }
+    loadFromExecutionCache(_hash) {
+        return Promise.reject(new OracleMethodNotAvailableError('loadFromExecutionCache'));
+    }
+    getBlockNumber() {
+        return Promise.reject(new OracleMethodNotAvailableError('getBlockNumber'));
+    }
+    getContractAddress() {
+        return Promise.reject(new OracleMethodNotAvailableError('getContractAddress'));
+    }
+    getChainId() {
+        return Promise.reject(new OracleMethodNotAvailableError('getChainId'));
+    }
+    getVersion() {
+        return Promise.reject(new OracleMethodNotAvailableError('getVersion'));
+    }
+    getKeyValidationRequest(_pkMHash) {
+        return Promise.reject(new OracleMethodNotAvailableError('getKeyValidationRequest'));
+    }
+    getContractInstance(_address) {
+        return Promise.reject(new OracleMethodNotAvailableError('getContractInstance'));
+    }
+    getMembershipWitness(_blockNumber, _treeId, _leafValue) {
+        return Promise.reject(new OracleMethodNotAvailableError('getMembershipWitness'));
+    }
+    getNullifierMembershipWitness(_blockNumber, _nullifier) {
+        return Promise.reject(new OracleMethodNotAvailableError('getNullifierMembershipWitness'));
+    }
+    getPublicDataWitness(_blockNumber, _leafSlot) {
+        return Promise.reject(new OracleMethodNotAvailableError('getPublicDataWitness'));
+    }
+    getLowNullifierMembershipWitness(_blockNumber, _nullifier) {
+        return Promise.reject(new OracleMethodNotAvailableError('getLowNullifierMembershipWitness'));
+    }
+    getBlockHeader(_blockNumber) {
+        return Promise.reject(new OracleMethodNotAvailableError('getBlockHeader'));
+    }
+    getCompleteAddress(_account) {
+        return Promise.reject(new OracleMethodNotAvailableError('getCompleteAddress'));
+    }
+    getAuthWitness(_messageHash) {
+        return Promise.reject(new OracleMethodNotAvailableError('getAuthWitness'));
+    }
+    getNotes(_storageSlot, _numSelects, _selectByIndexes, _selectByOffsets, _selectByLengths, _selectValues, _selectComparators, _sortByIndexes, _sortByOffsets, _sortByLengths, _sortOrder, _limit, _offset, _status) {
+        return Promise.reject(new OracleMethodNotAvailableError('getNotes'));
+    }
+    notifyCreatedNote(_storageSlot, _noteTypeId, _note, _noteHash, _counter) {
+        throw new OracleMethodNotAvailableError('notifyCreatedNote');
+    }
+    notifyNullifiedNote(_innerNullifier, _noteHash, _counter) {
+        return Promise.reject(new OracleMethodNotAvailableError('notifyNullifiedNote'));
+    }
+    notifyCreatedNullifier(_innerNullifier) {
+        return Promise.reject(new OracleMethodNotAvailableError('notifyCreatedNullifier'));
+    }
+    checkNullifierExists(_innerNullifier) {
+        return Promise.reject(new OracleMethodNotAvailableError('checkNullifierExists'));
+    }
+    getL1ToL2MembershipWitness(_contractAddress, _messageHash, _secret) {
+        return Promise.reject(new OracleMethodNotAvailableError('getL1ToL2MembershipWitness'));
+    }
+    storageRead(_contractAddress, _startStorageSlot, _blockNumber, _numberOfElements) {
+        return Promise.reject(new OracleMethodNotAvailableError('storageRead'));
+    }
+    storageWrite(_startStorageSlot, _values) {
+        return Promise.reject(new OracleMethodNotAvailableError('storageWrite'));
+    }
+    notifyCreatedContractClassLog(_log, _counter) {
+        throw new OracleMethodNotAvailableError('notifyCreatedContractClassLog');
+    }
+    callPrivateFunction(_targetContractAddress, _functionSelector, _argsHash, _sideEffectCounter, _isStaticCall) {
+        return Promise.reject(new OracleMethodNotAvailableError('callPrivateFunction'));
+    }
+    notifyEnqueuedPublicFunctionCall(_targetContractAddress, _calldataHash, _sideEffectCounter, _isStaticCall) {
+        return Promise.reject(new OracleMethodNotAvailableError('notifyEnqueuedPublicFunctionCall'));
+    }
+    notifySetPublicTeardownFunctionCall(_targetContractAddress, _calldataHash, _sideEffectCounter, _isStaticCall) {
+        return Promise.reject(new OracleMethodNotAvailableError('notifySetPublicTeardownFunctionCall'));
+    }
+    notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter) {
+        throw new OracleMethodNotAvailableError('notifySetMinRevertibleSideEffectCounter');
+    }
+    debugLog(_message, _fields) {
+        throw new OracleMethodNotAvailableError('debugLog');
+    }
+    getIndexedTaggingSecretAsSender(_sender, _recipient) {
+        return Promise.reject(new OracleMethodNotAvailableError('getIndexedTaggingSecretAsSender'));
+    }
+    incrementAppTaggingSecretIndexAsSender(_sender, _recipient) {
+        return Promise.reject(new OracleMethodNotAvailableError('incrementAppTaggingSecretIndexAsSender'));
+    }
+    fetchTaggedLogs(_pendingTaggedLogArrayBaseSlot) {
+        return Promise.reject(new OracleMethodNotAvailableError('fetchTaggedLogs'));
+    }
+    deliverNote(_contractAddress, _storageSlot, _nonce, _content, _noteHash, _nullifier, _txHash, _recipient) {
+        return Promise.reject(new OracleMethodNotAvailableError('deliverNote'));
+    }
+    getLogByTag(_tag) {
+        throw new OracleMethodNotAvailableError('getLogByTag');
+    }
+    storeCapsule(_contractAddress, _key, _capsule) {
+        return Promise.reject(new OracleMethodNotAvailableError('storeCapsule'));
+    }
+    loadCapsule(_contractAddress, _key) {
+        return Promise.reject(new OracleMethodNotAvailableError('loadCapsule'));
+    }
+    deleteCapsule(_contractAddress, _key) {
+        return Promise.reject(new OracleMethodNotAvailableError('deleteCapsule'));
+    }
+    copyCapsule(_contractAddress, _srcKey, _dstKey, _numEntries) {
+        return Promise.reject(new OracleMethodNotAvailableError('copyCapsule'));
+    }
+    aes128Decrypt(_ciphertext, _iv, _symKey) {
+        return Promise.reject(new OracleMethodNotAvailableError('aes128Decrypt'));
+    }
+    getSharedSecret(_address, _ephPk) {
+        return Promise.reject(new OracleMethodNotAvailableError('getSharedSecret'));
+    }
+    storePrivateEventLog(_contractAddress, _recipient, _eventSelector, _logContent, _txHash, _logIndexInTx, _txIndexInBlock) {
+        return Promise.reject(new OracleMethodNotAvailableError('storePrivateEventLog'));
+    }
+}