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

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":"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"}
+{"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

@@ -1,56 +1,52 @@
-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';
+import { FunctionType } from '@aztec/stdlib/abi';
+import { computePrivateFunctionsRoot, computePublicBytecodeCommitment, getContractClassPrivateFunctionFromArtifact } 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
-        };
+    blockNumber;
+    contractDataProvider;
+    #privateFunctionsRoot;
+    constructor(blockNumber, contractDataProvider){
+        this.blockNumber = blockNumber;
+        this.contractDataProvider = contractDataProvider;
+        this.#privateFunctionsRoot = new Map();
     }
     getBlockNumber() {
-        return this.txeOracle.getBlockNumber();
+        return Promise.resolve(this.blockNumber);
     }
     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
-            });
+        const contractClass = await this.contractDataProvider.getContractClass(id);
+        if (!contractClass) {
+            return;
+        }
+        const artifact = await this.contractDataProvider.getContractArtifact(id);
+        if (!artifact) {
+            return;
+        }
+        let privateFunctionsRoot;
+        if (!this.#privateFunctionsRoot.has(id.toString())) {
+            const privateFunctions = await Promise.all(artifact.functions.filter((fn)=>fn.functionType === FunctionType.PRIVATE).map((fn)=>getContractClassPrivateFunctionFromArtifact(fn)));
+            privateFunctionsRoot = await computePrivateFunctionsRoot(privateFunctions);
+            this.#privateFunctionsRoot.set(id.toString(), privateFunctionsRoot.toBuffer());
+        } else {
+            privateFunctionsRoot = Fr.fromBuffer(this.#privateFunctionsRoot.get(id.toString()));
         }
         return {
             id,
             artifactHash: contractClass.artifactHash,
             packedBytecode: contractClass.packedBytecode,
-            publicFunctions: publicFunctions,
-            privateFunctionsRoot: new Fr(privateFunctionsRoot.root),
+            privateFunctionsRoot,
             version: contractClass.version,
             privateFunctions: [],
-            unconstrainedFunctions: []
+            utilityFunctions: []
         };
     }
     async getBytecodeCommitment(id) {
-        const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
-        return computePublicBytecodeCommitment(contractClass.packedBytecode);
+        const contractClass = await this.contractDataProvider.getContractClass(id);
+        return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
     }
     async getContract(address) {
-        const instance = await this.txeOracle.getContractDataProvider().getContractInstance(address);
-        return {
+        const instance = await this.contractDataProvider.getContractInstance(address);
+        return instance && {
             ...instance,
             address
         };
@@ -59,30 +55,13 @@ export class TXEPublicContractDataSource {
         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);
+        const instance = await this.contractDataProvider.getContractInstance(address);
+        return instance && this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
     }
-    registerContractFunctionSignatures(_address, _signatures) {
-        return Promise.resolve();
+    async getDebugFunctionName(address, selector) {
+        return await this.contractDataProvider.getDebugFunctionName(address, selector);
     }
-    // TODO(#10007): Remove this method.
-    addContractClass(_contractClass) {
-        // We don't really need to do anything for the txe here
+    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": "0.0.0-test.1",
+  "version": "0.0.1-commit.b655e406",
   "type": "module",
   "exports": "./dest/index.js",
   "bin": "./dest/bin/index.js",
@@ -15,10 +15,8 @@
     "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",
+    "dev": "LOG_LEVEL=\"debug; trace: simulator:state_manager; info: json-rpc:proxy\" node ./dest/bin/index.js",
     "start": "node --no-warnings ./dest/bin/index.js"
   },
   "inherits": [
@@ -56,30 +54,37 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.0-test.1",
-    "@aztec/aztec.js": "0.0.0-test.1",
-    "@aztec/constants": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/key-store": "0.0.0-test.1",
-    "@aztec/kv-store": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@aztec/pxe": "0.0.0-test.1",
-    "@aztec/simulator": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "@aztec/world-state": "0.0.0-test.1",
+    "@aztec/accounts": "0.0.1-commit.b655e406",
+    "@aztec/archiver": "0.0.1-commit.b655e406",
+    "@aztec/aztec-node": "0.0.1-commit.b655e406",
+    "@aztec/aztec.js": "0.0.1-commit.b655e406",
+    "@aztec/bb-prover": "0.0.1-commit.b655e406",
+    "@aztec/constants": "0.0.1-commit.b655e406",
+    "@aztec/foundation": "0.0.1-commit.b655e406",
+    "@aztec/key-store": "0.0.1-commit.b655e406",
+    "@aztec/kv-store": "0.0.1-commit.b655e406",
+    "@aztec/protocol-contracts": "0.0.1-commit.b655e406",
+    "@aztec/pxe": "0.0.1-commit.b655e406",
+    "@aztec/simulator": "0.0.1-commit.b655e406",
+    "@aztec/stdlib": "0.0.1-commit.b655e406",
+    "@aztec/world-state": "0.0.1-commit.b655e406",
     "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",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -88,6 +93,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

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';
@@ -20,11 +20,12 @@ async function main() {
     process.exit(0);
   });
 
-  const logger = createLogger('txe:service');
+  const logger = createLogger('txe:rpc');
   logger.info(`Setting up TXE...`);
 
   const txeServer = createTXERpcServer(logger);
   const { port } = await startHttpRpcServer(txeServer, {
+    host: '127.0.0.1',
     port: TXE_PORT,
     timeoutMs: 1e3 * 60 * 5,
   });

package/src/index.ts

@@ -1,25 +1,26 @@
 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 ContractArtifact,
   type ContractInstanceWithAddress,
-  Fr,
-  PublicKeys,
-  deriveKeys,
-  getContractInstanceFromDeployParams,
-  loadContractArtifact,
-} from '@aztec/aztec.js';
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
 import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import type { Logger } from '@aztec/foundation/log';
 import { type ProtocolContract, protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { computeArtifactHash } from '@aztec/stdlib/contract';
 import type { ApiSchemaFor, ZodFor } from '@aztec/stdlib/schemas';
 
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
 import { readFile, readdir } from 'fs/promises';
-import { join } from 'path';
+import { join, parse } from 'path';
 import { z } from 'zod';
 
-import { TXEService } from './txe_service/txe_service.js';
+import { type TXEOracleFunctionName, TXESession } from './txe_session.js';
 import {
   type ForeignCallArgs,
   ForeignCallArgsSchema,
@@ -29,21 +30,24 @@ import {
   type ForeignCallSingle,
   fromArray,
   fromSingle,
-  toForeignCallResult,
   toSingle,
 } from './util/encoding.js';
+import type { ContractArtifactWithHash } from './util/txe_contract_data_provider.js';
 
-const TXESessions = new Map<number, TXEService>();
+const sessions = new Map<number, TXESession>();
 
-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];
+/*
+ * TXE typically has to load the same contract artifacts over and over again for multiple tests,
+ * so we cache them here to avoid both loading them from disk repeatedly and computing their artifact hashes
+ */
+const TXEArtifactsCache = new Map<
+  string,
+  { artifact: ContractArtifactWithHash; instance: ContractInstanceWithAddress }
+>();
 
 type TXEForeignCallInput = {
   session_id: number;
-  function: MethodNames<TXEService> | 'reset';
+  function: TXEOracleFunctionName;
   root_path: string;
   package_name: string;
   inputs: ForeignCallArgs;
@@ -52,7 +56,7 @@ type TXEForeignCallInput = {
 const TXEForeignCallInputSchema = z.object({
   // eslint-disable-next-line camelcase
   session_id: z.number().int().nonnegative(),
-  function: z.string() as ZodFor<MethodNames<TXEService> | 'reset'>,
+  function: z.string() as ZodFor<TXEOracleFunctionName>,
   // eslint-disable-next-line camelcase
   root_path: z.string(),
   // eslint-disable-next-line camelcase
@@ -65,58 +69,84 @@ class TXEDispatcher {
 
   constructor(private logger: Logger) {}
 
+  private fastHashFile(path: 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());
+      });
+
+      fd.pipe(hash);
+    });
+  }
+
   async #processDeployInputs({ inputs, root_path: rootPath, package_name: packageName }: TXEForeignCallInput) {
-    const [pathStr, contractName, initializer] = inputs.slice(0, 3).map(input =>
+    const [contractPath, initializer] = inputs.slice(0, 2).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 decodedArgs = fromArray(inputs[3] as ForeignCallArray);
+    const secret = fromSingle(inputs[4] 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
+    let artifactPath = '';
+    const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+    if (contractDirectory) {
+      if (contractDirectory.includes('@')) {
+        // We're deploying a contract that belongs in a workspace
+        // env.deploy("../path/to/workspace/root@packageName/contractName")
+        const [workspace, pkg] = contractDirectory.split('@');
+        const targetPath = join(rootPath, workspace, '/target');
+        this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
+        artifactPath = join(targetPath, `${pkg}-${contractFilename}.json`);
+      } else {
+        // We're deploying a standalone external contract
+        // env.deploy("../path/to/contract/root/contractName")
+        const targetPath = join(rootPath, contractDirectory, '/target');
+        this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
+        [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractFilename}.json`));
+      }
+    } else {
+      // We're deploying a local contract
+      // env.deploy("contractName")
+      artifactPath = join(rootPath, './target', `${packageName}-${contractFilename}.json`);
+    }
+
+    const fileHash = await this.fastHashFile(artifactPath);
+
+    const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${decodedArgs
       .map(arg => arg.toString())
-      .join('-')}-${publicKeysHash.toString()}`;
+      .join('-')}-${publicKeysHash}-${fileHash}`;
 
-    let artifact;
     let instance;
+    let artifact: ContractArtifactWithHash;
 
     if (TXEArtifactsCache.has(cacheKey)) {
       this.logger.debug(`Using cached artifact for ${cacheKey}`);
       ({ artifact, instance } = TXEArtifactsCache.get(cacheKey)!);
     } else {
-      let artifactPath = '';
-      // We're deploying the contract under test
-      // env.deploy_self("contractName")
-      if (!pathStr) {
-        artifactPath = join(rootPath, './target', `${packageName}-${contractName}.json`);
-      } else {
-        // We're deploying a contract that belongs in a workspace
-        // env.deploy("../path/to/workspace/root@packageName", "contractName")
-        if (pathStr.includes('@')) {
-          const [workspace, pkg] = pathStr.split('@');
-          const targetPath = join(rootPath, workspace, './target');
-          this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
-          artifactPath = join(targetPath, `${pkg}-${contractName}.json`);
-        } else {
-          // We're deploying a standalone contract
-          // env.deploy("../path/to/contract/root", "contractName")
-          const targetPath = join(rootPath, pathStr, './target');
-          this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
-          [artifactPath] = (await readdir(targetPath)).filter(file => file.endsWith(`-${contractName}.json`));
-        }
-      }
       this.logger.debug(`Loading compiled artifact ${artifactPath}`);
-      artifact = loadContractArtifact(JSON.parse(await readFile(artifactPath, 'utf-8')));
+      const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8')) as NoirCompiledContract;
+      const artifactWithoutHash = loadContractArtifact(artifactJSON);
+      artifact = {
+        ...artifactWithoutHash,
+        // Artifact hash is *very* expensive to compute, so we do it here once
+        // and the TXE contract data provider can cache it
+        artifactHash: await computeArtifactHash(artifactWithoutHash),
+      };
       this.logger.debug(
         `Deploy ${
           artifact.name
         } with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`,
       );
-      instance = await getContractInstanceFromDeployParams(artifact, {
+      instance = await getContractInstanceFromInstantiationParams(artifact, {
         constructorArgs: decodedArgs,
         skipArgsDecoding: true,
         salt: Fr.ONE,
@@ -127,7 +157,7 @@ class TXEDispatcher {
       TXEArtifactsCache.set(cacheKey, { artifact, instance });
     }
 
-    inputs.splice(0, 2, artifact, instance, toSingle(secret));
+    inputs.splice(0, 1, artifact, instance, toSingle(secret));
   }
 
   async #processAddAccountInputs({ inputs }: TXEForeignCallInput) {
@@ -135,7 +165,7 @@ class TXEDispatcher {
 
     const cacheKey = `SchnorrAccountContract-${secret}`;
 
-    let artifact;
+    let artifact: ContractArtifactWithHash;
     let instance;
 
     if (TXEArtifactsCache.has(cacheKey)) {
@@ -144,8 +174,13 @@ class TXEDispatcher {
     } else {
       const keys = await deriveKeys(secret);
       const args = [keys.publicKeys.masterIncomingViewingPublicKey.x, keys.publicKeys.masterIncomingViewingPublicKey.y];
-      artifact = SchnorrAccountContractArtifact;
-      instance = await getContractInstanceFromDeployParams(artifact, {
+      artifact = {
+        ...SchnorrAccountContractArtifact,
+        // Artifact hash is *very* expensive to compute, so we do it here once
+        // and the TXE contract data provider can cache it
+        artifactHash: await computeArtifactHash(SchnorrAccountContractArtifact),
+      };
+      instance = await getContractInstanceFromInstantiationParams(artifact, {
         constructorArgs: args,
         skipArgsDecoding: true,
         salt: Fr.ONE,
@@ -164,35 +199,28 @@ class TXEDispatcher {
     const { session_id: sessionId, function: functionName, inputs } = callData;
     this.logger.debug(`Calling ${functionName} on session ${sessionId}`);
 
-    if (!TXESessions.has(sessionId) && functionName != 'reset') {
+    if (!sessions.has(sessionId)) {
       this.logger.debug(`Creating new session ${sessionId}`);
       if (!this.protocolContracts) {
         this.protocolContracts = await Promise.all(
           protocolContractNames.map(name => new BundledProtocolContractsProvider().getProtocolContractArtifact(name)),
         );
       }
-      TXESessions.set(sessionId, await TXEService.init(this.logger, this.protocolContracts));
+      sessions.set(sessionId, await TXESession.init(this.protocolContracts));
     }
 
     switch (functionName) {
-      case 'reset': {
-        TXESessions.delete(sessionId) &&
-          this.logger.debug(`Called reset on session ${sessionId}, yeeting it out of existence`);
-        return toForeignCallResult([]);
-      }
-      case 'deploy': {
+      case 'txeDeploy': {
         await this.#processDeployInputs(callData);
         break;
       }
-      case 'addAccount': {
+      case 'txeAddAccount': {
         await this.#processAddAccountInputs(callData);
         break;
       }
     }
 
-    const txeService = TXESessions.get(sessionId);
-    const response = await (txeService as any)[functionName](...inputs);
-    return response;
+    return await sessions.get(sessionId)!.processFunction(functionName, inputs);
   }
 }