@aztec/txe 3.0.0-nightly.20250925 → 3.0.0-nightly.20250927

package/dest/oracle/txe_oracle.js

@@ -1,263 +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';
-import { TXETypedOracle } from './txe_typed_oracle.js';
-export class TXE extends TXETypedOracle {
-    contractAddress;
-    pxeOracleInterface;
-    forkedWorldTrees;
-    anchorBlockGlobalVariables;
-    nextBlockGlobalVariables;
-    txRequestHash;
-    logger;
-    executionCache;
-    senderForTags;
-    noteCache;
-    constructor(contractAddress, pxeOracleInterface, forkedWorldTrees, anchorBlockGlobalVariables, nextBlockGlobalVariables, txRequestHash){
-        super('TXEOraclePrivateUtilityContext'), this.contractAddress = contractAddress, this.pxeOracleInterface = pxeOracleInterface, this.forkedWorldTrees = forkedWorldTrees, this.anchorBlockGlobalVariables = anchorBlockGlobalVariables, this.nextBlockGlobalVariables = nextBlockGlobalVariables, this.txRequestHash = txRequestHash, 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`);
-        }
-    }
-    // TypedOracle
-    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;
-    }
-}

package/dest/oracle/txe_typed_oracle.d.ts

@@ -1,41 +0,0 @@
-import type { CompleteAddress, ContractArtifact, ContractInstanceWithAddress, TxHash } from '@aztec/aztec.js';
-import type { Fr } from '@aztec/foundation/fields';
-import { TypedOracle } from '@aztec/pxe/simulator';
-import type { FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PrivateContextInputs } from '@aztec/stdlib/kernel';
-import type { UInt32, UInt64 } from '@aztec/stdlib/types';
-export declare class TXETypedOracle extends TypedOracle {
-    avmOpcodeAddress(): Promise<AztecAddress>;
-    avmOpcodeBlockNumber(): Promise<UInt32>;
-    avmOpcodeTimestamp(): Promise<bigint>;
-    avmOpcodeIsStaticCall(): Promise<boolean>;
-    avmOpcodeChainId(): Promise<Fr>;
-    avmOpcodeVersion(): Promise<Fr>;
-    avmOpcodeEmitNullifier(_nullifier: Fr): Promise<void>;
-    avmOpcodeEmitNoteHash(_noteHash: Fr): Promise<void>;
-    avmOpcodeNullifierExists(_innerNullifier: Fr, _targetAddress: AztecAddress): Promise<boolean>;
-    avmOpcodeStorageWrite(_slot: Fr, _value: Fr): Promise<void>;
-    avmOpcodeStorageRead(_slot: Fr): Promise<Fr>;
-    txeGetPrivateContextInputs(_blockNumber?: number): Promise<PrivateContextInputs>;
-    txeGetNextBlockNumber(): Promise<number>;
-    txeGetNextBlockTimestamp(): Promise<UInt64>;
-    txeAdvanceBlocksBy(_blocks: number): Promise<void>;
-    txeAdvanceTimestampBy(_duration: UInt64): void;
-    txeDeploy(_artifact: ContractArtifact, _instance: ContractInstanceWithAddress, _foreignSecret: Fr): Promise<void>;
-    txeCreateAccount(_secret: Fr): Promise<CompleteAddress>;
-    txeAddAccount(_artifact: ContractArtifact, _instance: ContractInstanceWithAddress, _secret: Fr): Promise<CompleteAddress>;
-    txeAddAuthWitness(_address: AztecAddress, _messageHash: Fr): Promise<void>;
-    txeGetLastBlockTimestamp(): Promise<bigint>;
-    txeGetLastTxEffects(): Promise<{
-        txHash: TxHash;
-        noteHashes: Fr[];
-        nullifiers: Fr[];
-    }>;
-    storageWrite(_startStorageSlot: Fr, _values: Fr[]): Promise<Fr[]>;
-    getMsgSender(): AztecAddress;
-    txePrivateCallNewFlow(_from: AztecAddress, _targetContractAddress: AztecAddress, _functionSelector: FunctionSelector, _args: Fr[], _argsHash: Fr, _isStaticCall: boolean): Promise<Fr[]>;
-    txeSimulateUtilityFunction(_targetContractAddress: AztecAddress, _functionSelector: FunctionSelector, _args: Fr[]): Promise<Fr[]>;
-    txePublicCallNewFlow(_from: AztecAddress, _targetContractAddress: AztecAddress, _calldata: Fr[], _isStaticCall: boolean): Promise<Fr[]>;
-}
-//# sourceMappingURL=txe_typed_oracle.d.ts.map

package/dest/oracle/txe_typed_oracle.d.ts.map

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

package/dest/oracle/txe_typed_oracle.js

@@ -1,89 +0,0 @@
-import { TypedOracle } from '@aztec/pxe/simulator';
-class OracleMethodNotAvailableError extends Error {
-    constructor(className, methodName){
-        super(`Oracle method ${methodName} is not implemented in handler ${className}.`);
-    }
-}
-export class TXETypedOracle extends TypedOracle {
-    avmOpcodeAddress() {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeAddress');
-    }
-    avmOpcodeBlockNumber() {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeBlockNumber');
-    }
-    avmOpcodeTimestamp() {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeTimestamp');
-    }
-    avmOpcodeIsStaticCall() {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeIsStaticCall');
-    }
-    avmOpcodeChainId() {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeChainId');
-    }
-    avmOpcodeVersion() {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeVersion');
-    }
-    avmOpcodeEmitNullifier(_nullifier) {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeEmitNullifier');
-    }
-    avmOpcodeEmitNoteHash(_noteHash) {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeEmitNoteHash');
-    }
-    avmOpcodeNullifierExists(_innerNullifier, _targetAddress) {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeNullifierExists');
-    }
-    avmOpcodeStorageWrite(_slot, _value) {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeStorageWrite');
-    }
-    avmOpcodeStorageRead(_slot) {
-        throw new OracleMethodNotAvailableError(this.className, 'avmOpcodeStorageRead');
-    }
-    txeGetPrivateContextInputs(_blockNumber) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeGetPrivateContextInputs');
-    }
-    txeGetNextBlockNumber() {
-        throw new OracleMethodNotAvailableError(this.className, 'txeGetNextBlockNumber');
-    }
-    txeGetNextBlockTimestamp() {
-        throw new OracleMethodNotAvailableError(this.className, 'txeGetNextBlockTimestamp');
-    }
-    txeAdvanceBlocksBy(_blocks) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeAdvanceBlocksBy');
-    }
-    txeAdvanceTimestampBy(_duration) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeAdvanceTimestampBy');
-    }
-    txeDeploy(_artifact, _instance, _foreignSecret) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeDeploy');
-    }
-    txeCreateAccount(_secret) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeCreateAccount');
-    }
-    txeAddAccount(_artifact, _instance, _secret) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeAddAccount');
-    }
-    txeAddAuthWitness(_address, _messageHash) {
-        throw new OracleMethodNotAvailableError(this.className, 'txeAddAuthWitness');
-    }
-    txeGetLastBlockTimestamp() {
-        throw new OracleMethodNotAvailableError(this.className, 'txeGetLastBlockTimestamp');
-    }
-    txeGetLastTxEffects() {
-        throw new OracleMethodNotAvailableError(this.className, 'txeGetLastTxEffects');
-    }
-    storageWrite(_startStorageSlot, _values) {
-        throw new OracleMethodNotAvailableError(this.className, 'storageWrite');
-    }
-    getMsgSender() {
-        throw new OracleMethodNotAvailableError(this.className, 'getMsgSender');
-    }
-    txePrivateCallNewFlow(_from, _targetContractAddress, _functionSelector, _args, _argsHash, _isStaticCall) {
-        throw new OracleMethodNotAvailableError(this.className, 'txePrivateCallNewFlow');
-    }
-    txeSimulateUtilityFunction(_targetContractAddress, _functionSelector, _args) {
-        throw new OracleMethodNotAvailableError(this.className, 'simulateUtilityFunction');
-    }
-    txePublicCallNewFlow(_from, _targetContractAddress, _calldata, _isStaticCall) {
-        throw new OracleMethodNotAvailableError(this.className, 'txePublicCallNewFlow');
-    }
-}