@aztec/txe 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/utils/block_creation.ts

@@ -4,13 +4,12 @@ import {
   NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
 } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 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 { Fr } from '@aztec/foundation/curves/bn254';
+import { Body, L2Block } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import { GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
 
 /**
  * Returns a transaction request hash that is valid for transactions that are the only ones in a block.
@@ -24,6 +23,7 @@ export function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr {
 export async function insertTxEffectIntoWorldTrees(
   txEffect: TxEffect,
   worldTrees: MerkleTreeWriteOperations,
+  l1ToL2Messages: Fr[] = [],
 ): Promise<void> {
   await worldTrees.appendLeaves(
     MerkleTreeId.NOTE_HASH_TREE,
@@ -38,7 +38,7 @@ export async function insertTxEffectIntoWorldTrees(
 
   await worldTrees.appendLeaves(
     MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-    padArrayEnd<Fr, number>(txEffect.l2ToL1Msgs, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+    padArrayEnd<Fr, number>(l1ToL2Messages, 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.
@@ -47,18 +47,52 @@ export async function insertTxEffectIntoWorldTrees(
 export async function makeTXEBlockHeader(
   worldTrees: MerkleTreeWriteOperations,
   globalVariables: GlobalVariables,
-): Promise<L2BlockHeader> {
+): Promise<BlockHeader> {
   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,
+  return BlockHeader.from({
+    lastArchive: new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+    spongeBlobHash: Fr.ZERO,
+    state: stateReference,
     globalVariables,
-    Fr.ZERO,
-    Fr.ZERO,
-    Fr.ZERO,
-    Fr.ZERO,
-  );
+    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/{util → utils}/encoding.ts

@@ -1,8 +1,9 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 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/tx_effect_creation.ts

@@ -1,19 +1,13 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 
-export async function makeTxEffect(
-  noteCache: ExecutionNoteCache,
-  protocolNullifier: Fr,
-  txBlockNumber: BlockNumber,
-): Promise<TxEffect> {
+export async function makeTxEffect(noteCache: ExecutionNoteCache, txBlockNumber: BlockNumber): Promise<TxEffect> {
   const txEffect = TxEffect.empty();
 
-  const { usedProtocolNullifierForNonces } = noteCache.finish();
-  const nonceGenerator = usedProtocolNullifierForNonces ? protocolNullifier : noteCache.getAllNullifiers()[0];
-
+  const nonceGenerator = noteCache.getNonceGenerator();
   txEffect.noteHashes = await Promise.all(
     noteCache
       .getAllNotes()
@@ -28,10 +22,6 @@ export async function makeTxEffect(
   // Nullifiers are already siloed
   txEffect.nullifiers = noteCache.getAllNullifiers();
 
-  if (usedProtocolNullifierForNonces) {
-    txEffect.nullifiers.unshift(protocolNullifier);
-  }
-
   txEffect.txHash = new TxHash(new Fr(txBlockNumber));
 
   return txEffect;

package/src/{util/txe_account_data_provider.ts → utils/txe_account_store.ts}

@@ -2,7 +2,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { CompleteAddress } from '@aztec/stdlib/contract';
 
-export class TXEAccountDataProvider {
+export class TXEAccountStore {
   #accounts: AztecAsyncMap<string, Buffer>;
 
   constructor(store: AztecAsyncKVStore) {

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/utils/txe_public_contract_data_source.ts

@@ -0,0 +1,60 @@
+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 } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/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();
+  }
+}

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