@aztec/txe 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/txe_service/txe_service.js

@@ -1,572 +0,0 @@
-import { Fr } from '@aztec/aztec.js';
-import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
-import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { enrichPublicSimulationError } from '@aztec/pxe/server';
-import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
-import { PublicDataWrite } from '@aztec/stdlib/avm';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computePartialAddress } from '@aztec/stdlib/contract';
-import { SimulationError } from '@aztec/stdlib/errors';
-import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { TXE } from '../oracle/txe_oracle.js';
-import { addressFromSingle, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, toArray, toForeignCallResult, toSingle } from '../util/encoding.js';
-import { ExpectedFailureError } from '../util/expected_failure_error.js';
-export class TXEService {
-    logger;
-    typedOracle;
-    constructor(logger, typedOracle){
-        this.logger = logger;
-        this.typedOracle = typedOracle;
-    }
-    static async init(logger, protocolContracts) {
-        logger.debug(`TXE service initialized`);
-        const store = await openTmpStore('test');
-        const txe = await TXE.create(logger, store, protocolContracts);
-        const service = new TXEService(logger, txe);
-        await service.advanceBlocksBy(toSingle(new Fr(1n)));
-        return service;
-    }
-    // Cheatcodes
-    async getPrivateContextInputs(blockNumber) {
-        const inputs = await this.typedOracle.getPrivateContextInputs(fromSingle(blockNumber).toNumber());
-        return toForeignCallResult(inputs.toFields().map(toSingle));
-    }
-    async advanceBlocksBy(blocks) {
-        const nBlocks = fromSingle(blocks).toNumber();
-        this.logger.debug(`time traveling ${nBlocks} blocks`);
-        for(let i = 0; i < nBlocks; i++){
-            const blockNumber = await this.typedOracle.getBlockNumber();
-            await this.typedOracle.commitState();
-            this.typedOracle.setBlockNumber(blockNumber + 1);
-        }
-        return toForeignCallResult([]);
-    }
-    setContractAddress(address) {
-        const typedAddress = addressFromSingle(address);
-        this.typedOracle.setContractAddress(typedAddress);
-        return toForeignCallResult([]);
-    }
-    async deriveKeys(secret) {
-        const keys = await this.typedOracle.deriveKeys(fromSingle(secret));
-        return toForeignCallResult(keys.publicKeys.toFields().map(toSingle));
-    }
-    async deploy(artifact, instance, secret) {
-        // Emit deployment nullifier
-        this.typedOracle.addSiloedNullifiersFromPublic([
-            await siloNullifier(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), instance.address.toField())
-        ]);
-        if (!fromSingle(secret).equals(Fr.ZERO)) {
-            await this.addAccount(artifact, instance, secret);
-        } else {
-            await this.typedOracle.addContractInstance(instance);
-            await this.typedOracle.addContractArtifact(instance.currentContractClassId, artifact);
-            this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
-        }
-        return toForeignCallResult([
-            toArray([
-                instance.salt,
-                instance.deployer.toField(),
-                instance.currentContractClassId,
-                instance.initializationHash,
-                ...instance.publicKeys.toFields()
-            ])
-        ]);
-    }
-    async directStorageWrite(contractAddress, startStorageSlot, values) {
-        const startStorageSlotFr = fromSingle(startStorageSlot);
-        const valuesFr = fromArray(values);
-        const contractAddressFr = addressFromSingle(contractAddress);
-        const publicDataWrites = await Promise.all(valuesFr.map(async (value, i)=>{
-            const storageSlot = startStorageSlotFr.add(new Fr(i));
-            this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
-            return new PublicDataWrite(await computePublicDataTreeLeafSlot(contractAddressFr, storageSlot), value);
-        }));
-        await this.typedOracle.addPublicDataWrites(publicDataWrites);
-        return toForeignCallResult([
-            toArray(publicDataWrites.map((write)=>write.value))
-        ]);
-    }
-    async createAccount(secret) {
-        const keyStore = this.typedOracle.getKeyStore();
-        const secretFr = fromSingle(secret);
-        // This is a footgun !
-        const completeAddress = await keyStore.addAccount(secretFr, secretFr);
-        const accountDataProvider = this.typedOracle.getAccountDataProvider();
-        await accountDataProvider.setAccount(completeAddress.address, completeAddress);
-        const addressDataProvider = this.typedOracle.getAddressDataProvider();
-        await addressDataProvider.addCompleteAddress(completeAddress);
-        this.logger.debug(`Created account ${completeAddress.address}`);
-        return toForeignCallResult([
-            toSingle(completeAddress.address),
-            ...completeAddress.publicKeys.toFields().map(toSingle)
-        ]);
-    }
-    async addAccount(artifact, instance, secret) {
-        this.logger.debug(`Deployed ${artifact.name} at ${instance.address}`);
-        await this.typedOracle.addContractInstance(instance);
-        await this.typedOracle.addContractArtifact(instance.currentContractClassId, artifact);
-        const keyStore = this.typedOracle.getKeyStore();
-        const completeAddress = await keyStore.addAccount(fromSingle(secret), await computePartialAddress(instance));
-        const accountDataProvider = this.typedOracle.getAccountDataProvider();
-        await accountDataProvider.setAccount(completeAddress.address, completeAddress);
-        const addressDataProvider = this.typedOracle.getAddressDataProvider();
-        await addressDataProvider.addCompleteAddress(completeAddress);
-        this.logger.debug(`Created account ${completeAddress.address}`);
-        return toForeignCallResult([
-            toSingle(completeAddress.address),
-            ...completeAddress.publicKeys.toFields().map(toSingle)
-        ]);
-    }
-    getSideEffectsCounter() {
-        const counter = this.typedOracle.getSideEffectsCounter();
-        return toForeignCallResult([
-            toSingle(new Fr(counter))
-        ]);
-    }
-    async addAuthWitness(address, messageHash) {
-        await this.typedOracle.addAuthWitness(addressFromSingle(address), fromSingle(messageHash));
-        return toForeignCallResult([]);
-    }
-    async assertPublicCallFails(address, functionSelector, _length, args) {
-        const parsedAddress = addressFromSingle(address);
-        const parsedSelector = fromSingle(functionSelector);
-        const extendedArgs = [
-            parsedSelector,
-            ...fromArray(args)
-        ];
-        const result = await this.typedOracle.avmOpcodeCall(parsedAddress, extendedArgs, false);
-        if (result.revertCode.isOK()) {
-            throw new ExpectedFailureError('Public call did not revert');
-        }
-        return toForeignCallResult([]);
-    }
-    async assertPrivateCallFails(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        try {
-            await this.typedOracle.callPrivateFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-            throw new ExpectedFailureError('Private call did not fail');
-        } catch (e) {
-            if (e instanceof ExpectedFailureError) {
-                throw e;
-            }
-        }
-        return toForeignCallResult([]);
-    }
-    // PXE oracles
-    getRandomField() {
-        return toForeignCallResult([
-            toSingle(this.typedOracle.getRandomField())
-        ]);
-    }
-    async getContractAddress() {
-        const contractAddress = await this.typedOracle.getContractAddress();
-        return toForeignCallResult([
-            toSingle(contractAddress.toField())
-        ]);
-    }
-    async getBlockNumber() {
-        const blockNumber = await this.typedOracle.getBlockNumber();
-        return toForeignCallResult([
-            toSingle(new Fr(blockNumber))
-        ]);
-    }
-    // Since the argument is a slice, noir automatically adds a length field to oracle call.
-    async storeInExecutionCache(_length, values) {
-        const returnsHash = await this.typedOracle.storeInExecutionCache(fromArray(values));
-        return toForeignCallResult([
-            toSingle(returnsHash)
-        ]);
-    }
-    async loadFromExecutionCache(hash) {
-        const returns = await this.typedOracle.loadFromExecutionCache(fromSingle(hash));
-        return toForeignCallResult([
-            toArray(returns)
-        ]);
-    }
-    // Since the argument is a slice, noir automatically adds a length field to oracle call.
-    debugLog(message, _length, fields) {
-        const messageStr = fromArray(message).map((field)=>String.fromCharCode(field.toNumber())).join('');
-        const fieldsFr = fromArray(fields);
-        this.typedOracle.debugLog(messageStr, fieldsFr);
-        return toForeignCallResult([]);
-    }
-    async storageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
-        const values = await this.typedOracle.storageRead(addressFromSingle(contractAddress), fromSingle(startStorageSlot), fromSingle(blockNumber).toNumber(), fromSingle(numberOfElements).toNumber());
-        return toForeignCallResult([
-            toArray(values)
-        ]);
-    }
-    async storageWrite(startStorageSlot, values) {
-        const newValues = await this.typedOracle.storageWrite(fromSingle(startStorageSlot), fromArray(values));
-        return toForeignCallResult([
-            toArray(newValues)
-        ]);
-    }
-    async getPublicDataTreeWitness(blockNumber, leafSlot) {
-        const parsedBlockNumber = fromSingle(blockNumber).toNumber();
-        const parsedLeafSlot = fromSingle(leafSlot);
-        const witness = await this.typedOracle.getPublicDataTreeWitness(parsedBlockNumber, parsedLeafSlot);
-        if (!witness) {
-            throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
-        }
-        return toForeignCallResult([
-            toArray(witness.toFields())
-        ]);
-    }
-    async getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, returnSize) {
-        const noteDatas = await this.typedOracle.getNotes(fromSingle(storageSlot), fromSingle(numSelects).toNumber(), fromArray(selectByIndexes).map((fr)=>fr.toNumber()), fromArray(selectByOffsets).map((fr)=>fr.toNumber()), fromArray(selectByLengths).map((fr)=>fr.toNumber()), fromArray(selectValues), fromArray(selectComparators).map((fr)=>fr.toNumber()), fromArray(sortByIndexes).map((fr)=>fr.toNumber()), fromArray(sortByOffsets).map((fr)=>fr.toNumber()), fromArray(sortByLengths).map((fr)=>fr.toNumber()), fromArray(sortOrder).map((fr)=>fr.toNumber()), fromSingle(limit).toNumber(), fromSingle(offset).toNumber(), fromSingle(status).toNumber());
-        const noteLength = noteDatas?.[0]?.note.items.length ?? 0;
-        if (!noteDatas.every(({ note })=>noteLength === note.items.length)) {
-            throw new Error('Notes should all be the same length.');
-        }
-        const contractAddress = noteDatas[0]?.contractAddress ?? Fr.ZERO;
-        // Values indicates whether the note is settled or transient.
-        const noteTypes = {
-            isSettled: new Fr(0),
-            isTransient: new Fr(1)
-        };
-        const flattenData = noteDatas.flatMap(({ nonce, note, index })=>[
-                nonce,
-                index === undefined ? noteTypes.isTransient : noteTypes.isSettled,
-                ...note.items
-            ]);
-        const returnFieldSize = fromSingle(returnSize).toNumber();
-        const returnData = [
-            noteDatas.length,
-            contractAddress.toField(),
-            ...flattenData
-        ].map((v)=>new Fr(v));
-        if (returnData.length > returnFieldSize) {
-            throw new Error(`Return data size too big. Maximum ${returnFieldSize} fields. Got ${flattenData.length}.`);
-        }
-        const paddedZeros = Array(returnFieldSize - returnData.length).fill(new Fr(0));
-        return toForeignCallResult([
-            toArray([
-                ...returnData,
-                ...paddedZeros
-            ])
-        ]);
-    }
-    notifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter) {
-        this.typedOracle.notifyCreatedNote(fromSingle(storageSlot), NoteSelector.fromField(fromSingle(noteTypeId)), fromArray(note), fromSingle(noteHash), fromSingle(counter).toNumber());
-        return toForeignCallResult([
-            toSingle(new Fr(0))
-        ]);
-    }
-    async notifyNullifiedNote(innerNullifier, noteHash, counter) {
-        await this.typedOracle.notifyNullifiedNote(fromSingle(innerNullifier), fromSingle(noteHash), fromSingle(counter).toNumber());
-        return toForeignCallResult([
-            toSingle(new Fr(0))
-        ]);
-    }
-    async notifyCreatedNullifier(innerNullifier) {
-        await this.typedOracle.notifyCreatedNullifier(fromSingle(innerNullifier));
-        return toForeignCallResult([
-            toSingle(new Fr(0))
-        ]);
-    }
-    async checkNullifierExists(innerNullifier) {
-        const exists = await this.typedOracle.checkNullifierExists(fromSingle(innerNullifier));
-        return toForeignCallResult([
-            toSingle(new Fr(exists))
-        ]);
-    }
-    async getContractInstance(address) {
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
-        return toForeignCallResult([
-            toArray([
-                instance.salt,
-                instance.deployer.toField(),
-                instance.currentContractClassId,
-                instance.initializationHash,
-                ...instance.publicKeys.toFields()
-            ])
-        ]);
-    }
-    async getPublicKeysAndPartialAddress(address) {
-        const parsedAddress = addressFromSingle(address);
-        const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
-        return toForeignCallResult([
-            toArray([
-                ...publicKeys.toFields(),
-                partialAddress
-            ])
-        ]);
-    }
-    async getKeyValidationRequest(pkMHash) {
-        const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(fromSingle(pkMHash));
-        return toForeignCallResult([
-            toArray(keyValidationRequest.toFields())
-        ]);
-    }
-    async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        const result = await this.typedOracle.callPrivateFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-        return toForeignCallResult([
-            toArray([
-                result.endSideEffectCounter,
-                result.returnsHash
-            ])
-        ]);
-    }
-    async getNullifierMembershipWitness(blockNumber, nullifier) {
-        const parsedBlockNumber = fromSingle(blockNumber).toNumber();
-        const witness = await this.typedOracle.getNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
-        if (!witness) {
-            throw new Error(`Nullifier membership witness not found at block ${parsedBlockNumber}.`);
-        }
-        return toForeignCallResult([
-            toArray(witness.toFields())
-        ]);
-    }
-    async getAuthWitness(messageHash) {
-        const parsedMessageHash = fromSingle(messageHash);
-        const authWitness = await this.typedOracle.getAuthWitness(parsedMessageHash);
-        if (!authWitness) {
-            throw new Error(`Auth witness not found for message hash ${parsedMessageHash}.`);
-        }
-        return toForeignCallResult([
-            toArray(authWitness)
-        ]);
-    }
-    async enqueuePublicFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        const newArgsHash = await this.typedOracle.enqueuePublicFunctionCall(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-        return toForeignCallResult([
-            toSingle(newArgsHash)
-        ]);
-    }
-    async setPublicTeardownFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
-        const newArgsHash = await this.typedOracle.setPublicTeardownFunctionCall(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
-        return toForeignCallResult([
-            toSingle(newArgsHash)
-        ]);
-    }
-    notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
-        this.typedOracle.notifySetMinRevertibleSideEffectCounter(fromSingle(minRevertibleSideEffectCounter).toNumber());
-    }
-    async getChainId() {
-        return toForeignCallResult([
-            toSingle(await this.typedOracle.getChainId())
-        ]);
-    }
-    async getVersion() {
-        return toForeignCallResult([
-            toSingle(await this.typedOracle.getVersion())
-        ]);
-    }
-    async getBlockHeader(blockNumber) {
-        const header = await this.typedOracle.getBlockHeader(fromSingle(blockNumber).toNumber());
-        if (!header) {
-            throw new Error(`Block header not found for block ${blockNumber}.`);
-        }
-        return toForeignCallResult([
-            toArray(header.toFields())
-        ]);
-    }
-    async getMembershipWitness(blockNumber, treeId, leafValue) {
-        const parsedBlockNumber = fromSingle(blockNumber).toNumber();
-        const parsedTreeId = fromSingle(treeId).toNumber();
-        const parsedLeafValue = fromSingle(leafValue);
-        const witness = await this.typedOracle.getMembershipWitness(parsedBlockNumber, parsedTreeId, parsedLeafValue);
-        if (!witness) {
-            throw new Error(`Membership witness in tree ${MerkleTreeId[parsedTreeId]} not found for value ${parsedLeafValue} at block ${parsedBlockNumber}.`);
-        }
-        return toForeignCallResult([
-            toArray(witness)
-        ]);
-    }
-    async getLowNullifierMembershipWitness(blockNumber, nullifier) {
-        const parsedBlockNumber = fromSingle(blockNumber).toNumber();
-        const witness = await this.typedOracle.getLowNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
-        if (!witness) {
-            throw new Error(`Low nullifier witness not found for nullifier ${nullifier} at block ${parsedBlockNumber}.`);
-        }
-        return toForeignCallResult([
-            toArray(witness.toFields())
-        ]);
-    }
-    async getIndexedTaggingSecretAsSender(sender, recipient) {
-        const secret = await this.typedOracle.getIndexedTaggingSecretAsSender(AztecAddress.fromField(fromSingle(sender)), AztecAddress.fromField(fromSingle(recipient)));
-        return toForeignCallResult([
-            toArray(secret.toFields())
-        ]);
-    }
-    async syncNotes() {
-        await this.typedOracle.syncNotes();
-        return toForeignCallResult([]);
-    }
-    async storeCapsule(contractAddress, slot, capsule) {
-        await this.typedOracle.storeCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot), fromArray(capsule));
-        return toForeignCallResult([]);
-    }
-    async loadCapsule(contractAddress, slot, tSize) {
-        const values = await this.typedOracle.loadCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
-        // We are going to return a Noir Option struct to represent the possibility of null values. Options are a struct
-        // with two fields: `some` (a boolean) and `value` (a field array in this case).
-        if (values === null) {
-            // No data was found so we set `some` to 0 and pad `value` with zeros get the correct return size.
-            return toForeignCallResult([
-                toSingle(new Fr(0)),
-                toArray(Array(fromSingle(tSize).toNumber()).fill(new Fr(0)))
-            ]);
-        } else {
-            // Data was found so we set `some` to 1 and return it along with `value`.
-            return toForeignCallResult([
-                toSingle(new Fr(1)),
-                toArray(values)
-            ]);
-        }
-    }
-    async deleteCapsule(contractAddress, slot) {
-        await this.typedOracle.deleteCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
-        return toForeignCallResult([]);
-    }
-    async copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
-        await this.typedOracle.copyCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(srcSlot), fromSingle(dstSlot), fromSingle(numEntries).toNumber());
-        return toForeignCallResult([]);
-    }
-    // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts. The compiler didn't throw an error, so it took me a while to learn of the existence of this file, and that I need to implement this function here. Isn't there a way to programmatically identify that this is missing, given the existence of a txe_oracle method?
-    async aes128Decrypt(ciphertext, iv, symKey) {
-        const ciphertextBuffer = fromUintArray(ciphertext, 8);
-        const ivBuffer = fromUintArray(iv, 8);
-        const symKeyBuffer = fromUintArray(symKey, 8);
-        const plaintextBuffer = await this.typedOracle.aes128Decrypt(ciphertextBuffer, ivBuffer, symKeyBuffer);
-        return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), ciphertextBuffer.length));
-    }
-    // AVM opcodes
-    avmOpcodeEmitUnencryptedLog(_message) {
-        // TODO(#8811): Implement
-        return toForeignCallResult([]);
-    }
-    async avmOpcodeStorageRead(slot) {
-        const value = await this.typedOracle.avmOpcodeStorageRead(fromSingle(slot));
-        return toForeignCallResult([
-            toSingle(value)
-        ]);
-    }
-    async avmOpcodeStorageWrite(slot, value) {
-        await this.typedOracle.storageWrite(fromSingle(slot), [
-            fromSingle(value)
-        ]);
-        return toForeignCallResult([]);
-    }
-    async avmOpcodeGetContractInstanceDeployer(address) {
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
-        return toForeignCallResult([
-            toSingle(instance.deployer),
-            // AVM requires an extra boolean indicating the instance was found
-            toSingle(new Fr(1))
-        ]);
-    }
-    async avmOpcodeGetContractInstanceClassId(address) {
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
-        return toForeignCallResult([
-            toSingle(instance.currentContractClassId),
-            // AVM requires an extra boolean indicating the instance was found
-            toSingle(new Fr(1))
-        ]);
-    }
-    async avmOpcodeGetContractInstanceInitializationHash(address) {
-        const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
-        return toForeignCallResult([
-            toSingle(instance.initializationHash),
-            // AVM requires an extra boolean indicating the instance was found
-            toSingle(new Fr(1))
-        ]);
-    }
-    avmOpcodeSender() {
-        const sender = this.typedOracle.getMsgSender();
-        return toForeignCallResult([
-            toSingle(sender)
-        ]);
-    }
-    async avmOpcodeEmitNullifier(nullifier) {
-        await this.typedOracle.avmOpcodeEmitNullifier(fromSingle(nullifier));
-        return toForeignCallResult([]);
-    }
-    async avmOpcodeEmitNoteHash(noteHash) {
-        await this.typedOracle.avmOpcodeEmitNoteHash(fromSingle(noteHash));
-        return toForeignCallResult([]);
-    }
-    async avmOpcodeNullifierExists(innerNullifier, targetAddress) {
-        const exists = await this.typedOracle.avmOpcodeNullifierExists(fromSingle(innerNullifier), AztecAddress.fromField(fromSingle(targetAddress)));
-        return toForeignCallResult([
-            toSingle(new Fr(exists))
-        ]);
-    }
-    async avmOpcodeAddress() {
-        const contractAddress = await this.typedOracle.getContractAddress();
-        return toForeignCallResult([
-            toSingle(contractAddress.toField())
-        ]);
-    }
-    async avmOpcodeBlockNumber() {
-        const blockNumber = await this.typedOracle.getBlockNumber();
-        return toForeignCallResult([
-            toSingle(new Fr(blockNumber))
-        ]);
-    }
-    avmOpcodeIsStaticCall() {
-        const isStaticCall = this.typedOracle.getIsStaticCall();
-        return toForeignCallResult([
-            toSingle(new Fr(isStaticCall ? 1 : 0))
-        ]);
-    }
-    async avmOpcodeChainId() {
-        const chainId = await this.typedOracle.getChainId();
-        return toForeignCallResult([
-            toSingle(chainId)
-        ]);
-    }
-    async avmOpcodeVersion() {
-        const version = await this.typedOracle.getVersion();
-        return toForeignCallResult([
-            toSingle(version)
-        ]);
-    }
-    avmOpcodeReturndataSize() {
-        const size = this.typedOracle.avmOpcodeReturndataSize();
-        return toForeignCallResult([
-            toSingle(new Fr(size))
-        ]);
-    }
-    avmOpcodeReturndataCopy(rdOffset, copySize) {
-        const returndata = this.typedOracle.avmOpcodeReturndataCopy(fromSingle(rdOffset).toNumber(), fromSingle(copySize).toNumber());
-        // This is a slice, so we need to return the length as well.
-        return toForeignCallResult([
-            toSingle(new Fr(returndata.length)),
-            toArray(returndata)
-        ]);
-    }
-    async avmOpcodeCall(_gas, address, _length, args) {
-        const result = await this.typedOracle.avmOpcodeCall(addressFromSingle(address), fromArray(args), /* isStaticCall */ false);
-        // Poor man's revert handling
-        if (!result.revertCode.isOK()) {
-            if (result.revertReason && result.revertReason instanceof SimulationError) {
-                await enrichPublicSimulationError(result.revertReason, this.typedOracle.getContractDataProvider(), this.logger);
-                throw new Error(result.revertReason.message);
-            } else {
-                throw new Error(`Public function call reverted: ${result.revertReason}`);
-            }
-        }
-        return toForeignCallResult([]);
-    }
-    async avmOpcodeStaticCall(_gas, address, _length, args) {
-        const result = await this.typedOracle.avmOpcodeCall(addressFromSingle(address), fromArray(args), /* isStaticCall */ true);
-        // Poor man's revert handling
-        if (!result.revertCode.isOK()) {
-            if (result.revertReason && result.revertReason instanceof SimulationError) {
-                await enrichPublicSimulationError(result.revertReason, this.typedOracle.getContractDataProvider(), this.logger);
-                throw new Error(result.revertReason.message);
-            } else {
-                throw new Error(`Public function call reverted: ${result.revertReason}`);
-            }
-        }
-        return toForeignCallResult([]);
-    }
-    avmOpcodeSuccessCopy() {
-        const success = this.typedOracle.avmOpcodeSuccessCopy();
-        return toForeignCallResult([
-            toSingle(new Fr(success))
-        ]);
-    }
-}

