@aztec/txe 0.86.0 → 0.87.0

package/dest/txe_service/txe_service.js

@@ -7,18 +7,20 @@ 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 { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import { LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { TXE } from '../oracle/txe_oracle.js';
-import { addressFromSingle, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle, toSingleOrArray } from '../util/encoding.js';
+import { addressFromSingle, arrayOfArraysToBoundedVecOfArrays, arrayToBoundedVec, bufferToU8Array, fromArray, fromSingle, fromUintArray, fromUintBoundedVec, toArray, toForeignCallResult, toSingle, toSingleOrArray } from '../util/encoding.js';
 import { ExpectedFailureError } from '../util/expected_failure_error.js';
 export class TXEService {
     logger;
     typedOracle;
+    oraclesEnabled;
     constructor(logger, typedOracle){
         this.logger = logger;
         this.typedOracle = typedOracle;
+        this.oraclesEnabled = true;
     }
     static async init(logger, protocolContracts) {
         logger.debug(`TXE service initialized`);
@@ -54,9 +56,7 @@ export class TXEService {
     }
     async deploy(artifact, instance, secret) {
         // Emit deployment nullifier
-        this.typedOracle.addSiloedNullifiersFromPublic([
-            await siloNullifier(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), instance.address.toField())
-        ]);
+        await this.typedOracle.noteCache.nullifierCreated(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), instance.address.toField());
         if (!fromSingle(secret).equals(Fr.ZERO)) {
             await this.addAccount(artifact, instance, secret);
         } else {
@@ -155,17 +155,26 @@ export class TXEService {
     }
     // PXE oracles
     getRandomField() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         return toForeignCallResult([
             toSingle(this.typedOracle.getRandomField())
         ]);
     }
     async getContractAddress() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const contractAddress = await this.typedOracle.getContractAddress();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
     async getBlockNumber() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const blockNumber = await this.typedOracle.getBlockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
@@ -173,10 +182,16 @@ export class TXEService {
     }
     // Since the argument is a slice, noir automatically adds a length field to oracle call.
     storeInExecutionCache(_length, values, hash) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         this.typedOracle.storeInExecutionCache(fromArray(values), fromSingle(hash));
         return toForeignCallResult([]);
     }
     async loadFromExecutionCache(hash) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const returns = await this.typedOracle.loadFromExecutionCache(fromSingle(hash));
         return toForeignCallResult([
             toArray(returns)
@@ -202,6 +217,9 @@ export class TXEService {
         ]);
     }
     async getPublicDataWitness(blockNumber, leafSlot) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
         const parsedLeafSlot = fromSingle(leafSlot);
         const witness = await this.typedOracle.getPublicDataWitness(parsedBlockNumber, parsedLeafSlot);
@@ -210,59 +228,71 @@ export class TXEService {
         }
         return toForeignCallResult(witness.toNoirRepresentation());
     }
-    async getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, returnSize) {
+    async getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status, maxNotes, packedRetrievedNoteLength) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         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 })=>[
+        if (noteDatas.length > 0) {
+            const noteLength = noteDatas[0].note.items.length;
+            if (!noteDatas.every(({ note })=>noteLength === note.items.length)) {
+                throw new Error('Notes should all be the same length.');
+            }
+        }
+        // The expected return type is a BoundedVec<[Field; packedRetrievedNoteLength], maxNotes> where each
+        // array is structured as [contract_address, nonce, nonzero_note_hash_counter, ...packed_note].
+        const returnDataAsArrayOfArrays = noteDatas.map(({ contractAddress, nonce, index, note })=>{
+            // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
+            const noteIsTransient = index === undefined;
+            const nonzeroNoteHashCounter = noteIsTransient ? true : false;
+            // If you change the array on the next line you have to change the `unpack_retrieved_note` function in
+            // `aztec/src/note/retrieved_note.nr`
+            return [
+                contractAddress,
                 nonce,
-                index === undefined ? noteTypes.isTransient : noteTypes.isSettled,
+                nonzeroNoteHashCounter,
                 ...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
-            ])
-        ]);
+            ];
+        });
+        // Now we convert each sub-array to an array of ForeignCallSingles
+        const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map((subArray)=>subArray.map(toSingle));
+        // At last we convert the array of arrays to a bounded vec of arrays
+        return toForeignCallResult(arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfForeignCallSingleArrays, fromSingle(maxNotes).toNumber(), fromSingle(packedRetrievedNoteLength).toNumber()));
     }
     notifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         this.typedOracle.notifyCreatedNote(fromSingle(storageSlot), NoteSelector.fromField(fromSingle(noteTypeId)), fromArray(note), fromSingle(noteHash), fromSingle(counter).toNumber());
         return toForeignCallResult([]);
     }
     async notifyNullifiedNote(innerNullifier, noteHash, counter) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.notifyNullifiedNote(fromSingle(innerNullifier), fromSingle(noteHash), fromSingle(counter).toNumber());
         return toForeignCallResult([]);
     }
     async notifyCreatedNullifier(innerNullifier) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.notifyCreatedNullifier(fromSingle(innerNullifier));
         return toForeignCallResult([]);
     }
     async checkNullifierExists(innerNullifier) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const exists = await this.typedOracle.checkNullifierExists(fromSingle(innerNullifier));
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
     async getContractInstance(address) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             instance.salt,
