@aztec/txe 2.1.0-rc.9 → 3.0.0-devnet.2

package/dest/txe_session.js

@@ -1,37 +1,24 @@
-import { AztecAddress, Fr } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { AddressDataProvider, CapsuleDataProvider, NoteDataProvider, PrivateEventDataProvider, TaggingDataProvider } from '@aztec/pxe/server';
-import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { TXE } from './oracle/txe_oracle.js';
+import { AddressDataProvider, CapsuleDataProvider, NoteDataProvider, PXEOracleInterface, PrivateEventDataProvider, TaggingDataProvider } from '@aztec/pxe/server';
+import { ExecutionNoteCache, ExecutionTaggingIndexCache, HashedValuesCache, PrivateExecutionOracle, UtilityExecutionOracle } from '@aztec/pxe/simulator';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Body, L2Block } from '@aztec/stdlib/block';
+import { GasSettings } from '@aztec/stdlib/gas';
+import { makeAppendOnlyTreeSnapshot, makeGlobalVariables } from '@aztec/stdlib/testing';
+import { CallContext, TxContext } from '@aztec/stdlib/tx';
+import { z } from 'zod';
 import { TXEOraclePublicContext } from './oracle/txe_oracle_public_context.js';
+import { TXEOracleTopLevelContext } from './oracle/txe_oracle_top_level_context.js';
+import { RPCTranslator } from './rpc_translator.js';
 import { TXEStateMachine } from './state_machine/index.js';
-import { TXEService } from './txe_service/txe_service.js';
 import { TXEAccountDataProvider } from './util/txe_account_data_provider.js';
 import { TXEContractDataProvider } from './util/txe_contract_data_provider.js';
