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

package/dest/bin/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S node --no-warnings
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 import { createTXERpcServer } from '../index.js';
 /**
@@ -14,10 +14,11 @@ import { createTXERpcServer } from '../index.js';
         logger.info('Received SIGTERM.');
         process.exit(0);
     });
-    const logger = createLogger('txe:service');
+    const logger = createLogger('txe:rpc');
     logger.info(`Setting up TXE...`);
     const txeServer = createTXERpcServer(logger);
     const { port } = await startHttpRpcServer(txeServer, {
+        host: '127.0.0.1',
         port: TXE_PORT,
         timeoutMs: 1e3 * 60 * 5
     });

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA+LpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,iEAIhD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA6NpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,iEAIhD"}

package/dest/index.js

@@ -1,15 +1,25 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { AztecAddress, Fr, PublicKeys, deriveKeys, getContractInstanceFromDeployParams, loadContractArtifact } from '@aztec/aztec.js';
+import { loadContractArtifact } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
 import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { computeArtifactHash } from '@aztec/stdlib/contract';
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
 import { readFile, readdir } from 'fs/promises';
-import { join } from 'path';
+import { join, parse } from 'path';
 import { z } from 'zod';
-import { TXEService } from './txe_service/txe_service.js';
-import { ForeignCallArgsSchema, ForeignCallResultSchema, fromArray, fromSingle, toForeignCallResult, toSingle } from './util/encoding.js';
-const TXESessions = new Map();
-const TXEArtifactsCache = new Map();
+import { TXESession } from './txe_session.js';
+import { ForeignCallArgsSchema, ForeignCallResultSchema, fromArray, fromSingle, toSingle } from './util/encoding.js';
+const sessions = new Map();
+/*
+ * TXE typically has to load the same contract artifacts over and over again for multiple tests,
+ * so we cache them here to avoid both loading them from disk repeatedly and computing their artifact hashes
+ */ const TXEArtifactsCache = new Map();
 const TXEForeignCallInputSchema = z.object({
     // eslint-disable-next-line camelcase
     session_id: z.number().int().nonnegative(),
@@ -26,44 +36,65 @@ class TXEDispatcher {
     constructor(logger){
         this.logger = logger;
     }
+    fastHashFile(path) {
+        return new Promise((resolve)=>{
+            const fd = createReadStream(path);
+            const hash = createHash('sha1');
+            hash.setEncoding('hex');
+            fd.on('end', function() {
+                hash.end();
+                resolve(hash.read());
+            });
+            fd.pipe(hash);
+        });
+    }
     async #processDeployInputs({ inputs, root_path: rootPath, package_name: packageName }) {
-        const [pathStr, contractName, initializer] = inputs.slice(0, 3).map((input)=>fromArray(input).map((char)=>String.fromCharCode(char.toNumber())).join(''));
-        const decodedArgs = fromArray(inputs[4]);
-        const secret = fromSingle(inputs[5]);
+        const [contractPath, initializer] = inputs.slice(0, 2).map((input)=>fromArray(input).map((char)=>String.fromCharCode(char.toNumber())).join(''));
+        const decodedArgs = fromArray(inputs[3]);
+        const secret = fromSingle(inputs[4]);
         const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
         const publicKeysHash = await publicKeys.hash();
-        const cacheKey = `${pathStr}-${contractName}-${initializer}-${decodedArgs.map((arg)=>arg.toString()).join('-')}-${publicKeysHash.toString()}`;
-        let artifact;
+        let artifactPath = '';
+        const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+        if (contractDirectory) {
+            if (contractDirectory.includes('@')) {
+                // We're deploying a contract that belongs in a workspace
+                // env.deploy("../path/to/workspace/root@packageName/contractName")
+                const [workspace, pkg] = contractDirectory.split('@');
+                const targetPath = join(rootPath, workspace, '/target');
+                this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
+                artifactPath = join(targetPath, `${pkg}-${contractFilename}.json`);
+            } else {
+                // We're deploying a standalone external contract
+                // env.deploy("../path/to/contract/root/contractName")
+                const targetPath = join(rootPath, contractDirectory, '/target');
+                this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
+                [artifactPath] = (await readdir(targetPath)).filter((file)=>file.endsWith(`-${contractFilename}.json`));
+            }
+        } else {
+            // We're deploying a local contract
+            // env.deploy("contractName")
+            artifactPath = join(rootPath, './target', `${packageName}-${contractFilename}.json`);
+        }
+        const fileHash = await this.fastHashFile(artifactPath);
+        const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${decodedArgs.map((arg)=>arg.toString()).join('-')}-${publicKeysHash}-${fileHash}`;
         let instance;
+        let artifact;
         if (TXEArtifactsCache.has(cacheKey)) {
             this.logger.debug(`Using cached artifact for ${cacheKey}`);
             ({ artifact, instance } = TXEArtifactsCache.get(cacheKey));
         } else {
-            let artifactPath = '';
-            // We're deploying the contract under test
-            // env.deploy_self("contractName")
-            if (!pathStr) {
-                artifactPath = join(rootPath, './target', `${packageName}-${contractName}.json`);
-            } else {
-                // We're deploying a contract that belongs in a workspace
-                // env.deploy("../path/to/workspace/root@packageName", "contractName")
-                if (pathStr.includes('@')) {
-                    const [workspace, pkg] = pathStr.split('@');
-                    const targetPath = join(rootPath, workspace, './target');
-                    this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
-                    artifactPath = join(targetPath, `${pkg}-${contractName}.json`);
-                } else {
-                    // We're deploying a standalone contract
-                    // env.deploy("../path/to/contract/root", "contractName")
-                    const targetPath = join(rootPath, pathStr, './target');
-                    this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
-                    [artifactPath] = (await readdir(targetPath)).filter((file)=>file.endsWith(`-${contractName}.json`));
-                }
-            }
             this.logger.debug(`Loading compiled artifact ${artifactPath}`);
-            artifact = loadContractArtifact(JSON.parse(await readFile(artifactPath, 'utf-8')));
+            const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8'));
+            const artifactWithoutHash = loadContractArtifact(artifactJSON);
+            artifact = {
+                ...artifactWithoutHash,
+                // Artifact hash is *very* expensive to compute, so we do it here once
+                // and the TXE contract data provider can cache it
+                artifactHash: await computeArtifactHash(artifactWithoutHash)
+            };
             this.logger.debug(`Deploy ${artifact.name} with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`);
-            instance = await getContractInstanceFromDeployParams(artifact, {
+            instance = await getContractInstanceFromInstantiationParams(artifact, {
                 constructorArgs: decodedArgs,
                 skipArgsDecoding: true,
                 salt: Fr.ONE,
@@ -76,7 +107,7 @@ class TXEDispatcher {
                 instance
             });
         }
-        inputs.splice(0, 2, artifact, instance, toSingle(secret));
+        inputs.splice(0, 1, artifact, instance, toSingle(secret));
     }
     async #processAddAccountInputs({ inputs }) {
         const secret = fromSingle(inputs[0]);
@@ -92,8 +123,13 @@ class TXEDispatcher {
                 keys.publicKeys.masterIncomingViewingPublicKey.x,
                 keys.publicKeys.masterIncomingViewingPublicKey.y
             ];
-            artifact = SchnorrAccountContractArtifact;
-            instance = await getContractInstanceFromDeployParams(artifact, {
+            artifact = {
+                ...SchnorrAccountContractArtifact,
+                // Artifact hash is *very* expensive to compute, so we do it here once
+                // and the TXE contract data provider can cache it
+                artifactHash: await computeArtifactHash(SchnorrAccountContractArtifact)
+            };
+            instance = await getContractInstanceFromInstantiationParams(artifact, {
                 constructorArgs: args,
                 skipArgsDecoding: true,
                 salt: Fr.ONE,
@@ -112,33 +148,26 @@ class TXEDispatcher {
     async resolve_foreign_call(callData) {
         const { session_id: sessionId, function: functionName, inputs } = callData;
         this.logger.debug(`Calling ${functionName} on session ${sessionId}`);
-        if (!TXESessions.has(sessionId) && functionName != 'reset') {
+        if (!sessions.has(sessionId)) {
             this.logger.debug(`Creating new session ${sessionId}`);
             if (!this.protocolContracts) {
                 this.protocolContracts = await Promise.all(protocolContractNames.map((name)=>new BundledProtocolContractsProvider().getProtocolContractArtifact(name)));
             }
-            TXESessions.set(sessionId, await TXEService.init(this.logger, this.protocolContracts));
+            sessions.set(sessionId, await TXESession.init(this.protocolContracts));
         }
         switch(functionName){
-            case 'reset':
-                {
-                    TXESessions.delete(sessionId) && this.logger.debug(`Called reset on session ${sessionId}, yeeting it out of existence`);
-                    return toForeignCallResult([]);
-                }
-            case 'deploy':
+            case 'txeDeploy':
                 {
                     await this.#processDeployInputs(callData);
                     break;
                 }
-            case 'addAccount':
+            case 'txeAddAccount':
                 {
                     await this.#processAddAccountInputs(callData);
                     break;
                 }
         }
-        const txeService = TXESessions.get(sessionId);
-        const response = await txeService[functionName](...inputs);
-        return response;
+        return await sessions.get(sessionId).processFunction(functionName, inputs);
     }
 }
 const TXEDispatcherApiSchema = {

package/dest/oracle/interfaces.d.ts

@@ -0,0 +1,54 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
+import { TxHash } from '@aztec/aztec.js/tx';
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt32, UInt64 } from '@aztec/stdlib/types';
+/**
+ * Oracle methods associated with the execution of an Aztec #[external("public")] function.
+ *
+ * Note that real contracts have their Brillig calls to these be transpiled into opcodes, the oracles are only executed
+ * as such when running the original Brillig code, e.g. when invoking functions that interact with a PublicContext
+ * directly in a Noir test.
+ */
+export interface IAvmExecutionOracle {
+    isAvm: true;
+    avmOpcodeAddress(): Promise<AztecAddress>;
+    avmOpcodeSender(): 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>;
+}
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */
+export interface ITxeExecutionOracle {
+    isTxe: true;
+    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[];
+    }>;
+    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=interfaces.d.ts.map

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

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

package/dest/oracle/interfaces.js

@@ -0,0 +1,3 @@
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */ export { };

package/dest/oracle/txe_oracle_public_context.d.ts

@@ -0,0 +1,34 @@
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2Block } from '@aztec/stdlib/block';
+import { type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import type { UInt32 } from '@aztec/stdlib/types';
+import type { IAvmExecutionOracle } from './interfaces.js';
+export declare class TXEOraclePublicContext implements IAvmExecutionOracle {
+    private contractAddress;
+    private forkedWorldTrees;
+    private txRequestHash;
+    private globalVariables;
+    isAvm: true;
+    private logger;
+    private transientUniqueNoteHashes;
+    private transientSiloedNullifiers;
+    private publicDataWrites;
+    constructor(contractAddress: AztecAddress, forkedWorldTrees: MerkleTreeWriteOperations, txRequestHash: Fr, globalVariables: GlobalVariables);
+    avmOpcodeAddress(): Promise<AztecAddress>;
+    avmOpcodeSender(): 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>;
+    close(): Promise<L2Block>;
+    private makeTxEffect;
+}
+//# sourceMappingURL=txe_oracle_public_context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txe_oracle_public_context.d.ts","sourceRoot":"","sources":["../../src/oracle/txe_oracle_public_context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAQ,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAEL,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAoB,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,qBAAa,sBAAuB,YAAW,mBAAmB;IAS9D,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,eAAe;IAXzB,KAAK,EAAG,IAAI,CAAU;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,yBAAyB,CAAY;IAC7C,OAAO,CAAC,yBAAyB,CAAY;IAC7C,OAAO,CAAC,gBAAgB,CAAyB;gBAGvC,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,yBAAyB,EAC3C,aAAa,EAAE,EAAE,EACjB,eAAe,EAAE,eAAe;IAW1C,gBAAgB,IAAI,OAAO,CAAC,YAAY,CAAC;IAIzC,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC;IAIxC,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIvC,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIrC,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC;IAIzC,gBAAgB,IAAI,OAAO,CAAC,EAAE,CAAC;IAI/B,gBAAgB,IAAI,OAAO,CAAC,EAAE,CAAC;IAIzB,sBAAsB,CAAC,SAAS,EAAE,EAAE;IAKpC,qBAAqB,CAAC,QAAQ,EAAE,EAAE;IAMlC,wBAAwB,CAAC,cAAc,EAAE,EAAE,EAAE,aAAa,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAW3F,qBAAqB,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAYzC,oBAAoB,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAuB3C,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAwB/B,OAAO,CAAC,YAAY;CAarB"}

package/dest/oracle/txe_oracle_public_context.js

@@ -0,0 +1,124 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Body, L2Block } from '@aztec/stdlib/block';
+import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from '../utils/block_creation.js';
+export class TXEOraclePublicContext {
+    contractAddress;
+    forkedWorldTrees;
+    txRequestHash;
+    globalVariables;
+    isAvm;
+    logger;
+    transientUniqueNoteHashes;
+    transientSiloedNullifiers;
+    publicDataWrites;
+    constructor(contractAddress, forkedWorldTrees, txRequestHash, globalVariables){
+        this.contractAddress = contractAddress;
+        this.forkedWorldTrees = forkedWorldTrees;
+        this.txRequestHash = txRequestHash;
+        this.globalVariables = globalVariables;
+        this.isAvm = true;
+        this.transientUniqueNoteHashes = [];
+        this.transientSiloedNullifiers = [];
+        this.publicDataWrites = [];
+        this.logger = createLogger('txe:public_context');
+        this.logger.debug('Entering Public Context', {
+            contractAddress,
+            blockNumber: globalVariables.blockNumber,
+            timestamp: globalVariables.timestamp
+        });
+    }
+    avmOpcodeAddress() {
+        return Promise.resolve(this.contractAddress);
+    }
+    avmOpcodeSender() {
+        return Promise.resolve(AztecAddress.ZERO); // todo: change?
+    }
+    avmOpcodeBlockNumber() {
+        return Promise.resolve(this.globalVariables.blockNumber);
+    }
+    avmOpcodeTimestamp() {
+        return Promise.resolve(this.globalVariables.timestamp);
+    }
+    avmOpcodeIsStaticCall() {
+        return Promise.resolve(false);
+    }
+    avmOpcodeChainId() {
+        return Promise.resolve(this.globalVariables.chainId);
+    }
+    avmOpcodeVersion() {
+        return Promise.resolve(this.globalVariables.version);
+    }
+    async avmOpcodeEmitNullifier(nullifier) {
+        const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
+        this.transientSiloedNullifiers.push(siloedNullifier);
+    }
+    async avmOpcodeEmitNoteHash(noteHash) {
+        const siloedNoteHash = await siloNoteHash(this.contractAddress, noteHash);
+        // TODO: make the note hash unique - they are only siloed right now
+        this.transientUniqueNoteHashes.push(siloedNoteHash);
+    }
+    async avmOpcodeNullifierExists(innerNullifier, targetAddress) {
+        const nullifier = await siloNullifier(targetAddress, innerNullifier);
+        const treeIndex = (await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
+            nullifier.toBuffer()
+        ]))[0];
+        const transientIndex = this.transientSiloedNullifiers.find((n)=>n.equals(nullifier));
+        return treeIndex !== undefined || transientIndex !== undefined;
+    }
+    async avmOpcodeStorageWrite(slot, value) {
+        this.logger.debug('AVM storage write', {
+            slot,
+            value
+        });
+        const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
+        this.publicDataWrites.push(dataWrite);
+        await this.forkedWorldTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+            new PublicDataTreeLeaf(dataWrite.leafSlot, dataWrite.value).toBuffer()
+        ]);
+    }
+    async avmOpcodeStorageRead(slot) {
+        const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
+        const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+        const value = !lowLeafResult || !lowLeafResult.alreadyPresent ? Fr.ZERO : (await this.forkedWorldTrees.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index)).leaf.value;
+        this.logger.debug('AVM storage read', {
+            slot,
+            value
+        });
+        return value;
+    }
+    async close() {
+        this.logger.debug('Exiting Public Context, building block with collected side effects', {
+            blockNumber: this.globalVariables.blockNumber
+        });
+        const txEffect = this.makeTxEffect();
+        await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
+        const block = new L2Block(makeAppendOnlyTreeSnapshot(), await makeTXEBlockHeader(this.forkedWorldTrees, this.globalVariables), new Body([
+            txEffect
+        ]));
+        await this.forkedWorldTrees.close();
+        this.logger.debug('Exited PublicContext with built block', {
+            blockNumber: block.number,
+            txEffects: block.body.txEffects
+        });
+        return block;
+    }
+    makeTxEffect() {
+        const txEffect = TxEffect.empty();
+        txEffect.noteHashes = this.transientUniqueNoteHashes;
+        txEffect.nullifiers = [
+            this.txRequestHash,
+            ...this.transientSiloedNullifiers
+        ];
+        txEffect.publicDataWrites = this.publicDataWrites;
+        // TODO: support public logs
+        txEffect.txHash = new TxHash(new Fr(this.globalVariables.blockNumber));
+        return txEffect;
+    }
+}

package/dest/oracle/txe_oracle_top_level_context.d.ts

@@ -0,0 +1,56 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { KeyStore } from '@aztec/key-store';
+import { AddressDataProvider, PXEOracleInterface } from '@aztec/pxe/server';
+import { type IMiscOracle } from '@aztec/pxe/simulator';
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { TxHash } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { TXEStateMachine } from '../state_machine/index.js';
+import type { TXEAccountDataProvider } from '../util/txe_account_data_provider.js';
+import type { TXEContractDataProvider } from '../util/txe_contract_data_provider.js';
+import type { ITxeExecutionOracle } from './interfaces.js';
+export declare class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracle {
+    private stateMachine;
+    private contractDataProvider;
+    private keyStore;
+    private addressDataProvider;
+    private accountDataProvider;
+    private pxeOracleInterface;
+    private nextBlockTimestamp;
+    private version;
+    private chainId;
+    private authwits;
+    isMisc: true;
+    isTxe: true;
+    private logger;
+    constructor(stateMachine: TXEStateMachine, contractDataProvider: TXEContractDataProvider, keyStore: KeyStore, addressDataProvider: AddressDataProvider, accountDataProvider: TXEAccountDataProvider, pxeOracleInterface: PXEOracleInterface, nextBlockTimestamp: bigint, version: Fr, chainId: Fr, authwits: Map<string, AuthWitness>);
+    utilityAssertCompatibleOracleVersion(version: number): void;
+    utilityGetRandomField(): Fr;
+    utilityDebugLog(level: number, message: string, fields: Fr[]): void;
+    txeGetNextBlockNumber(): Promise<number>;
+    txeGetNextBlockTimestamp(): Promise<bigint>;
+    txeGetLastBlockTimestamp(): Promise<bigint>;
+    txeGetLastTxEffects(): Promise<{
+        txHash: TxHash;
+        noteHashes: Fr[];
+        nullifiers: Fr[];
+    }>;
+    txeAdvanceBlocksBy(blocks: number): Promise<void>;
+    txeAdvanceTimestampBy(duration: UInt64): void;
+    txeDeploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<void>;
+    txeAddAccount(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<import("@aztec/stdlib/contract").CompleteAddress>;
+    txeCreateAccount(secret: Fr): Promise<import("@aztec/stdlib/contract").CompleteAddress>;
+    txeAddAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+    mineBlock(options?: {
+        nullifiers?: Fr[];
+    }): Promise<void>;
+    txePrivateCallNewFlow(from: AztecAddress, targetContractAddress: AztecAddress | undefined, functionSelector: FunctionSelector | undefined, args: Fr[], argsHash?: Fr, isStaticCall?: boolean): Promise<Fr[]>;
+    txePublicCallNewFlow(from: AztecAddress, targetContractAddress: AztecAddress, calldata: Fr[], isStaticCall: boolean): Promise<Fr[]>;
+    txeSimulateUtilityFunction(targetContractAddress: AztecAddress, functionSelector: FunctionSelector, args: Fr[]): Promise<Fr[]>;
+    close(): [bigint, Map<string, AuthWitness>];
+    private getLastBlockNumber;
+}
+//# sourceMappingURL=txe_oracle_top_level_context.d.ts.map

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

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