@aztec-labs/txe 6.0.0-nightly.20260829

package/src/utils/block_creation.ts

@@ -0,0 +1,91 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec-labs/constants';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec-labs/foundation/branded-types';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { Body, L2Block } from '@aztec-labs/stdlib/block';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec-labs/stdlib/trees';
+import { BlockHeader, GlobalVariables, TxEffect } from '@aztec-labs/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 function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr {
+  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: TxEffect,
+  worldTrees: MerkleTreeWriteOperations,
+  l1ToL2Messages: Fr[] = [],
+): Promise<void> {
+  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,
+  );
+
+  // Append the block's real message leaves unpadded at compact indices.
+  await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+
+  // We do not need to add public data writes because we apply them as we go.
+}
+
+export async function makeTXEBlockHeader(
+  worldTrees: MerkleTreeWriteOperations,
+  globalVariables: GlobalVariables,
+): Promise<BlockHeader> {
+  const stateReference = await worldTrees.getStateReference();
+  const archiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+  return BlockHeader.from({
+    lastArchive: new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+    spongeBlobHash: Fr.ZERO,
+    state: stateReference,
+    globalVariables,
+    totalFees: Fr.ZERO,
+    totalManaUsed: Fr.ZERO,
+  });
+}
+
+/**
+ * Creates an L2Block with proper archive chaining.
+ * This function:
+ * 1. Gets the current archive state as lastArchive for the header
+ * 2. Creates the block header
+ * 3. Updates the archive tree with the header hash
+ * 4. Gets the new archive state for the block's archive
+ *
+ * @param worldTrees - The world trees to read/write from
+ * @param globalVariables - Global variables for the block
+ * @param txEffects - Transaction effects to include in the block
+ * @returns The created L2Block with proper archive chaining
+ */
+export async function makeTXEBlock(
+  worldTrees: MerkleTreeWriteOperations,
+  globalVariables: GlobalVariables,
+  txEffects: TxEffect[],
+): Promise<L2Block> {
+  const header = await makeTXEBlockHeader(worldTrees, globalVariables);
+
+  // Update the archive tree with this block's header hash
+  await worldTrees.updateArchive(header);
+
+  // Get the new archive state after updating
+  const newArchiveInfo = await worldTrees.getTreeInfo(MerkleTreeId.ARCHIVE);
+  const newArchive = new AppendOnlyTreeSnapshot(new Fr(newArchiveInfo.root), Number(newArchiveInfo.size));
+
+  // L2Block requires checkpointNumber and indexWithinCheckpoint.
+  // TXE uses 1-block-per-checkpoint for testing simplicity, so we can use block number as checkpoint number.
+  // This uses the deprecated fromBlockNumber method intentionally for the TXE testing environment.
+  const checkpointNumber = CheckpointNumber.fromBlockNumber(globalVariables.blockNumber);
+  const indexWithinCheckpoint = IndexWithinCheckpoint(0);
+
+  return new L2Block(newArchive, header, new Body(txEffects), checkpointNumber, indexWithinCheckpoint);
+}

package/src/utils/encoding.ts