package/dest/util/txe_world_state_db.d.ts

@@ -1,14 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { WorldStateDB } from '@aztec/simulator/server';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import type { TXE } from '../oracle/txe_oracle.js';
-export declare class TXEWorldStateDB extends WorldStateDB {
-    private merkleDb;
-    private txe;
-    constructor(merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource, txe: TXE);
-    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
-    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
-}
-//# sourceMappingURL=txe_world_state_db.d.ts.map

package/dest/util/txe_world_state_db.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"txe_world_state_db.d.ts","sourceRoot":"","sources":["../../src/util/txe_world_state_db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAGjF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,qBAAa,eAAgB,SAAQ,YAAY;IACnC,OAAO,CAAC,QAAQ;IAA6D,OAAO,CAAC,GAAG;gBAAhF,QAAQ,EAAE,yBAAyB,EAAE,UAAU,EAAE,kBAAkB,EAAU,GAAG,EAAE,GAAG;IAI1F,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAgB1D,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3F"}

package/dest/util/txe_world_state_db.js

@@ -1,27 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { WorldStateDB } from '@aztec/simulator/server';
-import { PublicDataWrite } from '@aztec/stdlib/avm';
-import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-export class TXEWorldStateDB extends WorldStateDB {
-    merkleDb;
-    txe;
-    constructor(merkleDb, dataSource, txe){
-        super(merkleDb, dataSource), this.merkleDb = merkleDb, this.txe = txe;
-    }
-    async storageRead(contract, slot) {
-        const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
-        const lowLeafResult = await this.merkleDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-        let value = Fr.ZERO;
-        if (lowLeafResult && lowLeafResult.alreadyPresent) {
-            const preimage = await this.merkleDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-            value = preimage.value;
-        }
-        return value;
-    }
-    async storageWrite(contract, slot, newValue) {
-        await this.txe.addPublicDataWrites([
-            new PublicDataWrite(await computePublicDataTreeLeafSlot(contract, slot), newValue)
-        ]);
-    }
-}