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

package/dest/state_machine/synchronizer.js

@@ -0,0 +1,58 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { NativeWorldStateService } from '@aztec/world-state/native';
+export class TXESynchronizer {
+    nativeWorldStateService;
+    // This works when set to 1 as well.
+    blockNumber;
+    constructor(nativeWorldStateService){
+        this.nativeWorldStateService = nativeWorldStateService;
+        this.blockNumber = 0;
+    }
+    static async create() {
+        const nativeWorldStateService = await NativeWorldStateService.tmp();
+        return new this(nativeWorldStateService);
+    }
+    async handleL2Block(block) {
+        await this.nativeWorldStateService.handleL2BlockAndMessages(block, Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero));
+        this.blockNumber = block.header.globalVariables.blockNumber;
+    }
+    /**
+   * Forces an immediate sync to an optionally provided minimum block number
+   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
+   * @returns A promise that resolves with the block number the world state was synced to
+   */ syncImmediate(_minBlockNumber, _skipThrowIfTargetNotReached) {
+        return Promise.resolve(this.blockNumber);
+    }
+    /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */ getCommitted() {
+        return this.nativeWorldStateService.getCommitted();
+    }
+    /** Forks the world state at the given block number, defaulting to the latest one. */ fork(block) {
+        return this.nativeWorldStateService.fork(block);
+    }
+    /** Gets a handle that allows reading the state as it was at the given block number. */ getSnapshot(blockNumber) {
+        return this.nativeWorldStateService.getSnapshot(blockNumber);
+    }
+    /** Backups the db to the target path. */ backupTo(dstPath, compact) {
+        return this.nativeWorldStateService.backupTo(dstPath, compact);
+    }
+    start() {
+        throw new Error('TXE Synchronizer does not implement "start"');
+    }
+    status() {
+        throw new Error('TXE Synchronizer does not implement "status"');
+    }
+    stop() {
+        throw new Error('TXE Synchronizer does not implement "stop"');
+    }
+    stopSync() {
+        throw new Error('TXE Synchronizer does not implement "stopSync"');
+    }
+    resumeSync() {
+        throw new Error('TXE Synchronizer does not implement "resumeSync"');
+    }
+    clear() {
+        throw new Error('TXE Synchronizer does not implement "clear"');
+    }
+}

package/dest/txe_session.d.ts

@@ -0,0 +1,67 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger } from '@aztec/foundation/log';
+import { KeyStore } from '@aztec/key-store';
+import type { ProtocolContract } from '@aztec/protocol-contracts';
+import { AddressDataProvider, PXEOracleInterface } from '@aztec/pxe/server';
+import { type IPrivateExecutionOracle, type IUtilityExecutionOracle } from '@aztec/pxe/simulator';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { PrivateContextInputs } from '@aztec/stdlib/kernel';
+import type { UInt32 } from '@aztec/stdlib/types';
+import type { IAvmExecutionOracle, ITxeExecutionOracle } from './oracle/interfaces.js';
+import { RPCTranslator } from './rpc_translator.js';
+import { TXEStateMachine } from './state_machine/index.js';
+import type { ForeignCallArgs, ForeignCallResult } from './util/encoding.js';
+import { TXEAccountDataProvider } from './util/txe_account_data_provider.js';
+import { TXEContractDataProvider } from './util/txe_contract_data_provider.js';
+type MethodNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+/**
+ * The name of an oracle function that TXE supports, which are a combination of PXE oracles, non-transpiled AVM opcodes,
+ * and custom TXE oracles.
+ */
+export type TXEOracleFunctionName = Exclude<MethodNames<RPCTranslator>, 'constructor' | 'handlerAsMisc' | 'handlerAsUtility' | 'handlerAsPrivate' | 'handlerAsAvm' | 'handlerAsTxe'>;
+export interface TXESessionStateHandler {
+    enterTopLevelState(): Promise<void>;
+    enterPublicState(contractAddress?: AztecAddress): Promise<void>;
+    enterPrivateState(contractAddress?: AztecAddress, anchorBlockNumber?: UInt32): Promise<PrivateContextInputs>;
+    enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
+}
+/**
+ * A `TXESession` corresponds to a Noir `#[test]` function, and handles all of its oracle calls, stores test-specific
+ * state, etc., independent of all other tests running in parallel.
+ */
+export declare class TXESession implements TXESessionStateHandler {
+    private logger;
+    private stateMachine;
+    private oracleHandler;
+    private contractDataProvider;
+    private keyStore;
+    private addressDataProvider;
+    private accountDataProvider;
+    private chainId;
+    private version;
+    private nextBlockTimestamp;
+    private pxeOracleInterface;
+    private state;
+    private authwits;
+    constructor(logger: Logger, stateMachine: TXEStateMachine, oracleHandler: IUtilityExecutionOracle | IPrivateExecutionOracle | IAvmExecutionOracle | ITxeExecutionOracle, contractDataProvider: TXEContractDataProvider, keyStore: KeyStore, addressDataProvider: AddressDataProvider, accountDataProvider: TXEAccountDataProvider, chainId: Fr, version: Fr, nextBlockTimestamp: bigint, pxeOracleInterface: PXEOracleInterface);
+    static init(protocolContracts: ProtocolContract[]): Promise<TXESession>;
+    /**
+     * Processes an oracle function invoked by the Noir test associated to this session.
+     * @param functionName The name of the oracle.
+     * @param inputs The inputs of the oracle.
+     * @returns The oracle return values.
+     */
+    processFunction(functionName: TXEOracleFunctionName, inputs: ForeignCallArgs): Promise<ForeignCallResult>;
+    enterTopLevelState(): Promise<void>;
+    enterPrivateState(contractAddress?: AztecAddress, anchorBlockNumber?: UInt32): Promise<PrivateContextInputs>;
+    enterPublicState(contractAddress?: AztecAddress): Promise<void>;
+    enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
+    private exitTopLevelState;
+    private exitPrivateState;
+    private exitPublicState;
+    private exitUtilityContext;
+}
+export {};
+//# sourceMappingURL=txe_session.d.ts.map