@@ -273,6 +303,9 @@ export class TXEService {
         ].map(toSingle));
     }
     async getPublicKeysAndPartialAddress(address) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const parsedAddress = addressFromSingle(address);
         const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
         return toForeignCallResult([
@@ -283,10 +316,16 @@ export class TXEService {
         ]);
     }
     async getKeyValidationRequest(pkMHash) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const keyValidationRequest = await this.typedOracle.getKeyValidationRequest(fromSingle(pkMHash));
         return toForeignCallResult(keyValidationRequest.toFields().map(toSingle));
     }
     async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const result = await this.typedOracle.callPrivateFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
         return toForeignCallResult([
             toArray([
@@ -296,6 +335,9 @@ export class TXEService {
         ]);
     }
     async getNullifierMembershipWitness(blockNumber, nullifier) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
         const witness = await this.typedOracle.getNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
         if (!witness) {
@@ -304,6 +346,9 @@ export class TXEService {
         return toForeignCallResult(witness.toNoirRepresentation());
     }
     async getAuthWitness(messageHash) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const parsedMessageHash = fromSingle(messageHash);
         const authWitness = await this.typedOracle.getAuthWitness(parsedMessageHash);
         if (!authWitness) {
@@ -314,28 +359,46 @@ export class TXEService {
         ]);
     }
     async notifyEnqueuedPublicFunctionCall(targetContractAddress, calldataHash, sideEffectCounter, isStaticCall) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.notifyEnqueuedPublicFunctionCall(addressFromSingle(targetContractAddress), fromSingle(calldataHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
         return toForeignCallResult([]);
     }
     async notifySetPublicTeardownFunctionCall(targetContractAddress, calldataHash, sideEffectCounter, isStaticCall) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.notifySetPublicTeardownFunctionCall(addressFromSingle(targetContractAddress), fromSingle(calldataHash), fromSingle(sideEffectCounter).toNumber(), fromSingle(isStaticCall).toBool());
         return toForeignCallResult([]);
     }
-    notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
-        this.typedOracle.notifySetMinRevertibleSideEffectCounter(fromSingle(minRevertibleSideEffectCounter).toNumber());
+    async notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
+        await this.typedOracle.notifySetMinRevertibleSideEffectCounter(fromSingle(minRevertibleSideEffectCounter).toNumber());
         return toForeignCallResult([]);
     }
     async getChainId() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         return toForeignCallResult([
             toSingle(await this.typedOracle.getChainId())
         ]);
     }
     async getVersion() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         return toForeignCallResult([
             toSingle(await this.typedOracle.getVersion())
         ]);
     }
     async getBlockHeader(blockNumber) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const header = await this.typedOracle.getBlockHeader(fromSingle(blockNumber).toNumber());
         if (!header) {
             throw new Error(`Block header not found for block ${blockNumber}.`);
@@ -343,6 +406,9 @@ export class TXEService {
         return toForeignCallResult(header.toFields().map(toSingle));
     }
     async getMembershipWitness(blockNumber, treeId, leafValue) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
         const parsedTreeId = fromSingle(treeId).toNumber();
         const parsedLeafValue = fromSingle(leafValue);
@@ -356,6 +422,9 @@ export class TXEService {
         ]);
     }
     async getLowNullifierMembershipWitness(blockNumber, nullifier) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const parsedBlockNumber = fromSingle(blockNumber).toNumber();
         const witness = await this.typedOracle.getLowNullifierMembershipWitness(parsedBlockNumber, fromSingle(nullifier));
         if (!witness) {
@@ -364,20 +433,32 @@ export class TXEService {
         return toForeignCallResult(witness.toNoirRepresentation());
     }
     async getIndexedTaggingSecretAsSender(sender, recipient) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const secret = await this.typedOracle.getIndexedTaggingSecretAsSender(AztecAddress.fromField(fromSingle(sender)), AztecAddress.fromField(fromSingle(recipient)));
         return toForeignCallResult(secret.toFields().map(toSingle));
     }
     async syncNotes(pendingTaggedLogArrayBaseSlot) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.syncNotes(fromSingle(pendingTaggedLogArrayBaseSlot));
         return toForeignCallResult([]);
     }
     async deliverNote(contractAddress, storageSlot, nonce, content, contentLength, noteHash, nullifier, txHash, recipient) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.deliverNote(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(storageSlot), fromSingle(nonce), fromArray(content.slice(0, Number(BigInt(contentLength)))), fromSingle(noteHash), fromSingle(nullifier), new TxHash(fromSingle(txHash)), AztecAddress.fromField(fromSingle(recipient)));
         return toForeignCallResult([
             toSingle(Fr.ONE)
         ]);
     }
     async getLogByTag(tag) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         // TODO(AD): this was warning that getLogByTag did not return a promise.
         const log = await Promise.resolve(this.typedOracle.getLogByTag(fromSingle(tag)));
         if (log == null) {
@@ -393,10 +474,16 @@ export class TXEService {
         }
     }
     async storeCapsule(contractAddress, slot, capsule) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.storeCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot), fromArray(capsule));
         return toForeignCallResult([]);
     }
     async loadCapsule(contractAddress, slot, tSize) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         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).
