@aztec/txe 3.0.0-nightly.20250926 → 3.0.0-nightly.20250928

package/dest/oracle/txe_oracle.js

@@ -1,303 +0,0 @@
-import { Aes128 } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
-import { ExecutionNoteCache, HashedValuesCache, UtilityContext, pickNotes } from '@aztec/pxe/simulator';
-import { Body, L2Block } from '@aztec/stdlib/block';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
-import { Note } from '@aztec/stdlib/note';
-import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { TxEffect, TxHash } from '@aztec/stdlib/tx';
-import { insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from '../utils/block_creation.js';
-export class TXE {
-    contractAddress;
-    pxeOracleInterface;
-    forkedWorldTrees;
-    anchorBlockGlobalVariables;
-    nextBlockGlobalVariables;
-    txRequestHash;
-    isMisc;
-    isUtility;
-    isPrivate;
-    logger;
-    executionCache;
-    senderForTags;
-    noteCache;
-    constructor(contractAddress, pxeOracleInterface, forkedWorldTrees, anchorBlockGlobalVariables, nextBlockGlobalVariables, txRequestHash){
-        this.contractAddress = contractAddress;
-        this.pxeOracleInterface = pxeOracleInterface;
-        this.forkedWorldTrees = forkedWorldTrees;
-        this.anchorBlockGlobalVariables = anchorBlockGlobalVariables;
-        this.nextBlockGlobalVariables = nextBlockGlobalVariables;
-        this.txRequestHash = txRequestHash;
-        this.isMisc = true;
-        this.isUtility = true;
-        this.isPrivate = true;
-        this.executionCache = new HashedValuesCache();
-        this.logger = createLogger('txe:oracle');
-        this.logger.debug('Entering Private/Utility context');
-        this.noteCache = new ExecutionNoteCache(txRequestHash);
-    }
-    static async create(contractAddress, pxeOracleInterface, forkedWorldTrees, anchorBlockGlobalVariables, nextBlockGlobalVariables, txRequestHash) {
-        // There is no automatic message discovery and contract-driven syncing process in inlined private or utility
-        // contexts, which means that known nullifiers are also not searched for, since it is during the tagging sync that
-        // we perform this. We therefore search for known nullifiers now, as otherwise notes that were nullified would not
-        // be removed from the database.
-        await pxeOracleInterface.removeNullifiedNotes(contractAddress);
-        return new TXE(contractAddress, pxeOracleInterface, forkedWorldTrees, anchorBlockGlobalVariables, nextBlockGlobalVariables, txRequestHash);
-    }
-    // Utils
-    async checkNullifiersNotInTree(contractAddress, nullifiers) {
-        const siloedNullifiers = await Promise.all(nullifiers.map((nullifier)=>siloNullifier(contractAddress, nullifier)));
-        const db = this.forkedWorldTrees;
-        const nullifierIndexesInTree = await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, siloedNullifiers.map((n)=>n.toBuffer()));
-        if (nullifierIndexesInTree.some((index)=>index !== undefined)) {
-            throw new Error(`Rejecting tx for emitting duplicate nullifiers`);
-        }
-    }
-    utilityGetRandomField() {
-        return Fr.random();
-    }
-    utilityGetUtilityContext() {
-        return Promise.resolve(UtilityContext.from({
-            blockNumber: this.anchorBlockGlobalVariables.blockNumber,
-            timestamp: this.anchorBlockGlobalVariables.timestamp,
-            contractAddress: this.contractAddress,
-            version: this.anchorBlockGlobalVariables.version,
-            chainId: this.anchorBlockGlobalVariables.chainId
-        }));
-    }
-    privateStoreInExecutionCache(values, hash) {
-        return this.executionCache.store(values, hash);
-    }
-    privateLoadFromExecutionCache(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);
-    }
-    utilityGetKeyValidationRequest(pkMHash) {
-        return this.pxeOracleInterface.getKeyValidationRequest(pkMHash, this.contractAddress);
-    }
-    utilityGetContractInstance(address) {
-        return this.pxeOracleInterface.getContractInstance(address);
-    }
-    utilityGetMembershipWitness(blockNumber, treeId, leafValue) {
-        return this.pxeOracleInterface.getMembershipWitness(blockNumber, treeId, leafValue);
-    }
-    utilityGetNullifierMembershipWitness(blockNumber, nullifier) {
-        return this.pxeOracleInterface.getNullifierMembershipWitness(blockNumber, nullifier);
-    }
-    utilityGetPublicDataWitness(blockNumber, leafSlot) {
-        return this.pxeOracleInterface.getPublicDataWitness(blockNumber, leafSlot);
-    }
-    utilityGetLowNullifierMembershipWitness(blockNumber, nullifier) {
-        return this.pxeOracleInterface.getLowNullifierMembershipWitness(blockNumber, nullifier);
-    }
-    async utilityGetBlockHeader(blockNumber) {
-        return (await this.pxeOracleInterface.getBlock(blockNumber))?.header.toBlockHeader();
-    }
-    utilityGetPublicKeysAndPartialAddress(account) {
-        return this.pxeOracleInterface.getCompleteAddress(account);
-    }
-    async utilityGetNotes(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.contractAddress, storageSlot);
-        const pendingNullifiers = this.noteCache.getNullifiers(this.contractAddress);
-        const dbNotes = await this.pxeOracleInterface.getNotes(this.contractAddress, storageSlot, status);
-        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.logger.debug(`Returning ${notes.length} notes for ${this.contractAddress} at ${storageSlot}: ${notes.map((n)=>`${n.noteNonce.toString()}:[${n.note.items.map((i)=>i.toString()).join(',')}]`).join(', ')}`);
-        if (notes.length > 0) {
-            const noteLength = notes[0].note.items.length;
-            if (!notes.every(({ note })=>noteLength === note.items.length)) {
-                throw new Error('Notes should all be the same length.');
-            }
-        }
-        return notes;
-    }
-    privateNotifyCreatedNote(storageSlot, _noteTypeId, noteItems, noteHash, counter) {
-        const note = new Note(noteItems);
-        this.noteCache.addNewNote({
-            contractAddress: this.contractAddress,
-            storageSlot,
-            noteNonce: Fr.ZERO,
-            note,
-            siloedNullifier: undefined,
-            noteHash
-        }, counter);
-    }
-    async privateNotifyNullifiedNote(innerNullifier, noteHash, _counter) {
-        await this.checkNullifiersNotInTree(this.contractAddress, [
-            innerNullifier
-        ]);
-        await this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
-    }
-    async privateNotifyCreatedNullifier(innerNullifier) {
-        await this.checkNullifiersNotInTree(this.contractAddress, [
-            innerNullifier
-        ]);
-        await this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
-    }
-    async utilityCheckNullifierExists(innerNullifier) {
-        const nullifier = await siloNullifier(this.contractAddress, innerNullifier);
-        const index = await this.pxeOracleInterface.getNullifierIndex(nullifier);
-        return index !== undefined;
-    }
-    async utilityStorageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
-        const values = [];
-        for(let i = 0n; i < numberOfElements; i++){
-            const storageSlot = startStorageSlot.add(new Fr(i));
-            const value = await this.pxeOracleInterface.getPublicStorageAt(blockNumber, contractAddress, storageSlot);
-            values.push(value);
-        }
-        return values;
-    }
-    utilityDebugLog(message, fields) {
-        this.logger.verbose(`${applyStringFormatting(message, fields)}`, {
-            module: `${this.logger.module}:debug_log`
-        });
-    }
-    async privateIncrementAppTaggingSecretIndexAsSender(sender, recipient) {
-        await this.pxeOracleInterface.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
-    }
-    async utilityGetIndexedTaggingSecretAsSender(sender, recipient) {
-        return await this.pxeOracleInterface.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
-    }
-    async utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
-        await this.pxeOracleInterface.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot);
-        await this.pxeOracleInterface.removeNullifiedNotes(this.contractAddress);
-        return Promise.resolve();
-    }
-    async utilityValidateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot) {
-        await this.pxeOracleInterface.validateEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot);
-    }
-    async utilityBulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
-        return await this.pxeOracleInterface.bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot);
-    }
-    utilityStoreCapsule(contractAddress, slot, capsule) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.storeCapsule(this.contractAddress, slot, capsule);
-    }
-    utilityLoadCapsule(contractAddress, slot) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.loadCapsule(this.contractAddress, slot);
-    }
-    utilityDeleteCapsule(contractAddress, slot) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.deleteCapsule(this.contractAddress, slot);
-    }
-    utilityCopyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
-        if (!contractAddress.equals(this.contractAddress)) {
-            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-        }
-        return this.pxeOracleInterface.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
-    }
-    utilityAes128Decrypt(ciphertext, iv, symKey) {
-        const aes128 = new Aes128();
-        return aes128.decryptBufferCBC(ciphertext, iv, symKey);
-    }
-    utilityGetSharedSecret(address, ephPk) {
-        return this.pxeOracleInterface.getSharedSecret(address, ephPk);
-    }
-    privateGetSenderForTags() {
-        return Promise.resolve(this.senderForTags);
-    }
-    privateSetSenderForTags(senderForTags) {
-        this.senderForTags = senderForTags;
-        return Promise.resolve();
-    }
-    async close() {
-        this.logger.debug('Exiting Private Context, building block with collected side effects', {
-            blockNumber: this.nextBlockGlobalVariables.blockNumber
-        });
-        const txEffect = await this.makeTxEffect();
-        await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
-        const block = new L2Block(makeAppendOnlyTreeSnapshot(), await makeTXEBlockHeader(this.forkedWorldTrees, this.nextBlockGlobalVariables), new Body([
-            txEffect
-        ]));
-        await this.forkedWorldTrees.close();
-        this.logger.debug('Exited PublicContext with built block', {
-            blockNumber: block.number,
-            txEffects: block.body.txEffects
-        });
-        return block;
-    }
-    async makeTxEffect() {
-        const txEffect = TxEffect.empty();
-        const { usedTxRequestHashForNonces } = this.noteCache.finish();
-        const nonceGenerator = usedTxRequestHashForNonces ? this.txRequestHash : this.noteCache.getAllNullifiers()[0];
-        txEffect.noteHashes = await Promise.all(this.noteCache.getAllNotes().map(async (pendingNote, i)=>computeUniqueNoteHash(await computeNoteHashNonce(nonceGenerator, i), await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption))));
-        // Nullifiers are already siloed
-        txEffect.nullifiers = this.noteCache.getAllNullifiers();
-        if (usedTxRequestHashForNonces) {
-            txEffect.nullifiers.unshift(this.txRequestHash);
-        }
-        txEffect.txHash = new TxHash(new Fr(this.nextBlockGlobalVariables.blockNumber));
-        return txEffect;
-    }
-    // TODO: this class will soon be replaced with the real UtilityExecutionOracle and PrivateExecutionOracle classes. The
-    // functions below are not currently used in Noir tests, and in most cases they're caught beforehand by the RPC
-    // translator - we just have a temporary empty implementation until we finalize the migration.
-    utilityAssertCompatibleOracleVersion(_version) {
-        throw new Error('Method not implemented.');
-    }
-    utilityGetAuthWitness(_messageHash) {
-        throw new Error('Method not implemented.');
-    }
-    utilityGetL1ToL2MembershipWitness(_contractAddress, _messageHash, _secret) {
-        throw new Error('Method not implemented.');
-    }
-    utilityEmitOffchainEffect(_data) {
-        throw new Error('Method not implemented.');
-    }
-    privateNotifyCreatedContractClassLog(_log, _counter) {
-        throw new Error('Method not implemented.');
-    }
-    privateCallPrivateFunction(_targetContractAddress, _functionSelector, _argsHash, _sideEffectCounter, _isStaticCall) {
-        throw new Error('Method not implemented.');
-    }
-    privateNotifyEnqueuedPublicFunctionCall(_targetContractAddress, _calldataHash, _sideEffectCounter, _isStaticCall) {
-        throw new Error('Method not implemented.');
-    }
-    privateNotifySetPublicTeardownFunctionCall(_targetContractAddress, _calldataHash, _sideEffectCounter, _isStaticCall) {
-        throw new Error('Method not implemented.');
-    }
-    privateNotifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter) {
-        throw new Error('Method not implemented.');
-    }
-}