package/dest/txe_session.d.ts.map

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

package/dest/txe_session.js

@@ -0,0 +1,253 @@
+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, 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 { TXEAccountDataProvider } from './util/txe_account_data_provider.js';
+import { TXEContractDataProvider } from './util/txe_contract_data_provider.js';
+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
+ * state, etc., independent of all other tests running in parallel.
+ */ export class TXESession {
+    logger;
+    stateMachine;
+    oracleHandler;
+    contractDataProvider;
+    keyStore;
+    addressDataProvider;
+    accountDataProvider;
+    chainId;
+    version;
+    nextBlockTimestamp;
+    pxeOracleInterface;
+    state;
+    authwits;
+    constructor(logger, stateMachine, oracleHandler, contractDataProvider, keyStore, addressDataProvider, accountDataProvider, chainId, version, nextBlockTimestamp, pxeOracleInterface){
+        this.logger = logger;
+        this.stateMachine = stateMachine;
+        this.oracleHandler = oracleHandler;
+        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');
+        const addressDataProvider = new AddressDataProvider(store);
+        const privateEventDataProvider = new PrivateEventDataProvider(store);
+        const contractDataProvider = new TXEContractDataProvider(store);
+        const noteDataProvider = await NoteDataProvider.create(store);
+        const taggingDataProvider = new TaggingDataProvider(store);
+        const capsuleDataProvider = new CapsuleDataProvider(store);
+        const keyStore = new KeyStore(store);
+        const accountDataProvider = new TXEAccountDataProvider(store);
+        // Register protocol contracts.
+        for (const { contractClass, instance, artifact } of protocolContracts){
+            await contractDataProvider.addContractArtifact(contractClass.id, artifact);
+            await contractDataProvider.addContractInstance(instance);
+        }
+        const stateMachine = await TXEStateMachine.create(store);
+        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.
+   * @param functionName The name of the oracle.
+   * @param inputs The inputs of the oracle.
+   * @returns The oracle return values.
+   */ processFunction(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 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.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 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: latestBlockNumber + 1,
+            timestamp: this.nextBlockTimestamp,
+            version: this.version,
+            chainId: this.chainId
+        });
+        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 exitPrivateState() {
+        if (this.state.name != 'PRIVATE') {
+            throw new Error(`Expected to be in state 'PRIVATE', but got '${this.state.name}' instead`);
+        }
+        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
+        });
+    }
+    async exitPublicState() {
+        if (this.state.name != 'PUBLIC') {
+            throw new Error(`Expected to be in state 'PUBLIC', but got '${this.state.name}' instead`);
+        }
+        const block = await this.oracleHandler.close();
+        await this.stateMachine.handleL2Block(block);
+    }
+    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

