@aztec/txe 0.0.0-test.0

package/dest/util/encoding.js

@@ -0,0 +1,76 @@
+import { Fr } from '@aztec/foundation/fields';
+import { hexToBuffer } from '@aztec/foundation/string';
+import { ContractArtifactSchema } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
+import { z } from 'zod';
+export function fromSingle(obj) {
+    return Fr.fromBuffer(Buffer.from(obj, 'hex'));
+}
+export function addressFromSingle(obj) {
+    return new AztecAddress(fromSingle(obj));
+}
+export function fromArray(obj) {
+    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
+ */ export function fromUintArray(obj, uintBitSize) {
+    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)));
+}
+export function toSingle(obj) {
+    return obj.toString().slice(2);
+}
+export function toArray(objs) {
+    return objs.map((obj)=>obj.toString());
+}
+export function bufferToU8Array(buffer) {
+    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 array
+ * @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}`);
+    }
+    const lengthDiff = maxLen - array.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));
+    return [
+        storage,
+        len
+    ];
+}
+export function toForeignCallResult(obj) {
+    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/dest/util/expected_failure_error.d.ts

@@ -0,0 +1,4 @@
+export declare class ExpectedFailureError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=expected_failure_error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expected_failure_error.d.ts","sourceRoot":"","sources":["../../src/util/expected_failure_error.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAG5B"}

package/dest/util/expected_failure_error.js

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

package/dest/util/txe_account_data_provider.d.ts

@@ -0,0 +1,10 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+export declare class TXEAccountDataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    getAccount(key: AztecAddress): Promise<CompleteAddress>;
+    setAccount(key: AztecAddress, value: CompleteAddress): Promise<void>;
+}
+//# sourceMappingURL=txe_account_data_provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txe_account_data_provider.d.ts","sourceRoot":"","sources":["../../src/util/txe_account_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,sBAAsB;;gBAGrB,KAAK,EAAE,iBAAiB;IAI9B,UAAU,CAAC,GAAG,EAAE,YAAY;IAQ5B,UAAU,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,eAAe;CAG3D"}

package/dest/util/txe_account_data_provider.js

@@ -0,0 +1,17 @@
+import { CompleteAddress } from '@aztec/stdlib/contract';
+export class TXEAccountDataProvider {
+    #accounts;
+    constructor(store){
+        this.#accounts = store.openMap('accounts');
+    }
+    async getAccount(key) {
+        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, value) {
+        await this.#accounts.set(key.toString(), value.toBuffer());
+    }
+}

package/dest/util/txe_public_contract_data_source.d.ts

@@ -0,0 +1,20 @@
+import { Fr } from '@aztec/foundation/fields';
+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';
+export declare class TXEPublicContractDataSource implements ContractDataSource {
+    private txeOracle;
+    constructor(txeOracle: TXE);
+    getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined>;
+    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>;
+}
+//# sourceMappingURL=txe_public_contract_data_source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txe_public_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/util/txe_public_contract_data_source.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,cAAc,EAEpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,qBAAa,2BAA4B,YAAW,kBAAkB;IACxD,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,GAAG;IAE5B,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAQ/G,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAI3B,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IA0BlE,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,uBAAuB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAgB7G,kCAAkC,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1F,gBAAgB,CAAC,cAAc,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAIrE"}

package/dest/util/txe_public_contract_data_source.js

@@ -0,0 +1,88 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { PrivateFunctionsTree } from '@aztec/pxe/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+export class TXEPublicContractDataSource {
+    txeOracle;
+    constructor(txeOracle){
+        this.txeOracle = txeOracle;
+    }
+    async getPublicFunction(address, selector) {
+        const bytecode = await this.txeOracle.getContractDataProvider().getBytecode(address, selector);
+        if (!bytecode) {
+            return undefined;
+        }
+        return {
+            bytecode,
+            selector
+        };
+    }
+    getBlockNumber() {
+        return this.txeOracle.getBlockNumber();
+    }
+    async getContractClass(id) {
+        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+        const artifact = await this.txeOracle.getContractDataProvider().getContractArtifact(id);
+        const tree = await PrivateFunctionsTree.create(artifact);
+        const privateFunctionsRoot = await tree.getFunctionTreeRoot();
+        const publicFunctions = [];
+        if (contractClass.packedBytecode.length > 0) {
+            publicFunctions.push({
+                selector: FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+                bytecode: contractClass.packedBytecode
+            });
+        }
+        return {
+            id,
+            artifactHash: contractClass.artifactHash,
+            packedBytecode: contractClass.packedBytecode,
+            publicFunctions: publicFunctions,
+            privateFunctionsRoot: new Fr(privateFunctionsRoot.root),
+            version: contractClass.version,
+            privateFunctions: [],
+            unconstrainedFunctions: []
+        };
+    }
+    async getBytecodeCommitment(id) {
+        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+        return computePublicBytecodeCommitment(contractClass.packedBytecode);
+    }
+    async getContract(address) {
+        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
+        return {
+            ...instance,
+            address
+        };
+    }
+    getContractClassIds() {
+        throw new Error('Method not implemented.');
+    }
+    async getContractArtifact(address) {
+        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
+        return this.txeOracle.getContractDataProvider().getContractArtifact(instance.currentContractClassId);
+    }
+    async getContractFunctionName(address, selector) {
+        const artifact = await this.getContractArtifact(address);
+        if (!artifact) {
+            return undefined;
+        }
+        const functionSelectorsAndNames = await Promise.all(artifact.functions.map(async (f)=>({
+                name: f.name,
+                selector: await FunctionSelector.fromNameAndParameters({
+                    name: f.name,
+                    parameters: f.parameters
+                })
+            })));
+        const func = functionSelectorsAndNames.find((f)=>f.selector.equals(selector));
+        return Promise.resolve(func?.name);
+    }
+    registerContractFunctionSignatures(_address, _signatures) {
+        return Promise.resolve();
+    }
+    // TODO(#10007): Remove this method.
+    addContractClass(_contractClass) {
+        // We don't really need to do anything for the txe here
+        return Promise.resolve();
+    }
+}

package/dest/util/txe_world_state_db.d.ts

@@ -0,0 +1,14 @@
+import { Fr } from '@aztec/foundation/fields';
+import { WorldStateDB } from '@aztec/simulator/server';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { TXE } from '../oracle/txe_oracle.js';
+export declare class TXEWorldStateDB extends WorldStateDB {
+    private merkleDb;
+    private txe;
+    constructor(merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource, txe: TXE);
+    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
+    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
+}
+//# sourceMappingURL=txe_world_state_db.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txe_world_state_db.d.ts","sourceRoot":"","sources":["../../src/util/txe_world_state_db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAGjF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,qBAAa,eAAgB,SAAQ,YAAY;IACnC,OAAO,CAAC,QAAQ;IAA6D,OAAO,CAAC,GAAG;gBAAhF,QAAQ,EAAE,yBAAyB,EAAE,UAAU,EAAE,kBAAkB,EAAU,GAAG,EAAE,GAAG;IAI1F,WAAW,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAgB1D,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3F"}

package/dest/util/txe_world_state_db.js

@@ -0,0 +1,27 @@
+import { Fr } from '@aztec/foundation/fields';
+import { WorldStateDB } from '@aztec/simulator/server';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+export class TXEWorldStateDB extends WorldStateDB {
+    merkleDb;
+    txe;
+    constructor(merkleDb, dataSource, txe){
+        super(merkleDb, dataSource), this.merkleDb = merkleDb, this.txe = txe;
+    }
+    async storageRead(contract, slot) {
+        const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+        const lowLeafResult = await this.merkleDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+        let value = Fr.ZERO;
+        if (lowLeafResult && lowLeafResult.alreadyPresent) {
+            const preimage = await this.merkleDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+            value = preimage.value;
+        }
+        return value;
+    }
+    async storageWrite(contract, slot, newValue) {
+        await this.txe.addPublicDataWrites([
+            new PublicDataWrite(await computePublicDataTreeLeafSlot(contract, slot), newValue)
+        ]);
+    }
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@aztec/txe",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": "./dest/index.js",
+  "bin": "./dest/bin/index.js",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "TXE",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "dev": "LOG_LEVEL=debug node ./dest/bin/index.js",
+    "start": "node --no-warnings ./dest/bin/index.js"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "workerThreads": true,
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/accounts": "0.0.0-test.0",
+    "@aztec/aztec.js": "0.0.0-test.0",
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/key-store": "0.0.0-test.0",
+    "@aztec/kv-store": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/pxe": "0.0.0-test.0",
+    "@aztec/simulator": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/world-state": "0.0.0-test.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.7.23",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bin/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env -S node --no-warnings
+import { createLogger } from '@aztec/aztec.js';
+import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+
+import { createTXERpcServer } from '../index.js';
+
+/**
+ * Create and start a new TXE HTTP Server
+ */
+async function main() {
+  const { TXE_PORT = 8080 } = process.env;
+
+  process.on('SIGTERM', () => {
+    logger.info('Received SIGTERM.');
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    logger.info('Received SIGTERM.');
+    process.exit(0);
+  });
+
+  const logger = createLogger('txe:service');
+  logger.info(`Setting up TXE...`);
+
+  const txeServer = createTXERpcServer(logger);
+  const { port } = await startHttpRpcServer(txeServer, {
+    port: TXE_PORT,
+    timeoutMs: 1e3 * 60 * 5,
+  });
+
+  logger.info(`TXE listening on port ${port}`);
+}
+
+main().catch(err => {
+  // eslint-disable-next-line no-console
+  console.error(err);
+  process.exit(1);
+});

package/src/index.ts

@@ -0,0 +1,213 @@
+import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
+import {
+  AztecAddress,
+  type ContractArtifact,
+  type ContractInstanceWithAddress,
+  Fr,
+  PublicKeys,
+  deriveKeys,
+  getContractInstanceFromDeployParams,
+  loadContractArtifact,
+} from '@aztec/aztec.js';
+import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import type { Logger } from '@aztec/foundation/log';
+import { type ProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import type { ApiSchemaFor, ZodFor } from '@aztec/stdlib/schemas';
+
+import { readFile, readdir } from 'fs/promises';
+import { join } from 'path';
+import { z } from 'zod';
+
+import { TXEService } from './txe_service/txe_service.js';
+import {
+  type ForeignCallArgs,
+  ForeignCallArgsSchema,
+  type ForeignCallArray,
+  type ForeignCallResult,
+  ForeignCallResultSchema,
+  type ForeignCallSingle,
+  fromArray,
+  fromSingle,
+  toForeignCallResult,
+  toSingle,
+} from './util/encoding.js';
+
+const TXESessions = new Map<number, TXEService>();
+
+const TXEArtifactsCache = new Map<string, { artifact: ContractArtifact; instance: ContractInstanceWithAddress }>();
+
+type MethodNames<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+type TXEForeignCallInput = {
+  session_id: number;
+  function: MethodNames<TXEService> | 'reset';
+  root_path: string;
+  package_name: string;
+  inputs: ForeignCallArgs;
+};
+
+const TXEForeignCallInputSchema = z.object({
+  // eslint-disable-next-line camelcase
+  session_id: z.number().int().nonnegative(),
+  function: z.string() as ZodFor<MethodNames<TXEService> | 'reset'>,
+  // eslint-disable-next-line camelcase
+  root_path: z.string(),
+  // eslint-disable-next-line camelcase
+  package_name: z.string(),
+  inputs: ForeignCallArgsSchema,
+}) satisfies ZodFor<TXEForeignCallInput>;
+
+class TXEDispatcher {
+  private protocolContracts!: ProtocolContract[];
+
+  constructor(private logger: Logger) {}
+
+  async #processDeployInputs({ inputs, root_path: rootPath, package_name: packageName }: TXEForeignCallInput) {
+    const [pathStr, contractName, initializer] = inputs.slice(0, 3).map(input =>
+      fromArray(input as ForeignCallArray)
+        .map(char => String.fromCharCode(char.toNumber()))
+        .join(''),
+    );
+
+    const decodedArgs = fromArray(inputs[4] as ForeignCallArray);
+    const secret = fromSingle(inputs[5] as ForeignCallSingle);
+    const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
+    const publicKeysHash = await publicKeys.hash();
+
+    const cacheKey = `${pathStr}-${contractName}-${initializer}-${decodedArgs
+      .map(arg => arg.toString())
+      .join('-')}-${publicKeysHash.toString()}`;
+
+    let artifact;
+    let instance;
+
+    if (TXEArtifactsCache.has(cacheKey)) {
+      this.logger.debug(`Using cached artifact for ${cacheKey}`);
+      ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
+    } else {
+      let artifactPath = '';
+      // We're deploying the contract under test
+      // env.deploy_self("contractName")
+      if (!pathStr) {
+        artifactPath = join(rootPath, './target', `${packageName}-${contractName}.json`);
+      } else {
+        // We're deploying a contract that belongs in a workspace
+        // env.deploy("../path/to/workspace/root@packageName", "contractName")
+        if (pathStr.includes('@')) {
+          const [workspace, pkg] = pathStr.split('@');
+          const targetPath = join(rootPath, workspace, './target');
+          this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
+          artifactPath = join(targetPath, `${pkg}-${contractName}.json`);
+        } else {
+          // We're deploying a standalone contract
+          // env.deploy("../path/to/contract/root", "contractName")
+          const targetPath = join(rootPath, pathStr, './target');
+          this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
+          [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractName}.json`));
+        }
+      }
+      this.logger.debug(`Loading compiled artifact ${artifactPath}`);
+      artifact = loadContractArtifact(JSON.parse(await readFile(artifactPath, 'utf-8')));
+      this.logger.debug(
+        `Deploy ${
+          artifact.name
+        } with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
+      );
+      instance = await getContractInstanceFromDeployParams(artifact, {
+        constructorArgs: decodedArgs,
+        skipArgsDecoding: true,
+        salt: Fr.ONE,
+        publicKeys,
+        constructorArtifact: initializer ? initializer : undefined,
+        deployer: AztecAddress.ZERO,
+      });
+      TXEArtifactsCache.set(cacheKey, { artifact, instance });
+    }
+
+    inputs.splice(0, 2, artifact, instance, toSingle(secret));
+  }
+
+  async #processAddAccountInputs({ inputs }: TXEForeignCallInput) {
+    const secret = fromSingle(inputs[0] as ForeignCallSingle);
+
+    const cacheKey = `SchnorrAccountContract-${secret}`;
+
+    let artifact;
+    let instance;
+
+    if (TXEArtifactsCache.has(cacheKey)) {
+      this.logger.debug(`Using cached artifact for ${cacheKey}`);
+      ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
+    } else {
+      const keys = await deriveKeys(secret);
+      const args = [keys.publicKeys.masterIncomingViewingPublicKey.x, keys.publicKeys.masterIncomingViewingPublicKey.y];
+      artifact = SchnorrAccountContractArtifact;
+      instance = await getContractInstanceFromDeployParams(artifact, {
+        constructorArgs: args,
+        skipArgsDecoding: true,
+        salt: Fr.ONE,
+        publicKeys: keys.publicKeys,
+        constructorArtifact: 'constructor',
+        deployer: AztecAddress.ZERO,
+      });
+      TXEArtifactsCache.set(cacheKey, { artifact, instance });
+    }
+
+    inputs.splice(0, 0, artifact, instance);
+  }
+
+  // eslint-disable-next-line camelcase
+  async resolve_foreign_call(callData: TXEForeignCallInput): Promise<ForeignCallResult> {
+    const { session_id: sessionId, function: functionName, inputs } = callData;
+    this.logger.debug(`Calling ${functionName} on session ${sessionId}`);
+
+    if (!TXESessions.has(sessionId) && functionName != 'reset') {
+      this.logger.debug(`Creating new session ${sessionId}`);
+      if (!this.protocolContracts) {
+        this.protocolContracts = await Promise.all(
+          protocolContractNames.map(name => new BundledProtocolContractsProvider().getProtocolContractArtifact(name)),
+        );
+      }
+      TXESessions.set(sessionId, await TXEService.init(this.logger, this.protocolContracts));
+    }
+
+    switch (functionName) {
+      case 'reset': {
+        TXESessions.delete(sessionId) &&
+          this.logger.debug(`Called reset on session ${sessionId}, yeeting it out of existence`);
+        return toForeignCallResult([]);
+      }
+      case 'deploy': {
+        await this.#processDeployInputs(callData);
+        break;
+      }
+      case 'addAccount': {
+        await this.#processAddAccountInputs(callData);
+        break;
+      }
+    }
+
+    const txeService = TXESessions.get(sessionId);
+    const response = await (txeService as any)[functionName](...inputs);
+    return response;
+  }
+}
+
+const TXEDispatcherApiSchema: ApiSchemaFor<TXEDispatcher> = {
+  // eslint-disable-next-line camelcase
+  resolve_foreign_call: z.function().args(TXEForeignCallInputSchema).returns(ForeignCallResultSchema),
+};
+
+/**
+ * Creates an RPC server that forwards calls to the TXE.
+ * @param logger - Logger to output to
+ * @returns A TXE RPC server.
+ */
+export function createTXERpcServer(logger: Logger) {
+  return createSafeJsonRpcServer(new TXEDispatcher(logger), TXEDispatcherApiSchema, {
+    http200OnError: true,
+  });
+}