@aztec/txe 0.0.1-commit.86469d5 → 0.0.1-commit.8655d4a

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/{util → utils}/txe_public_contract_data_source.ts

@@ -1,19 +1,11 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractStore } from '@aztec/pxe/server';
-import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import {
-  type ContractClassPublic,
-  type ContractDataSource,
-  type ContractInstanceWithAddress,
-  computePrivateFunctionsRoot,
-  computePublicBytecodeCommitment,
-  getContractClassPrivateFunctionFromArtifact,
-} from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 export class TXEPublicContractDataSource implements ContractDataSource {
-  #privateFunctionsRoot: Map<string, Buffer> = new Map();
   constructor(
     private blockNumber: BlockNumber,
     private contractStore: ContractStore,
@@ -24,42 +16,22 @@ export class TXEPublicContractDataSource implements ContractDataSource {
   }
 
   async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    const contractClass = await this.contractStore.getContractClass(id);
+    const contractClass = await this.contractStore.getContractClassWithPreimage(id);
     if (!contractClass) {
       return;
     }
-    const artifact = await this.contractStore.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,
-      privateFunctionsRoot,
-      version: contractClass!.version,
-      privateFunctions: [],
-      utilityFunctions: [],
+      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.getContractClass(id);
-    return contractClass && computePublicBytecodeCommitment(contractClass.packedBytecode);
+    const contractClass = await this.contractStore.getContractClassWithPreimage(id);
+    return contractClass?.publicBytecodeCommitment;
   }
 
   async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {

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;
+  }
+});