@@ -0,0 +1,171 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { hexToBuffer } from '@aztec-labs/foundation/string';
+import { type ContractArtifact, ContractArtifactSchema } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { BlockHash } from '@aztec-labs/stdlib/block';
+import { type ContractInstanceWithAddress, ContractInstanceWithAddressSchema } from '@aztec-labs/stdlib/contract';
+import { z } from 'zod';
+
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallArgs = (ForeignCallSingle | ForeignCallArray | ContractArtifact | ContractInstanceWithAddress)[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+
+export function fromSingle(obj: ForeignCallSingle) {
+  return Fr.fromBuffer(Buffer.from(obj, 'hex'));
+}
+
+export function addressFromSingle(obj: ForeignCallSingle) {
+  return new AztecAddress(fromSingle(obj));
+}
+
+export function blockHashFromSingle(obj: ForeignCallSingle) {
+  return new BlockHash(fromSingle(obj));
+}
+
+export function fromArray(obj: ForeignCallArray) {
+  return obj.map(str => Fr.fromBuffer(hexToBuffer(str)));
+}
+
+/**
+ * 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 A buffer where each byte is correctly represented as a single byte in the buffer.
+ */
+export function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
+}
+
+/**
+ * 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: ForeignCallArray, length: ForeignCallSingle, uintBitSize: number): Buffer {
+  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: AztecAddress | EthAddress | Fr | Buffer | boolean | number | bigint,
+): ForeignCallSingle {
+  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: Fr[]): ForeignCallArray {
+  return objs.map(obj => obj.toString());
+}
+
+export function toSingleOrArray(value: Fr | Fr[]) {
+  return Array.isArray(value) ? value.map(toSingle) : toSingle(value);
+}
+
+export function bufferToU8Array(buffer: Buffer): ForeignCallArray {
+  return toArray(Array.from(buffer).map(byte => new Fr(byte)));
+}
+
+/**
+ * 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 bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export function arrayToBoundedVec(
+  bVecStorage: ForeignCallArray,
+  maxLen: number,
+): [ForeignCallArray, ForeignCallSingle] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+  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 = 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: ForeignCallArray[],
+  maxLen: number,
+  nestedArrayLength: number,
+): [ForeignCallArray, ForeignCallSingle] {
+  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;
+
+  // Pad with hex-encoded zeros so the result is uniformly `ForeignCallSingle` (string); raw Fr
+  // instances would JSON-serialize as `{ asBigInt: "0" }` and nargo would reject the response.
+  const flattenedStorageWithPadding = flattenedStorage.concat(toArray(Array(numFieldsToPad).fill(new Fr(0))));
+
+  const len = toSingle(new Fr(bVecStorage.length));
+  return [flattenedStorageWithPadding, len];
+}
+
+export function toForeignCallResult(obj: (ForeignCallSingle | ForeignCallArray)[]) {
+  return { values: obj };
+}
+
+export const ForeignCallSingleSchema = z.string();
+
+export const ForeignCallArraySchema = z.array(z.string());
+
+export const ForeignCallArgsSchema = z.array(
+  z.union([ForeignCallSingleSchema, ForeignCallArraySchema, ContractArtifactSchema, ContractInstanceWithAddressSchema]),
+);
+
+export const ForeignCallResultSchema = z.object({
+  values: z.array(z.union([ForeignCallSingleSchema, ForeignCallArraySchema])),
+});

package/src/utils/expected_failure_error.ts

@@ -0,0 +1,5 @@
+export class ExpectedFailureError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}

package/src/utils/tx_effect_creation.ts

@@ -0,0 +1,28 @@
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { ExecutionNoteCache } from '@aztec-labs/pxe/simulator';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec-labs/stdlib/hash';
+import { TxEffect, TxHash } from '@aztec-labs/stdlib/tx';
+
+export async function makeTxEffect(noteCache: ExecutionNoteCache, txBlockNumber: BlockNumber): Promise<TxEffect> {
+  const txEffect = TxEffect.empty();
+
+  const nonceGenerator = noteCache.getNonceGenerator();
+  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();
+
+  txEffect.txHash = new TxHash(new Fr(txBlockNumber));
+
+  return txEffect;
+}

package/src/utils/txe_account_store.ts

@@ -0,0 +1,23 @@
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec-labs/kv-store';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec-labs/stdlib/contract';
+
+export class TXEAccountStore {
+  #accounts: AztecAsyncMap<string, Buffer>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#accounts = store.openMap('accounts');
+  }
+
+  async getAccount(key: AztecAddress) {
+    const completeAddress = await this.#accounts.getAsync(key.toString());
+    if (!completeAddress) {
+      throw new Error(`Account not found: ${key.toString()}`);
+    }
+    return CompleteAddress.fromBuffer(completeAddress);
+  }
+
+  async setAccount(key: AztecAddress, value: CompleteAddress) {
+    await this.#accounts.set(key.toString(), value.toBuffer());
+  }
+}

package/src/utils/txe_artifact_resolver.ts

@@ -0,0 +1,217 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import type { ContractStore } from '@aztec-labs/pxe/client/lazy';
+import { loadContractArtifact } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import {
+  type ContractArtifactWithHash,
+  type ContractInstanceWithAddress,
+  computeArtifactHash,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec-labs/stdlib/contract';
+import { PublicKeys, deriveKeys } from '@aztec-labs/stdlib/keys';
+import type { NoirCompiledContract } from '@aztec-labs/stdlib/noir';
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
+import { readFile, readdir } from 'fs/promises';
+import { join, parse } from 'path';
+
+export interface ResolvedArtifact {
+  artifact: ContractArtifactWithHash;
+  instance: ContractInstanceWithAddress;
+}
+
+/**
+ * Cache + in-flight map pair. Lookup hits the cache, then awaits an in-flight `compute()` if one
+ * exists, otherwise starts one and stores it. Guarantees `compute()` runs at most once per `key`
+ * across concurrent callers, which matters because `computeArtifactHash` is expensive.
+ */
+class AsyncCache<K, V> {
+  #cache = new Map<K, V>();
+  #inFlight = new Map<K, Promise<V>>();
+
+  getOrCompute(key: K, compute: () => Promise<V>): Promise<V> {
+    const cached = this.#cache.get(key);
+    if (cached !== undefined) {
+      return Promise.resolve(cached);
+    }
+    let pending = this.#inFlight.get(key);
+    if (!pending) {
+      pending = (async () => {
+        try {
+          const value = await compute();
+          this.#cache.set(key, value);
+          return value;
+        } finally {
+          this.#inFlight.delete(key);
+        }
+      })();
+      this.#inFlight.set(key, pending);
+    }
+    return pending;
+  }
+}
+
+/**
+ * Resolves and caches contract artifacts and their associated instances.
+ *
+ * Artifact hash computation is expensive, so this service deduplicates both completed and in-flight computations.
+ * Two cache levels are kept: full deploys (artifact + computed instance) keyed by the full deploy context, and loaded +
+ * hashed artifacts keyed by the compiled-bytecode hash so deploys of the same contract with different args / salt /
+ * deployer reuse the same `ContractArtifactWithHash`.
+ */
+export class TXEArtifactResolver {
+  #deployments = new AsyncCache<string, ResolvedArtifact>();
+  #artifacts = new AsyncCache<string, ContractArtifactWithHash>();
+  #logger = createLogger('txe:artifact_resolver');
+
+  constructor(
+    private readonly contractStore: ContractStore,
+    private readonly schnorrClassId: Fr,
+  ) {}
+
+  /** Resolves the Schnorr account contract artifact and instance for the given secret, caching the result. */
+  resolveAccountArtifact(secret: Fr): Promise<ResolvedArtifact> {
+    return this.#deployments.getOrCompute(`SchnorrAccountContract-${secret}`, () =>
+      this.#computeAccountArtifact(secret),
+    );
+  }
+
+  /** Resolves a contract artifact from disk by path, computes its instance, and caches the result. */
+  async resolveDeployArtifact({
+    rootPath,
+    packageName,
+    contractPath,
+    initializer,
+    args,
+    secret,
+    salt,
+    deployer,
+  }: {
+    rootPath: string;
+    packageName: string;
+    contractPath: string;
+    initializer: string;
+    args: Fr[];
+    secret: Fr;
+    salt: Fr;
+    deployer: AztecAddress;
+  }): Promise<ResolvedArtifact> {
+    const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
+    const publicKeysHash = await publicKeys.hash();
+
+    const artifactPath = await this.#resolveArtifactPath(rootPath, packageName, contractPath);
+    const fileHash = await this.#fastHashFile(artifactPath);
+
+    const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+    const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${args
+      .map(arg => arg.toString())
+      .join('-')}-${publicKeysHash}-${salt}-${deployer}-${fileHash}`;
+
+    return this.#deployments.getOrCompute(cacheKey, () =>
+      this.#computeDeployArtifact(
+        artifactPath,
+        fileHash,
+        initializer,
+        args,
+        salt,
+        publicKeys,
+        publicKeysHash,
+        deployer,
+      ),
+    );
+  }
+
+  async #resolveArtifactPath(rootPath: string, packageName: string, contractPath: string): Promise<string> {
+    const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+    if (contractDirectory) {
+      if (contractDirectory.includes('@')) {
+        // 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}`);
+        return join(targetPath, `${pkg}-${contractFilename}.json`);
+      } else {
+        // env.deploy("../path/to/contract/root/contractName")
+        const targetPath = join(rootPath, contractDirectory, '/target');
+        this.#logger.debug(`Looking for compiled artifact in ${targetPath}`);
+        const [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractFilename}.json`));
+        return artifactPath;
+      }
+    } else {
+      // env.deploy("contractName")
+      return join(rootPath, './target', `${packageName}-${contractFilename}.json`);
+    }
+  }
+
+  async #computeAccountArtifact(secret: Fr): Promise<ResolvedArtifact> {
+    const [artifactFromStore, classWithPreimage] = await Promise.all([
+      this.contractStore.getContractArtifact(this.schnorrClassId),
+      this.contractStore.getContractClassWithPreimage(this.schnorrClassId),
+    ]);
+    if (!artifactFromStore || !classWithPreimage) {
+      throw new Error(
+        `SchnorrAccount not found in shared contract store at class id ${this.schnorrClassId.toString()}`,
+      );
+    }
+    const artifact: ContractArtifactWithHash = { ...artifactFromStore, artifactHash: classWithPreimage.artifactHash };
+    const keys = await deriveKeys(secret);
+    const args = [keys.publicKeys.ivpkM.x, keys.publicKeys.ivpkM.y];
+    const instance = await getContractInstanceFromInstantiationParams(artifact, {
+      constructorArgs: args,
+      skipArgsDecoding: true,
+      salt: Fr.ONE,
+      publicKeys: keys.publicKeys,
+      constructorArtifact: 'constructor',
+      deployer: AztecAddress.ZERO,
+    });
+    return { artifact, instance };
+  }
+
+  async #computeDeployArtifact(
+    artifactPath: string,
+    fileHash: string,
+    initializer: string,
+    args: Fr[],
+    salt: Fr,
+    publicKeys: PublicKeys,
+    publicKeysHash: Fr,
+    deployer: AztecAddress,
+  ): Promise<ResolvedArtifact> {
+    // Inner cache: artifact load + hash depends only on the compiled bytecode (`fileHash`), so subsequent deploys of
+    // the same contract — regardless of constructor args / deployer / salt — reuse the same `ContractArtifactWithHash`.
+    const artifact = await this.#artifacts.getOrCompute(fileHash, async () => {
+      this.#logger.debug(`Loading compiled artifact ${artifactPath}`);
+      const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8')) as NoirCompiledContract;
+      const artifactWithoutHash = loadContractArtifact(artifactJSON);
+      return { ...artifactWithoutHash, artifactHash: await computeArtifactHash(artifactWithoutHash) };
+    });
+    this.#logger.debug(
+      `Deploy ${artifact.name} with initializer ${initializer}(${args}) and public keys hash ${publicKeysHash}`,
+    );
+    const instance = await getContractInstanceFromInstantiationParams(artifact, {
+      constructorArgs: args,
+      skipArgsDecoding: true,
+      salt,
+      publicKeys,
+      constructorArtifact: initializer || undefined,
+      deployer,
+    });
+    return { artifact, instance };
+  }
+
+  #fastHashFile(path: string): Promise<string> {
+    return new Promise(resolve => {
+      const fd = createReadStream(path);
+      const hash = createHash('sha1');
+      hash.setEncoding('hex');
+
+      fd.on('end', function () {
+        hash.end();
+        resolve(hash.read() as string);
+      });
+
+      fd.pipe(hash);
+    });
+  }
+}

package/src/utils/txe_public_contract_data_source.ts

@@ -0,0 +1,60 @@
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { ContractStore } from '@aztec-labs/pxe/server';
+import { type ContractArtifact, FunctionSelector } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+
+export class TXEPublicContractDataSource implements ContractDataSource {
+  constructor(
+    private blockNumber: BlockNumber,
+    private contractStore: ContractStore,
+  ) {}
+
+  getBlockNumber(): Promise<BlockNumber> {
+    return Promise.resolve(this.blockNumber);
+  }
+
+  async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    const contractClass = await this.contractStore.getContractClassWithPreimage(id);
+    if (!contractClass) {
+      return;
+    }
+    return {
+      id: contractClass.id,
+      artifactHash: contractClass.artifactHash,
+      packedBytecode: contractClass.packedBytecode,
+      privateFunctionsRoot: contractClass.privateFunctionsRoot,
+      version: contractClass.version,
+    };
+  }
+
+  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
+    const contractClass = await this.contractStore.getContractClassWithPreimage(id);
+    return contractClass?.publicBytecodeCommitment;
+  }
+
+  async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const instance = await this.contractStore.getContractInstance(address);
+    // TXE has no contract updates, so the current class always equals the original.
+    return instance && { ...instance, address, currentContractClassId: instance.originalContractClassId };
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
+    const instance = await this.getContract(address);
+    return instance && this.contractStore.getContractArtifact(instance.originalContractClassId);
+  }
+
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    const instance = await this.getContract(address);
+    return instance && this.contractStore.getDebugFunctionName(instance.originalContractClassId, selector);
+  }
+
+  registerContractFunctionSignatures(_signatures: []): Promise<void> {
+    return Promise.resolve();
+  }
+}