@@ -415,10 +502,16 @@ export class TXEService {
         }
     }
     async deleteCapsule(contractAddress, slot) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.deleteCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(slot));
         return toForeignCallResult([]);
     }
     async copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.copyCapsule(AztecAddress.fromField(fromSingle(contractAddress)), fromSingle(srcSlot), fromSingle(dstSlot), fromSingle(numEntries).toNumber());
         return toForeignCallResult([]);
     }
@@ -427,6 +520,9 @@ export class TXEService {
     // 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(ciphertextBVecStorage, ciphertextLength, iv, symKey) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const ciphertext = fromUintBoundedVec(ciphertextBVecStorage, ciphertextLength, 8);
         const ivBuffer = fromUintArray(iv, 8);
         const symKeyBuffer = fromUintArray(symKey, 8);
@@ -434,6 +530,9 @@ export class TXEService {
         return toForeignCallResult(arrayToBoundedVec(bufferToU8Array(plaintextBuffer), ciphertextBVecStorage.length));
     }
     async getSharedSecret(address, ephPKField0, ephPKField1, ephPKField2) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const secret = await this.typedOracle.getSharedSecret(AztecAddress.fromField(fromSingle(address)), Point.fromFields([
             fromSingle(ephPKField0),
             fromSingle(ephPKField1),
@@ -442,27 +541,42 @@ export class TXEService {
         return toForeignCallResult(secret.toFields().map(toSingle));
     }
     async storePrivateEventLog(contractAddress, recipient, eventSelector, logContent, txHash, logIndexInTx, txIndexInBlock) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.storePrivateEventLog(AztecAddress.fromField(fromSingle(contractAddress)), AztecAddress.fromField(fromSingle(recipient)), EventSelector.fromField(fromSingle(eventSelector)), fromArray(logContent), new TxHash(fromSingle(txHash)), fromSingle(logIndexInTx).toNumber(), fromSingle(txIndexInBlock).toNumber());
         return toForeignCallResult([]);
     }
     // AVM opcodes
     avmOpcodeEmitUnencryptedLog(_message) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         // TODO(#8811): Implement
         return toForeignCallResult([]);
     }
     async avmOpcodeStorageRead(slot) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const value = (await this.typedOracle.avmOpcodeStorageRead(fromSingle(slot))).value;
         return toForeignCallResult([
             toSingle(new Fr(value))
         ]);
     }
     async avmOpcodeStorageWrite(slot, value) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.storageWrite(fromSingle(slot), [
             fromSingle(value)
         ]);
         return toForeignCallResult([]);
     }
     async avmOpcodeGetContractInstanceDeployer(address) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             toSingle(instance.deployer),
@@ -471,6 +585,9 @@ export class TXEService {
         ]);
     }
     async avmOpcodeGetContractInstanceClassId(address) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             toSingle(instance.currentContractClassId),