-/**
- * A TXE Session can be ine one of four states, which change as the test progresses and different oracles are called.
- * The current state determines which oracles are available.
- */ var SessionState = /*#__PURE__*/ function(SessionState) {
-    /**
-   * The top-level state is the default state, before any other state has been entered. This is where contracts can be
-   * deployed, accounts created, blocks mined, etc.
-   */ SessionState[SessionState["TOP_LEVEL"] = 0] = "TOP_LEVEL";
-    /**
-   * The private state is entered via the `private_context` function. In this state the PXE oracles that `#[private]`
-   * functions use are available, such as those related to note retrieval, notification of side-effects, capsule access,
-   * etc. */ SessionState[SessionState["PRIVATE"] = 1] = "PRIVATE";
-    /**
-   * The public state is entered via the `public_context` function. In this state the AVM opcodes that `#[public]`
-   * functions execute are resolved as oracles by TXE, since Noir tests are not transpiled. */ SessionState[SessionState["PUBLIC"] = 2] = "PUBLIC";
-    /**
-   * The utility state is entered via the `utility_context` function. In this state the PXE oracles that `#[utility]`
-   * functions use are available, such as those related to (unconstrained) note retrieval, capsule access, public
-   * storage reads, etc.
-   */ SessionState[SessionState["UTILITY"] = 3] = "UTILITY";
-    return SessionState;
-}(SessionState || {});
+import { getSingleTxBlockRequestHash, insertTxEffectIntoWorldTrees, makeTXEBlockHeader } from './utils/block_creation.js';
+import { makeTxEffect } from './utils/tx_effect_creation.js';
 const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
 /**
  * A `TXESession` corresponds to a Noir `#[test]` function, and handles all of its oracle calls, stores test-specific
@@ -40,14 +27,32 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
     logger;
     stateMachine;
     oracleHandler;
-    legacyTXEOracle;
+    contractDataProvider;
+    keyStore;
+    addressDataProvider;
+    accountDataProvider;
+    chainId;
+    version;
+    nextBlockTimestamp;
+    pxeOracleInterface;
     state;
-    constructor(logger, stateMachine, oracleHandler, legacyTXEOracle){
+    authwits;
+    constructor(logger, stateMachine, oracleHandler, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, chainId, version, nextBlockTimestamp, pxeOracleInterface){
         this.logger = logger;
         this.stateMachine = stateMachine;
         this.oracleHandler = oracleHandler;
-        this.legacyTXEOracle = legacyTXEOracle;
-        this.state = 0;
+        this.contractDataProvider = contractDataProvider;
+        this.keyStore = keyStore;
+        this.addressDataProvider = addressDataProvider;
+        this.accountDataProvider = accountDataProvider;
+        this.chainId = chainId;
+        this.version = version;
+        this.nextBlockTimestamp = nextBlockTimestamp;
+        this.pxeOracleInterface = pxeOracleInterface;
+        this.state = {
+            name: 'TOP_LEVEL'
+        };
+        this.authwits = new Map();
     }
     static async init(protocolContracts) {
         const store = await openTmpStore('txe-session');
@@ -65,9 +70,13 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
             await contractDataProvider.addContractInstance(instance);
         }
         const stateMachine = await TXEStateMachine.create(store);
-        const txeOracle = new TXE(keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider, accountDataProvider, DEFAULT_ADDRESS, await stateMachine.synchronizer.nativeWorldStateService.fork(), stateMachine);
-        await txeOracle.txeAdvanceBlocksBy(1);
-        return new TXESession(createLogger('txe:session'), stateMachine, txeOracle, txeOracle);
+        const nextBlockTimestamp = BigInt(Math.floor(new Date().getTime() / 1000));
+        const version = new Fr(await stateMachine.node.getVersion());
+        const chainId = new Fr(await stateMachine.node.getChainId());
+        const pxeOracleInterface = new PXEOracleInterface(stateMachine.node, keyStore, contractDataProvider, noteDataProvider, capsuleDataProvider, stateMachine.syncDataProvider, taggingDataProvider, addressDataProvider, privateEventDataProvider);
+        const topLevelOracleHandler = new TXEOracleTopLevelContext(stateMachine, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, pxeOracleInterface, nextBlockTimestamp, version, chainId, new Map());
+        await topLevelOracleHandler.txeAdvanceBlocksBy(1);
+        return new TXESession(createLogger('txe:session'), stateMachine, topLevelOracleHandler, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, version, chainId, nextBlockTimestamp, pxeOracleInterface);
     }
     /**
    * Processes an oracle function invoked by the Noir test associated to this session.
@@ -75,64 +84,170 @@ const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);
    * @param inputs The inputs of the oracle.
    * @returns The oracle return values.
    */ processFunction(functionName, inputs) {
-        return new TXEService(this, this.oracleHandler)[functionName](...inputs);
+        try {
+            const translator = new RPCTranslator(this, this.oracleHandler);
+            // We perform a runtime validation to check that the function name corresponds to a real oracle handler.
+            const validatedFunctionName = z.string().refine((fn)=>typeof translator[fn] === 'function' && !fn.startsWith('handlerAs') && fn !== 'constructor').parse(functionName);
+            return translator[validatedFunctionName](...inputs);
+        } catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`${functionName} does not correspond to any oracle handler available on RPCTranslator`);
+            } else if (error instanceof Error) {
+                throw new Error(`Execution error while processing function ${functionName} in state ${this.state.name}: ${error.message}`);
+            } else {
+                throw new Error(`Unknown execution error while processing function ${functionName} in state ${this.state.name}`);
+            }
+        }
     }