@@ -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';
@@ -17,21 +16,40 @@ export declare function fromArray(obj: ForeignCallArray): Fr[];
 /**
  * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
  * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
- * @returns
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
  */
 export declare function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffer;
-export declare function toSingle(obj: Fr | AztecAddress): ForeignCallSingle;
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ForeignCallArray and ForeignCallSingle values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */
+export declare function fromUintBoundedVec(storage: ForeignCallArray, length: ForeignCallSingle, uintBitSize: number): Buffer;
+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;
 /**
  * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
  * If the input array is shorter than the maxLen, it pads the result with zeros,
  * so that nr can correctly coerce this result into a BoundedVec.
- * @param array
+ * @param bVecStorage - The array underlying the BoundedVec.
  * @param maxLen - the max length of the BoundedVec.
  * @returns a tuple representing a BoundedVec.
  */
-export declare function arrayToBoundedVec(array: ForeignCallArray, maxLen: number): [ForeignCallArray, ForeignCallSingle];
+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)[];
 };
@@ -59,7 +77,7 @@ export declare const ForeignCallArgsSchema: z.ZodArray<z.ZodUnion<[z.ZodString,
         masterIncomingViewingPublicKey: string;
         masterOutgoingViewingPublicKey: string;
         masterTaggingPublicKey: string;
-    }>, import("@aztec/aztec.js").PublicKeys, {
+    }>, import("@aztec/stdlib/keys").PublicKeys, {
         masterNullifierPublicKey: string;
         masterIncomingViewingPublicKey: string;
         masterOutgoingViewingPublicKey: string;
@@ -72,7 +90,7 @@ export declare const ForeignCallArgsSchema: z.ZodArray<z.ZodUnion<[z.ZodString,
     currentContractClassId: Fr;
     originalContractClassId: Fr;
     initializationHash: Fr;
-    publicKeys: import("@aztec/aztec.js").PublicKeys;
+    publicKeys: import("@aztec/stdlib/keys").PublicKeys;
 }, {
     version: 1;
     publicKeys: {

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,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,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAEhE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAYhH;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"}

package/dest/util/encoding.js

@@ -16,7 +16,7 @@ export function fromArray(obj) {
 /**
  * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
  * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
- * @returns
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
  */ export function fromUintArray(obj, uintBitSize) {
     if (uintBitSize % 8 !== 0) {
         throw new Error(`u${uintBitSize} is not a supported type in Noir`);
@@ -24,12 +24,43 @@ export function fromArray(obj) {
     const uintByteSize = uintBitSize / 8;
     return Buffer.concat(obj.map((str)=>hexToBuffer(str).slice(-uintByteSize)));
 }
-export function toSingle(obj) {
-    return obj.toString().slice(2);
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ForeignCallArray and ForeignCallSingle values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */ export function fromUintBoundedVec(storage, length, uintBitSize) {
+    if (uintBitSize % 8 !== 0) {
+        throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+    }
+    const uintByteSize = uintBitSize / 8;
+    const boundedStorage = storage.slice(0, fromSingle(length).toNumber());
+    return Buffer.concat(boundedStorage.map((str)=>hexToBuffer(str).slice(-uintByteSize)));
+}
+// Just like toACVMField in yarn-project/simulator/src/private/acvm/serialize.ts but returns a ForeignCallSingle
+// instead of an ACVMField.
+export function toSingle(value) {
+    let valueAsField;
+    if (Buffer.isBuffer(value)) {
+        valueAsField = Fr.fromBuffer(value);
+    } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+        valueAsField = new Fr(value);
+    } else if (typeof value === 'string') {
+        valueAsField = Fr.fromHexString(value);
+    } else {
+        valueAsField = value;
+    }
+    return valueAsField.toString().slice(2);
 }
 export function toArray(objs) {
     return objs.map((obj)=>obj.toString());
 }
+export function toSingleOrArray(value) {
+    return Array.isArray(value) ? value.map(toSingle) : toSingle(value);
+}
 export function bufferToU8Array(buffer) {
     return toArray(Array.from(buffer).map((byte)=>new Fr(byte)));
 }
@@ -37,24 +68,48 @@ export function bufferToU8Array(buffer) {
  * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
  * If the input array is shorter than the maxLen, it pads the result with zeros,
  * so that nr can correctly coerce this result into a BoundedVec.
- * @param array
+ * @param bVecStorage - The array underlying the BoundedVec.
  * @param maxLen - the max length of the BoundedVec.
  * @returns a tuple representing a BoundedVec.
- */ export function arrayToBoundedVec(array, maxLen) {
-    if (array.length > maxLen) {
-        throw new Error(`Array of length ${array.length} larger than maxLen ${maxLen}`);
+ */ export function arrayToBoundedVec(bVecStorage, maxLen) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
     }
-    const lengthDiff = maxLen - array.length;
+    const lengthDiff = maxLen - bVecStorage.length;
     // We pad the array to the maxLen of the BoundedVec.
     const zeroPaddingArray = toArray(Array(lengthDiff).fill(new Fr(0)));
     // These variable names match with the BoundedVec members in nr:
-    const storage = array.concat(zeroPaddingArray);
-    const len = toSingle(new Fr(array.length));
+    const storage = bVecStorage.concat(zeroPaddingArray);
+    const len = toSingle(new Fr(bVecStorage.length));
     return [
         storage,
         len
     ];
 }
+/**
+ * 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 function arrayOfArraysToBoundedVecOfArrays(bVecStorage, maxLen, nestedArrayLength) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+    }
+    // Check that all nested arrays have length nestedArrayLength
+    if (!bVecStorage.every((nestedArray)=>nestedArray.length === nestedArrayLength)) {
+        throw new Error(`Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`);
+    }
+    const flattenedStorage = bVecStorage.flat();
+    const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+    const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(new Fr(0)));
+    // At last we get the actual length of the BoundedVec and return the values.
+    const len = toSingle(new Fr(bVecStorage.length));
+    return [
+        flattenedStorageWithPadding,
+        len
+    ];
+}
 export function toForeignCallResult(obj) {
     return {
         values: obj

package/dest/util/txe_contract_data_provider.d.ts

@@ -0,0 +1,12 @@
+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;
+};
+export declare class TXEContractDataProvider extends ContractDataProvider {
+    #private;
+    addContractArtifact(id: Fr, artifact: ContractArtifact | ContractArtifactWithHash): Promise<void>;
+    getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | ContractArtifactWithHash | undefined>;
+}
+//# sourceMappingURL=txe_contract_data_provider.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+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
+ * TXE typically deploys the same contract again and again for multiple tests, caching
+ * the *very* expensive artifact hash computation improves testing speed significantly.
+ */ export class TXEContractDataProvider extends ContractDataProvider {
+    #artifactHashes = new Map();
+    async addContractArtifact(id, artifact) {
+        if ('artifactHash' in artifact) {
+            this.#artifactHashes.set(id.toString(), artifact.artifactHash.toBuffer());
+        }
+        await super.addContractArtifact(id, artifact);
+    }
+    async getContractArtifact(contractClassId) {
+        const artifact = await super.getContractArtifact(contractClassId);
+        if (artifact && this.#artifactHashes.has(contractClassId.toString())) {
+            artifact.artifactHash = Fr.fromBuffer(this.#artifactHashes.get(contractClassId.toString()));
+        }
+        return artifact;
+    }
+}

package/dest/util/txe_public_contract_data_source.d.ts

@@ -1,20 +1,20 @@
 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, type PublicFunction } from '@aztec/stdlib/contract';
-import type { TXE } from '../oracle/txe_oracle.js';
+import { type ContractClassPublic, type ContractDataSource, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 export declare class TXEPublicContractDataSource implements ContractDataSource {
-    private txeOracle;
-    constructor(txeOracle: TXE);
-    getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined>;
+    #private;
+    private blockNumber;
+    private contractDataProvider;
+    constructor(blockNumber: number, contractDataProvider: ContractDataProvider);
     getBlockNumber(): Promise<number>;
     getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
     getBytecodeCommitment(id: Fr): Promise<Fr | undefined>;
     getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
     getContractClassIds(): Promise<Fr[]>;
     getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined>;
-    getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
-    registerContractFunctionSignatures(_address: AztecAddress, _signatures: []): Promise<void>;
-    addContractClass(_contractClass: ContractClassPublic): Promise<void>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    registerContractFunctionSignatures(_signatures: []): Promise<void>;
 }
 //# sourceMappingURL=txe_public_contract_data_source.d.ts.map