@@ -479,6 +596,9 @@ export class TXEService {
         ]);
     }
     async avmOpcodeGetContractInstanceInitializationHash(address) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const instance = await this.typedOracle.getContractInstance(addressFromSingle(address));
         return toForeignCallResult([
             toSingle(instance.initializationHash),
@@ -487,62 +607,95 @@ export class TXEService {
         ]);
     }
     avmOpcodeSender() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const sender = this.typedOracle.getMsgSender();
         return toForeignCallResult([
             toSingle(sender)
         ]);
     }
     async avmOpcodeEmitNullifier(nullifier) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.avmOpcodeEmitNullifier(fromSingle(nullifier));
         return toForeignCallResult([]);
     }
     async avmOpcodeEmitNoteHash(noteHash) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         await this.typedOracle.avmOpcodeEmitNoteHash(fromSingle(noteHash));
         return toForeignCallResult([]);
     }
     async avmOpcodeNullifierExists(innerNullifier, targetAddress) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const exists = await this.typedOracle.avmOpcodeNullifierExists(fromSingle(innerNullifier), AztecAddress.fromField(fromSingle(targetAddress)));
         return toForeignCallResult([
             toSingle(new Fr(exists))
         ]);
     }
     async avmOpcodeAddress() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const contractAddress = await this.typedOracle.getContractAddress();
         return toForeignCallResult([
             toSingle(contractAddress.toField())
         ]);
     }
     async avmOpcodeBlockNumber() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const blockNumber = await this.typedOracle.getBlockNumber();
         return toForeignCallResult([
             toSingle(new Fr(blockNumber))
         ]);
     }
     avmOpcodeIsStaticCall() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const isStaticCall = this.typedOracle.getIsStaticCall();
         return toForeignCallResult([
             toSingle(new Fr(isStaticCall ? 1 : 0))
         ]);
     }
     async avmOpcodeChainId() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const chainId = await this.typedOracle.getChainId();
         return toForeignCallResult([
             toSingle(chainId)
         ]);
     }
     async avmOpcodeVersion() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const version = await this.typedOracle.getVersion();
         return toForeignCallResult([
             toSingle(version)
         ]);
     }
     avmOpcodeReturndataSize() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const size = this.typedOracle.avmOpcodeReturndataSize();
         return toForeignCallResult([
             toSingle(new Fr(size))
         ]);
     }
     avmOpcodeReturndataCopy(rdOffset, copySize) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         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([
@@ -551,6 +704,9 @@ export class TXEService {
         ]);
     }
     async avmOpcodeCall(_l2Gas, _daGas, address, _length, args) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const result = await this.typedOracle.avmOpcodeCall(addressFromSingle(address), fromArray(args), /* isStaticCall */ false);
         // Poor man's revert handling
         if (!result.revertCode.isOK()) {
@@ -564,6 +720,9 @@ export class TXEService {
         return toForeignCallResult([]);
     }
     async avmOpcodeStaticCall(_l2Gas, _daGas, address, _length, args) {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const result = await this.typedOracle.avmOpcodeCall(addressFromSingle(address), fromArray(args), /* isStaticCall */ true);
         // Poor man's revert handling
         if (!result.revertCode.isOK()) {
@@ -577,9 +736,34 @@ export class TXEService {
         return toForeignCallResult([]);
     }
     avmOpcodeSuccessCopy() {
+        if (!this.oraclesEnabled) {
+            throw new Error('Oracle access from the root of a TXe test are not enabled. Please use env._ to interact with the oracles.');
+        }
         const success = this.typedOracle.avmOpcodeSuccessCopy();
         return toForeignCallResult([
             toSingle(new Fr(success))
         ]);
     }
+    async privateCallNewFlow(from, targetContractAddress, functionSelector, _argsLength, args, argsHash, isStaticCall) {
+        const result = await this.typedOracle.privateCallNewFlow(addressFromSingle(from), addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromArray(args), fromSingle(argsHash), fromSingle(isStaticCall).toBool());
+        return toForeignCallResult([
+            toArray([
+                result.endSideEffectCounter,
+                result.returnsHash,
+                result.txHash
+            ])
+        ]);
+    }
+    disableOracles() {
+        this.oraclesEnabled = false;
+    }
+    enableOracles() {
+        this.oraclesEnabled = true;
+    }
+    async simulateUtilityFunction(targetContractAddress, functionSelector, argsHash) {
+        const result = await this.typedOracle.simulateUtilityFunction(addressFromSingle(targetContractAddress), FunctionSelector.fromField(fromSingle(functionSelector)), fromSingle(argsHash));
+        return toForeignCallResult([
+            toSingle(result)
+        ]);
+    }
 }

package/dest/util/encoding.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type ContractArtifact } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -30,7 +29,7 @@ export declare function fromUintArray(obj: ForeignCallArray, uintBitSize: number
  * @returns A buffer containing the unsigned integers tightly packed
  */
 export declare function fromUintBoundedVec(storage: ForeignCallArray, length: ForeignCallSingle, uintBitSize: number): Buffer;
-export declare function toSingle(obj: Fr | AztecAddress): ForeignCallSingle;
+export declare function toSingle(value: AztecAddress | EthAddress | Fr | Buffer | boolean | number | bigint): ForeignCallSingle;
 export declare function toArray(objs: Fr[]): ForeignCallArray;
 export declare function toSingleOrArray(value: Fr | Fr[]): string | string[];
 export declare function bufferToU8Array(buffer: Buffer): ForeignCallArray;
@@ -43,6 +42,14 @@ export declare function bufferToU8Array(buffer: Buffer): ForeignCallArray;
  * @returns a tuple representing a BoundedVec.
  */
 export declare function arrayToBoundedVec(bVecStorage: ForeignCallArray, maxLen: number): [ForeignCallArray, ForeignCallSingle];
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export declare function arrayOfArraysToBoundedVecOfArrays(bVecStorage: ForeignCallArray[], maxLen: number, nestedArrayLength: number): [ForeignCallArray, ForeignCallSingle];
 export declare function toForeignCallResult(obj: (ForeignCallSingle | ForeignCallArray)[]): {
     values: (string | ForeignCallArray)[];
 };
@@ -78,8 +85,8 @@ export declare const ForeignCallArgsSchema: z.ZodArray<z.ZodUnion<[z.ZodString,
     }>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
-    publicKeys: import("@aztec/stdlib/keys").PublicKeys;
     salt: Fr;
+    publicKeys: import("@aztec/stdlib/keys").PublicKeys;
     deployer: AztecAddress;
     currentContractClassId: Fr;
     originalContractClassId: Fr;

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

@@ -1 +1 @@
-{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/util/encoding.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAA0B,MAAM,mBAAmB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,KAAK,2BAA2B,EAAqC,MAAM,wBAAwB,CAAC;AAE7G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG,MAAM,EAAE,CAAC;AAExC,MAAM,MAAM,eAAe,GAAG,CAAC,iBAAiB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,2BAA2B,CAAC,EAAE,CAAC;AAExH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE,CAAC;CAClD,CAAC;AAEF,wBAAgB,UAAU,CAAC,GAAG,EAAE,iBAAiB,MAEhD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,gBAEvD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,gBAAgB,QAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAMhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAOpH;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,YAAY,GAAG,iBAAiB,CAElE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,gBAAgB,CAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,qBAE/C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAEhE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,gBAAgB,EAC7B,MAAM,EAAE,MAAM,GACb,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAYvC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE;;EAEhF;AAED,eAAO,MAAM,uBAAuB,aAAa,CAAC;AAElD,eAAO,MAAM,sBAAsB,iCAAsB,CAAC;AAE1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEjC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC"}
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/util/encoding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAA0B,MAAM,mBAAmB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,KAAK,2BAA2B,EAAqC,MAAM,wBAAwB,CAAC;AAE7G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG,MAAM,EAAE,CAAC;AAExC,MAAM,MAAM,eAAe,GAAG,CAAC,iBAAiB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,2BAA2B,CAAC,EAAE,CAAC;AAExH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE,CAAC;CAClD,CAAC;AAEF,wBAAgB,UAAU,CAAC,GAAG,EAAE,iBAAiB,MAEhD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,gBAEvD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,gBAAgB,QAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAMhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAOpH;AAID,wBAAgB,QAAQ,CACtB,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,EAAE,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GACzE,iBAAiB,CAYnB;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,gBAAgB,CAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,qBAE/C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAEhE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,gBAAgB,EAC7B,MAAM,EAAE,MAAM,GACb,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAYvC;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,gBAAgB,EAAE,EAC/B,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,GACxB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAqBvC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,EAAE;;EAEhF;AAED,eAAO,MAAM,uBAAuB,aAAa,CAAC;AAElD,eAAO,MAAM,sBAAsB,iCAAsB,CAAC;AAE1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEjC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC"}