@aztec/txe 5.0.0-private.20260319 → 5.0.0-rc.1

package/src/{util → utils}/encoding.ts

@@ -3,6 +3,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { type ContractArtifact, ContractArtifactSchema } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
 import { type ContractInstanceWithAddress, ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
 
 import { z } from 'zod';
@@ -25,6 +26,10 @@ 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)));
 }
@@ -142,9 +147,10 @@ export function arrayOfArraysToBoundedVecOfArrays(
 
   const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
 
-  const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(new Fr(0)));
+  // 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))));
 
-  // At last we get the actual length of the BoundedVec and return the values.
   const len = toSingle(new Fr(bVecStorage.length));
   return [flattenedStorageWithPadding, len];
 }

package/src/utils/txe_artifact_resolver.ts

@@ -0,0 +1,217 @@
+import { type NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import {
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
+import { createLogger } from '@aztec/foundation/log';
+import type { ContractStore } from '@aztec/pxe/client/lazy';
+import type { ContractArtifactWithHash } from '@aztec/stdlib/contract';
+import { computeArtifactHash } from '@aztec/stdlib/contract';
+
+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/{util → utils}/txe_public_contract_data_source.ts

@@ -26,8 +26,6 @@ export class TXEPublicContractDataSource implements ContractDataSource {
       packedBytecode: contractClass.packedBytecode,
       privateFunctionsRoot: contractClass.privateFunctionsRoot,
       version: contractClass.version,
-      privateFunctions: [],
-      utilityFunctions: [],
     };
   }
 

package/src/worker.ts

@@ -0,0 +1,98 @@
+import { BackendType, Barretenberg, BarretenbergSync } from '@aztec/bb.js';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import { parentPort, workerData } from 'node:worker_threads';
+
+// Importing `./index.js` registers the msgpackr Fr extension transitively (via
+// ./msgpackr_fr_extension.js); this must happen before any `sendMessage` call.
+import { TXEDispatcher, type TXEDispatcherOptions, type TXEForeignCallInput, activeSessionCount } from './index.js';
+
+// Seed both bb.js singletons with the WASM backend before any crypto call. `initSingleton`
+// binds the singleton to whichever backend the first call requests, so this pre-empts the
+// implicit `Barretenberg.initSingleton()` inside `poseidon2Hash` from `@aztec/foundation/crypto`.
+// TXE only needs hashing (no proving, no verification), so WASM is sufficient and
+// `skipSrsInit: true` skips the CRS load. `threads: 1` keeps the WASM backend on a single
+// thread — additional threads would each spawn a nested worker_thread, multiplying memory cost
+// per pool worker.
+void Barretenberg.initSingleton({ backend: BackendType.Wasm, skipSrsInit: true, threads: 1 });
+void BarretenbergSync.initSingleton({ backend: BackendType.Wasm });
+
+if (!parentPort) {
+  throw new Error('worker.ts must be loaded as a worker_thread');
+}
+
+const port = parentPort;
+const logger: Logger = createLogger('txe:worker');
+
+// The pool builds a template LMDB containing the protocol contracts + the SchnorrAccount
+// artifact on the main thread and passes its data dir via `workerData`. The dispatcher clones
+// that LMDB into a per-worker store on first use, so this worker gets a writable copy already
+// populated.
+const dispatcherOpts: TXEDispatcherOptions = {
+  contractStoreSourceDir: workerData.contractStoreSourceDir,
+  schnorrClassId: workerData.schnorrClassId,
+};
+const dispatcher = new TXEDispatcher(logger, dispatcherOpts);
+
+interface ForeignCallRequest {
+  type: 'foreign-call';
+  requestId: number;
+  callData: TXEForeignCallInput;
+}
+
+interface DisposeSessionMessage {
+  type: 'dispose-session';
+  sessionId: number;
+}
+
+type IncomingMessage = ForeignCallRequest | DisposeSessionMessage;
+
+interface SerializedError {
+  message: string;
+  name?: string;
+  stack?: string;
+}
+
+function serializeError(err: unknown): SerializedError {
+  if (err instanceof Error) {
+    return { message: err.message, name: err.name, stack: err.stack };
+  }
+  return { message: String(err) };
+}
+
+// Periodic memstat for diagnostic builds — set TXE_WORKER_MEMSTAT=1 to enable. Posts JS-heap
+// breakdown + active-session count back to the dispatcher so we can attribute RSS growth
+// between V8 heap (would show in heapUsed) and native (LMDB / world-state / WASM).
+if (process.env.TXE_WORKER_MEMSTAT === '1') {
+  setInterval(() => {
+    const m = process.memoryUsage();
+    port.postMessage({
+      type: 'memstat',
+      sessions: activeSessionCount(),
+      rss: m.rss,
+      heapTotal: m.heapTotal,
+      heapUsed: m.heapUsed,
+      external: m.external,
+      arrayBuffers: m.arrayBuffers,
+    });
+  }, 2000).unref();
+}
+
+port.on('message', (msg: IncomingMessage) => {
+  switch (msg.type) {
+    case 'foreign-call':
+      void (async () => {
+        try {
+          const value = await dispatcher.resolve_foreign_call(msg.callData);
+          port.postMessage({ type: 'result', requestId: msg.requestId, ok: true, value });
+        } catch (err) {
+          port.postMessage({ type: 'result', requestId: msg.requestId, ok: false, error: serializeError(err) });
+        }
+      })();
+      return;
+    case 'dispose-session':
+      // Fire-and-forget; the main thread does not wait for confirmation.
+      void dispatcher.disposeSession(msg.sessionId).catch(err => logger.warn(`disposeSession failed`, err));
+      return;
+  }
+});