-    async setTopLevelContext() {
-        if (this.state == 1) {
-            await this.oracleHandler.txeAdvanceBlocksBy(1);
-            this.oracleHandler.txeSetContractAddress(DEFAULT_ADDRESS);
-        } else if (this.state == 2) {
-            const block = await this.oracleHandler.close();
-            await this.stateMachine.handleL2Block(block);
-            this.legacyTXEOracle.baseFork = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
-            this.legacyTXEOracle.txeSetContractAddress(DEFAULT_ADDRESS);
-            this.legacyTXEOracle.setBlockNumber(block.number + 1);
-            this.oracleHandler = this.legacyTXEOracle;
-        } else if (this.state == 3) {
-            this.oracleHandler.txeSetContractAddress(DEFAULT_ADDRESS);
-        } else if (this.state == 0) {
-            throw new Error(`Expected to be in state other than ${SessionState[0]}`);
-        } else {
-            throw new Error(`Unexpected state '${this.state}'`);
+    async enterTopLevelState() {
+        switch(this.state.name){
+            case 'PRIVATE':
+                {
+                    await this.exitPrivateState();
+                    break;
+                }
+            case 'PUBLIC':
+                {
+                    await this.exitPublicState();
+                    break;
+                }
+            case 'UTILITY':
+                {
+                    this.exitUtilityContext();
+                    break;
+                }
+            case 'TOP_LEVEL':
+                {
+                    throw new Error(`Expected to be in state other than TOP_LEVEL`);
+                }
+            default:
+                {
+                    this.state;
+                }
         }
-        this.state = 0;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
+        this.oracleHandler = new TXEOracleTopLevelContext(this.stateMachine, this.contractDataProvider, this.keyStore, this.addressDataProvider, this.accountDataProvider, this.pxeOracleInterface, this.nextBlockTimestamp, this.version, this.chainId, this.authwits);
+        this.state = {
+            name: 'TOP_LEVEL'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
     }
-    async setPublicContext(contractAddress) {
-        this.assertInTopLevelState();
+    async enterPrivateState(contractAddress = DEFAULT_ADDRESS, anchorBlockNumber) {
+        this.exitTopLevelState();
+        // There is no automatic message discovery and contract-driven syncing process in inlined private or utility
+        // contexts, which means that known nullifiers are also not searched for, since it is during the tagging sync that
+        // we perform this. We therefore search for known nullifiers now, as otherwise notes that were nullified would not
+        // be removed from the database.
+        // TODO(#12553): make the synchronizer sync here instead and remove this
+        await this.pxeOracleInterface.syncNoteNullifiers(contractAddress);
+        // Private execution has two associated block numbers: the anchor block (i.e. the historical block that is used to
+        // build the proof), and the *next* block, i.e. the one we'll create once the execution ends, and which will contain
+        // a single transaction with the effects of what was done in the test.
+        const anchorBlock = await this.stateMachine.node.getBlockHeader(anchorBlockNumber ?? 'latest');
+        const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
+        const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
+            blockNumber: latestBlock.globalVariables.blockNumber + 1,
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
+        const noteCache = new ExecutionNoteCache(txRequestHash);
+        const taggingIndexCache = new ExecutionTaggingIndexCache();
+        this.oracleHandler = new PrivateExecutionOracle(Fr.ZERO, new TxContext(this.chainId, this.version, GasSettings.empty()), new CallContext(AztecAddress.ZERO, contractAddress, FunctionSelector.empty(), false), anchorBlock, [], [], new HashedValuesCache(), noteCache, taggingIndexCache, this.pxeOracleInterface);
+        // We store the note and tagging index caches fed into the PrivateExecutionOracle (along with some other auxiliary
+        // data) in order to refer to it later, mimicking the way this object is used by the ContractFunctionSimulator. The
+        // difference resides in that the simulator has all information needed in order to run the simulation, while ours
+        // will be ongoing as the different oracles will be invoked from the Noir test, until eventually the private
+        // execution finishes.
+        this.state = {
+            name: 'PRIVATE',
+            nextBlockGlobalVariables,
+            txRequestHash,
+            noteCache,
+            taggingIndexCache
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+        return this.oracleHandler.getPrivateContextInputs();
+    }
+    async enterPublicState(contractAddress) {
+        this.exitTopLevelState();
+        // The PublicContext will create a block with a single transaction in it, containing the effects of what was done in
+        // the test. The block therefore gets the *next* block number and timestamp.
+        const latestBlockNumber = (await this.stateMachine.node.getBlockHeader('latest')).globalVariables.blockNumber;
         const globalVariables = makeGlobalVariables(undefined, {
-            blockNumber: await this.legacyTXEOracle.utilityGetBlockNumber(),
-            timestamp: await this.legacyTXEOracle.utilityGetTimestamp(),
-            version: await this.legacyTXEOracle.utilityGetVersion(),
-            chainId: await this.legacyTXEOracle.utilityGetChainId()
+            blockNumber: latestBlockNumber + 1,
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
         });
-        const txRequestHash = new Fr(globalVariables.blockNumber + 6969);
-        this.oracleHandler = new TXEOraclePublicContext(contractAddress ?? DEFAULT_ADDRESS, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), txRequestHash, globalVariables);
-        this.state = 2;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
+        this.oracleHandler = new TXEOraclePublicContext(contractAddress ?? DEFAULT_ADDRESS, await this.stateMachine.synchronizer.nativeWorldStateService.fork(), getSingleTxBlockRequestHash(globalVariables.blockNumber), globalVariables);
+        this.state = {
+            name: 'PUBLIC'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+    }
+    async enterUtilityState(contractAddress = DEFAULT_ADDRESS) {
+        this.exitTopLevelState();
+        // There is no automatic message discovery and contract-driven syncing process in inlined private or utility
+        // contexts, which means that known nullifiers are also not searched for, since it is during the tagging sync that
+        // we perform this. We therefore search for known nullifiers now, as otherwise notes that were nullified would not
+        // be removed from the database.
+        // TODO(#12553): make the synchronizer sync here instead and remove this
+        await this.pxeOracleInterface.syncNoteNullifiers(contractAddress);
+        this.oracleHandler = new UtilityExecutionOracle(contractAddress, [], [], this.pxeOracleInterface);
+        this.state = {
+            name: 'UTILITY'
+        };
+        this.logger.debug(`Entered state ${this.state.name}`);
+    }
+    exitTopLevelState() {
+        if (this.state.name != 'TOP_LEVEL') {
+            throw new Error(`Expected to be in state 'TOP_LEVEL', but got '${this.state.name}' instead`);
+        }
+        // Note that while all public and private contexts do is build a single block that we then process when exiting
+        // those, the top level context performs a large number of actions not captured in the following 'close' call. Among
+        // others, it will create empty blocks (via `txeAdvanceBlocksBy` and `deploy`), create blocks with transactions via
+        // `txePrivateCallNewFlow` and `txePublicCallNewFlow`, add accounts to PXE via `txeAddAccount`, etc. This is a
+        // slight inconsistency in the working model of this class, but is not too bad.
+        // TODO: it's quite unfortunate that we need to capture the authwits created to later pass them again when the top
+        // level context is re-created. This is because authwits create a temporary utility context that'd otherwise reset
+        // the authwits if not persisted, so we'd not be able to pass more than one per execution.
+        // Ideally authwits would be passed alongside a contract call instead of pre-seeded.
+        [this.nextBlockTimestamp, this.authwits] = this.oracleHandler.close();
     }
-    async setPrivateContext(contractAddress, historicalBlockNumber) {
-        this.assertInTopLevelState();
-        if (contractAddress) {
-            this.oracleHandler.txeSetContractAddress(contractAddress);
+    async exitPrivateState() {
+        if (this.state.name != 'PRIVATE') {
+            throw new Error(`Expected to be in state 'PRIVATE', but got '${this.state.name}' instead`);
         }
-        const privateContextInputs = await this.oracleHandler.txeGetPrivateContextInputs(historicalBlockNumber);
-        this.state = 1;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
-        return privateContextInputs;
+        this.logger.debug('Exiting Private state, building block with collected side effects', {
+            blockNumber: this.state.nextBlockGlobalVariables.blockNumber
+        });
+        // We rely on the note cache to determine the effects of the transaction. This is incomplete as it doesn't private
+        // logs (other effects like enqueued public calls don't need to be considered since those are not allowed).
+        const txEffect = await makeTxEffect(this.state.noteCache, this.state.txRequestHash, this.state.nextBlockGlobalVariables.blockNumber);
+        // We build a block holding just this transaction
+        const forkedWorldTrees = await this.stateMachine.synchronizer.nativeWorldStateService.fork();
+        await insertTxEffectIntoWorldTrees(txEffect, forkedWorldTrees);
+        const block = new L2Block(makeAppendOnlyTreeSnapshot(), await makeTXEBlockHeader(forkedWorldTrees, this.state.nextBlockGlobalVariables), new Body([
+            txEffect
+        ]));
+        await this.stateMachine.handleL2Block(block);
+        await forkedWorldTrees.close();
+        this.logger.debug('Exited PublicContext with built block', {
+            blockNumber: block.number,
+            txEffects: block.body.txEffects
+        });
     }
-    setUtilityContext(contractAddress) {
-        this.assertInTopLevelState();
-        if (contractAddress) {
-            this.oracleHandler.txeSetContractAddress(contractAddress);
+    async exitPublicState() {
+        if (this.state.name != 'PUBLIC') {
+            throw new Error(`Expected to be in state 'PUBLIC', but got '${this.state.name}' instead`);
         }
-        this.state = 3;
-        this.logger.debug(`Entered state ${SessionState[this.state]}`);
-        return Promise.resolve();
+        const block = await this.oracleHandler.close();
+        await this.stateMachine.handleL2Block(block);
     }
-    assertInTopLevelState() {
-        if (this.state != 0) {
-            throw new Error(`Expected to be in state ${SessionState[0]}, but got '${SessionState[this.state]}' instead`);
+    exitUtilityContext() {
+        if (this.state.name != 'UTILITY') {
+            throw new Error(`Expected to be in state 'UTILITY', but got '${this.state.name}' instead`);
         }
     }
 }

package/dest/util/encoding.d.ts

@@ -86,11 +86,11 @@ export declare const ForeignCallArgsSchema: z.ZodArray<z.ZodUnion<[z.ZodString,
 }, "strip", z.ZodTypeAny, {
     version: 1;
     salt: Fr;
-    publicKeys: import("@aztec/stdlib/keys").PublicKeys;
     deployer: AztecAddress;
     currentContractClassId: Fr;
     originalContractClassId: Fr;
     initializationHash: Fr;
+    publicKeys: import("@aztec/stdlib/keys").PublicKeys;
 }, {
     version: 1;
     publicKeys: {

package/dest/util/txe_contract_data_provider.d.ts

@@ -1,4 +1,5 @@
-import { type ContractArtifact, Fr } from '@aztec/aztec.js';
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { Fr } from '@aztec/aztec.js/fields';
 import { ContractDataProvider } from '@aztec/pxe/server';
 export type ContractArtifactWithHash = ContractArtifact & {
     artifactHash: Fr;

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

@@ -1 +1 @@
-{"version":3,"file":"txe_contract_data_provider.d.ts","sourceRoot":"","sources":["../../src/util/txe_contract_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,GAAG;IAAE,YAAY,EAAE,EAAE,CAAA;CAAE,CAAC;AAO/E,qBAAa,uBAAwB,SAAQ,oBAAoB;;IAGzC,mBAAmB,CACvC,EAAE,EAAE,EAAE,EACN,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GACpD,OAAO,CAAC,IAAI,CAAC;IAOM,mBAAmB,CACvC,eAAe,EAAE,EAAE,GAClB,OAAO,CAAC,gBAAgB,GAAG,wBAAwB,GAAG,SAAS,CAAC;CASpE"}
+{"version":3,"file":"txe_contract_data_provider.d.ts","sourceRoot":"","sources":["../../src/util/txe_contract_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,GAAG;IAAE,YAAY,EAAE,EAAE,CAAA;CAAE,CAAC;AAO/E,qBAAa,uBAAwB,SAAQ,oBAAoB;;IAGzC,mBAAmB,CACvC,EAAE,EAAE,EAAE,EACN,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,GACpD,OAAO,CAAC,IAAI,CAAC;IAOM,mBAAmB,CACvC,eAAe,EAAE,EAAE,GAClB,OAAO,CAAC,gBAAgB,GAAG,wBAAwB,GAAG,SAAS,CAAC;CASpE"}

package/dest/util/txe_contract_data_provider.js

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/aztec.js';
+import { Fr } from '@aztec/aztec.js/fields';
 import { ContractDataProvider } from '@aztec/pxe/server';
 /*
  * A contract data provider that stores contract artifacts with their hashes. Since

package/dest/util/txe_public_contract_data_source.d.ts

@@ -1,12 +1,13 @@
 import { Fr } from '@aztec/foundation/fields';
+import type { ContractDataProvider } from '@aztec/pxe/server';
 import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type ContractClassPublic, type ContractDataSource, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { TXE } from '../oracle/txe_oracle.js';
 export declare class TXEPublicContractDataSource implements ContractDataSource {
     #private;
-    private txeOracle;
-    constructor(txeOracle: TXE);
+    private blockNumber;
+    private contractDataProvider;
+    constructor(blockNumber: number, contractDataProvider: ContractDataProvider);
     getBlockNumber(): Promise<number>;
     getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
     getBytecodeCommitment(id: Fr): Promise<Fr | undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"txe_public_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/util/txe_public_contract_data_source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAIjC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,qBAAa,2BAA4B,YAAW,kBAAkB;;IAExD,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,GAAG;IAElC,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAI3B,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAkClE,qBAAqB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAKtD,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;IAK1F,mBAAmB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAI9B,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAKjF,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI1G,kCAAkC,CAAC,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAGnE"}
+{"version":3,"file":"txe_public_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/util/txe_public_contract_data_source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAIjC,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,2BAA4B,YAAW,kBAAkB;;IAGlE,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,oBAAoB;gBADpB,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,oBAAoB;IAGpD,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAI3B,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAkClE,qBAAqB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAKtD,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;IAK1F,mBAAmB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAI9B,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAKjF,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI1G,kCAAkC,CAAC,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAGnE"}

package/dest/util/txe_public_contract_data_source.js

@@ -2,21 +2,23 @@ import { Fr } from '@aztec/foundation/fields';
 import { FunctionType } from '@aztec/stdlib/abi';
 import { computePrivateFunctionsRoot, computePublicBytecodeCommitment, getContractClassPrivateFunctionFromArtifact } from '@aztec/stdlib/contract';
 export class TXEPublicContractDataSource {
-    txeOracle;
+    blockNumber;
+    contractDataProvider;
     #privateFunctionsRoot;
-    constructor(txeOracle){
-        this.txeOracle = txeOracle;
+    constructor(blockNumber, contractDataProvider){
+        this.blockNumber = blockNumber;
+        this.contractDataProvider = contractDataProvider;
         this.#privateFunctionsRoot = new Map();
     }
     getBlockNumber() {
-        return this.txeOracle.utilityGetBlockNumber();
+        return Promise.resolve(this.blockNumber);
     }
     async getContractClass(id) {
-        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+        const contractClass = await this.contractDataProvider.getContractClass(id);
         if (!contractClass) {
             return;
         }
-        const artifact = await this.txeOracle.getContractDataProvider().getContractArtifact(id);
+        const artifact = await this.contractDataProvider.getContractArtifact(id);
         if (!artifact) {
             return;
         }
@@ -39,11 +41,11 @@ export class TXEPublicContractDataSource {
         };
     }
     async getBytecodeCommitment(id) {
-        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+        const contractClass = await this.contractDataProvider.getContractClass(id);
         return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
     }
     async getContract(address) {
-        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
+        const instance = await this.contractDataProvider.getContractInstance(address);
         return instance && {
             ...instance,
             address
@@ -53,11 +55,11 @@ export class TXEPublicContractDataSource {
         throw new Error('Method not implemented.');
     }
     async getContractArtifact(address) {
-        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-        return instance && this.txeOracle.getContractDataProvider().getContractArtifact(instance.currentContractClassId);
+        const instance = await this.contractDataProvider.getContractInstance(address);
+        return instance && this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
     }
     async getDebugFunctionName(address, selector) {
-        return await this.txeOracle.getContractDataProvider().getDebugFunctionName(address, selector);
+        return await this.contractDataProvider.getDebugFunctionName(address, selector);
     }
     registerContractFunctionSignatures(_signatures) {
         return Promise.resolve();

package/dest/utils/block_creation.d.ts

@@ -0,0 +1,13 @@
+import { Fr } from '@aztec/foundation/fields';
+import { L2BlockHeader } from '@aztec/stdlib/block';
+import { type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */
+export declare function getSingleTxBlockRequestHash(blockNumber: number): Fr;
+export declare function insertTxEffectIntoWorldTrees(txEffect: TxEffect, worldTrees: MerkleTreeWriteOperations): Promise<void>;
+export declare function makeTXEBlockHeader(worldTrees: MerkleTreeWriteOperations, globalVariables: GlobalVariables): Promise<L2BlockHeader>;
+//# sourceMappingURL=block_creation.d.ts.map

package/dest/utils/block_creation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_creation.d.ts","sourceRoot":"","sources":["../../src/utils/block_creation.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAwC,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC3G,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,GAAG,EAAE,CAEnE;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,yBAAyB,GACpC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,GAC/B,OAAO,CAAC,aAAa,CAAC,CAaxB"}

package/dest/utils/block_creation.js

@@ -0,0 +1,24 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { L2BlockHeader } from '@aztec/stdlib/block';
+import { makeContentCommitment } from '@aztec/stdlib/testing';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
+ * @param blockNumber The number for the block in which there is a single transaction.
+ * @returns The transaction request hash.
+ */ export function getSingleTxBlockRequestHash(blockNumber) {
+    return new Fr(blockNumber + 9999); // Why does this need to be a high number? Why do small numbered nullifiers already exist?
+}
+export async function insertTxEffectIntoWorldTrees(txEffect, worldTrees) {
+    await worldTrees.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
+    await worldTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+    await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padArrayEnd(txEffect.l2ToL1Msgs, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+// We do not need to add public data writes because we apply them as we go.
+}
+export async function makeTXEBlockHeader(worldTrees, globalVariables) {
+    const stateReference = await worldTrees.getStateReference();
+    const archiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+    return new L2BlockHeader(new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)), makeContentCommitment(), stateReference, globalVariables, Fr.ZERO, Fr.ZERO, Fr.ZERO);
+}

package/dest/utils/tx_effect_creation.d.ts

@@ -0,0 +1,5 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
+import { TxEffect } from '@aztec/stdlib/tx';
+export declare function makeTxEffect(noteCache: ExecutionNoteCache, txRequestHash: Fr, txBlockNumber: number): Promise<TxEffect>;
+//# sourceMappingURL=tx_effect_creation.d.ts.map

package/dest/utils/tx_effect_creation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_effect_creation.d.ts","sourceRoot":"","sources":["../../src/utils/tx_effect_creation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EAAE,QAAQ,EAAU,MAAM,kBAAkB,CAAC;AAEpD,wBAAsB,YAAY,CAChC,SAAS,EAAE,kBAAkB,EAC7B,aAAa,EAAE,EAAE,EACjB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,QAAQ,CAAC,CA2BnB"}

package/dest/utils/tx_effect_creation.js

@@ -0,0 +1,16 @@
+import { Fr } from '@aztec/foundation/fields';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+export async function makeTxEffect(noteCache, txRequestHash, txBlockNumber) {
+    const txEffect = TxEffect.empty();
+    const { usedTxRequestHashForNonces } = noteCache.finish();
+    const nonceGenerator = usedTxRequestHashForNonces ? txRequestHash : noteCache.getAllNullifiers()[0];
+    txEffect.noteHashes = await Promise.all(noteCache.getAllNotes().map(async (pendingNote, i)=>computeUniqueNoteHash(await computeNoteHashNonce(nonceGenerator, i), await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption))));
+    // Nullifiers are already siloed
+    txEffect.nullifiers = noteCache.getAllNullifiers();
+    if (usedTxRequestHashForNonces) {
+        txEffect.nullifiers.unshift(txRequestHash);
+    }
+    txEffect.txHash = new TxHash(new Fr(txBlockNumber));
+    return txEffect;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "2.1.0-rc.9",
+  "version": "3.0.0-devnet.2",
   "type": "module",
   "exports": "./dest/index.js",
   "bin": "./dest/bin/index.js",
@@ -61,20 +61,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "2.1.0-rc.9",
-    "@aztec/archiver": "2.1.0-rc.9",
-    "@aztec/aztec-node": "2.1.0-rc.9",
-    "@aztec/aztec.js": "2.1.0-rc.9",
-    "@aztec/bb-prover": "2.1.0-rc.9",
-    "@aztec/constants": "2.1.0-rc.9",
-    "@aztec/foundation": "2.1.0-rc.9",
-    "@aztec/key-store": "2.1.0-rc.9",
-    "@aztec/kv-store": "2.1.0-rc.9",
-    "@aztec/protocol-contracts": "2.1.0-rc.9",
-    "@aztec/pxe": "2.1.0-rc.9",
-    "@aztec/simulator": "2.1.0-rc.9",
-    "@aztec/stdlib": "2.1.0-rc.9",
-    "@aztec/world-state": "2.1.0-rc.9",
+    "@aztec/accounts": "3.0.0-devnet.2",
+    "@aztec/archiver": "3.0.0-devnet.2",
+    "@aztec/aztec-node": "3.0.0-devnet.2",
+    "@aztec/aztec.js": "3.0.0-devnet.2",
+    "@aztec/bb-prover": "3.0.0-devnet.2",
+    "@aztec/constants": "3.0.0-devnet.2",
+    "@aztec/foundation": "3.0.0-devnet.2",
+    "@aztec/key-store": "3.0.0-devnet.2",
+    "@aztec/kv-store": "3.0.0-devnet.2",
+    "@aztec/protocol-contracts": "3.0.0-devnet.2",
+    "@aztec/pxe": "3.0.0-devnet.2",
+    "@aztec/simulator": "3.0.0-devnet.2",
+    "@aztec/stdlib": "3.0.0-devnet.2",
+    "@aztec/world-state": "3.0.0-devnet.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package/src/bin/index.ts

@@ -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';

package/src/index.ts

@@ -1,14 +1,12 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
+import { type NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
-  AztecAddress,
   type ContractInstanceWithAddress,
-  Fr,
-  type NoirCompiledContract,
-  PublicKeys,
-  deriveKeys,
   getContractInstanceFromInstantiationParams,
-  loadContractArtifact,
-} from '@aztec/aztec.js';
+} 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 type { Logger } from '@aztec/foundation/log';
 import { type ProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
@@ -55,7 +53,6 @@ type TXEForeignCallInput = {
   inputs: ForeignCallArgs;
 };
 
-// TODO: why does the zod validation in the txe dispatcher not reject invalid function names?
 const TXEForeignCallInputSchema = z.object({
   // eslint-disable-next-line camelcase
   session_id: z.number().int().nonnegative(),