trac-peer 0.4.5 → 0.4.6

package/DOCS.md

@@ -30,7 +30,8 @@ In practice:
 ## Requirements
 
 - Node.js + npm (recommended: a modern Node LTS).
-- `pear` is optional (you can run in pure Node). If you use Pear, add it to PATH as Pear suggests.
+- The Pear CLI is optional. `peer:pear` automatically uses legacy `pear run` when it detects Pear v2,
+  and uses the embedded `pear-runtime` worker for Pear v3 (or when Pear is not installed).
 - You need your **MSB bootstrap** (32‑byte hex / 64 hex characters) and **MSB channel** (string).
 
 ---
@@ -112,7 +113,10 @@ Notes:
 
 ## Start a peer (Pear runner)
 
-Pear runner is similar, but uses Pear runtime (like MSB does).
+The Pear compatibility runner uses the same command on Pear v2 and v3. It delegates to legacy
+`pear run` on v2; on v3, where that command no longer exists, it launches the peer as a Bare worker
+through the embedded `pear-runtime` module. If no Pear platform version can be detected, it safely
+uses the module path.
 
 Recommended: set store names explicitly (this avoids confusion when running multiple nodes on one machine).
 
@@ -323,7 +327,7 @@ npm run peer:run -- \
   --subnet-channel=trac-peer-subnet
 ```
 
-If you started Peer 1 with Pear, you can also start Peer 2 with Pear:
+If you started Peer 1 with the Pear compatibility runner, use the same runner for Peer 2:
 
 ```sh
 npm run peer:pear -- \
@@ -394,6 +398,8 @@ npm run peer:run-rpc -- \
 
 ### Start with RPC enabled (Pear)
 
+This command uses the same automatic Pear v2/v3 selection described above.
+
 ```sh
 npm run peer:pear-rpc -- \
   --msb-bootstrap=<hex32> \

package/README.md

@@ -35,7 +35,13 @@ npm run peer:run -- --msb-bootstrap=<32-byte-hex> --msb-channel=<channel-string>
 
 ### Pear runner (interactive)
 
-Runs `trac-peer` using the Pear runtime (similar to `trac-msb`). You can control stores via flags (recommended); an optional first positional arg can be used as a “store label” fallback if `--peer-store-name` is omitted.
+Runs `trac-peer` through the Pear v2/v3 compatibility runner. With Pear v2 it delegates to the legacy
+`pear run` command; with Pear v3 (where `pear run` was removed), or when no Pear platform version can be
+detected, it starts the same entrypoint with the embedded `pear-runtime` module. The npm command and all
+application flags are identical in both modes.
+
+You can control stores via flags (recommended); an optional first positional arg can be used as a “store
+label” fallback if `--peer-store-name` is omitted.
 
 ```sh
 npm run peer:pear -- \

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-peer",
   "main": "src/index.js",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "type": "module",
   "pear": {
     "name": "trac-peer",
@@ -22,8 +22,8 @@
     "peer:run": "node scripts/run-peer.mjs",
     "peer:run-rpc": "node scripts/run-peer.mjs --rpc",
     "peer:smoke": "node scripts/smoke-msb-sync.mjs",
-    "peer:pear": "pear run -d scripts/run-peer.mjs",
-    "peer:pear-rpc": "pear run -d scripts/run-peer.mjs --rpc",
+    "peer:pear": "node scripts/pear-runner.mjs",
+    "peer:pear-rpc": "node scripts/pear-runner.mjs --rpc",
     "test:unit:node": "brittle-node -t 60000 tests/unit/unit.test.js",
     "test:unit:bare": "brittle-bare -t 60000 tests/unit/unit.test.js",
     "test:unit:all": "(npm run test:unit:node && npm run test:unit:bare) || exit 1",
@@ -40,7 +40,7 @@
     "bare-assert": "1.0.2",
     "bare-buffer": "3.1.2",
     "bare-console": "6.0.1",
-    "bare-crypto": "1.4.3",
+    "bare-crypto": "1.12.0",
     "bare-events": "2.5.4",
     "bare-fetch": "2.2.2",
     "bare-fs": "^4.1.5",
@@ -57,7 +57,6 @@
     "bare-subprocess": "5.0.4",
     "bare-timers": "3.0.1",
     "bare-tls": "2.0.4",
-    "bare-tty": "5.0.2",
     "bare-url": "2.1.5",
     "bare-utils": "1.5.1",
     "bare-worker": "3.0.0",
@@ -88,6 +87,7 @@
     "os": "npm:bare-node-os",
     "path": "npm:bare-node-path",
     "pear-interface": "1.1.0",
+    "pear-runtime": "1.3.1",
     "process": "npm:bare-node-process",
     "protomux": "^3.10.1",
     "protomux-wakeup": "^2.4.0",
@@ -95,14 +95,12 @@
     "ready-resource": "1.1.2",
     "repl": "npm:bare-node-repl",
     "safety-catch": "1.0.2",
-    "sodium-native": "5.0.1",
     "stream": "npm:bare-node-stream",
     "timers": "npm:bare-node-timers",
     "tls": "npm:bare-node-tls",
-    "trac-crypto-api": "^0.1.3",
-    "trac-msb": "^0.2.9",
-    "trac-wallet": "^1.0.1",
-    "tty": "npm:bare-node-tty",
+    "trac-crypto-api": "^0.1.5",
+    "trac-msb": "^0.2.19",
+    "trac-wallet": "^1.0.4",
     "url": "npm:bare-node-url",
     "util": "npm:bare-node-util",
     "worker_threads": "npm:bare-node-worker-threads",

package/scripts/pear-runner.mjs

@@ -0,0 +1,163 @@
+import { spawn, spawnSync } from "node:child_process";
+import { constants as osConstants } from "node:os";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { parsePearMajor, selectPearRunnerMode } from "../src/pearCompat.js";
+
+const projectDirectory = fileURLToPath(new URL("../", import.meta.url));
+const entrypoint = fileURLToPath(new URL("./run-peer.mjs", import.meta.url));
+const appArgs = process.argv.slice(2);
+
+const exitCodeFor = (code, signal) => {
+  if (code !== null && code !== undefined) return code;
+  const signalNumber = osConstants.signals?.[signal];
+  return Number.isInteger(signalNumber) ? 128 + signalNumber : 1;
+};
+
+const detectPear = () => {
+  for (const args of [
+    ["-v"],
+    ["-v", "--json"],
+  ]) {
+    const result = spawnSync("pear", args, {
+      cwd: projectDirectory,
+      encoding: "utf8",
+      windowsHide: true,
+    });
+    if (result.error || result.status !== 0) continue;
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n");
+    if (parsePearMajor(output) !== null) return output;
+  }
+  return "";
+};
+
+const forwardedSignals =
+  process.platform === "win32"
+    ? ["SIGINT", "SIGBREAK", "SIGTERM"]
+    : ["SIGHUP", "SIGINT", "SIGQUIT", "SIGTERM"];
+
+const supervise = (child, { stop, forceStop = null }) => {
+  let exited = false;
+  let receivedSignal = null;
+  let forceTimer = null;
+
+  const signalHandlers = new Map();
+  const stopOnHostExit = () => {
+    if (!exited) stop("SIGTERM");
+  };
+  const cleanup = () => {
+    if (forceTimer) clearTimeout(forceTimer);
+    for (const [signal, handler] of signalHandlers) {
+      process.removeListener(signal, handler);
+    }
+    process.removeListener("exit", stopOnHostExit);
+  };
+  const requestStop = (signal) => {
+    if (receivedSignal !== null) {
+      (forceStop ?? stop)(signal);
+      return;
+    }
+    receivedSignal = signal;
+    stop(signal);
+    if (!forceStop) return;
+    forceTimer = setTimeout(() => {
+      if (!exited) forceStop();
+    }, 5000);
+    forceTimer.unref?.();
+  };
+
+  for (const signal of forwardedSignals) {
+    const handler = () => requestStop(signal);
+    signalHandlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  process.once("exit", stopOnHostExit);
+
+  child.once("error", (error) => {
+    exited = true;
+    cleanup();
+    console.error("Pear runner failed:", error?.message ?? error);
+    process.exitCode = 1;
+  });
+  child.once("exit", (code, signal) => {
+    exited = true;
+    cleanup();
+    if (receivedSignal === null && (signal || (code !== null && code !== 0))) {
+      const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+      console.error(`Pear runner exited unexpectedly (${reason}).`);
+    }
+    process.exitCode = receivedSignal
+      ? exitCodeFor(null, receivedSignal)
+      : exitCodeFor(code, signal);
+  });
+};
+
+const runLegacy = () => {
+  const child = spawn(
+    "pear",
+    ["run", "-d", "scripts/run-peer.mjs", ...appArgs],
+    {
+      cwd: projectDirectory,
+      stdio: "inherit",
+      windowsHide: true,
+    }
+  );
+
+  supervise(child, {
+    stop: (signal) => {
+      try {
+        child.kill(signal);
+      } catch (_e) {}
+    },
+    forceStop: () => {
+      try {
+        child.kill("SIGKILL");
+      } catch (_e) {}
+    },
+  });
+};
+
+const runModule = async () => {
+  const imported = await import("pear-runtime");
+  const PearRuntime = imported.default ?? imported;
+  const worker = PearRuntime.run(entrypoint, appArgs);
+
+  const onWorkerStdinError = (error) => {
+    if (error?.code === "EPIPE" || error?.code === "ERR_STREAM_DESTROYED") return;
+    console.error("Pear worker stdin failed:", error?.message ?? error);
+  };
+
+  if (worker.stdin) worker.stdin.on("error", onWorkerStdinError);
+  if (worker.stdin) process.stdin.pipe(worker.stdin);
+  if (worker.stdout) worker.stdout.pipe(process.stdout, { end: false });
+  if (worker.stderr) worker.stderr.pipe(process.stderr, { end: false });
+
+  const unpipe = () => {
+    if (worker.stdin) process.stdin.unpipe(worker.stdin);
+    if (worker.stdin) worker.stdin.removeListener("error", onWorkerStdinError);
+    if (worker.stdout) worker.stdout.unpipe(process.stdout);
+    if (worker.stderr) worker.stderr.unpipe(process.stderr);
+  };
+
+  worker.once("close", unpipe);
+  supervise(worker, {
+    stop: () => {
+      if (!worker.destroyed) worker.destroy();
+    },
+    forceStop: () => {
+      // Sidecar only exposes graceful destroy; use its child handle as a guarded fallback.
+      try {
+        if (typeof worker._process?.kill === "function") {
+          worker._process.kill("SIGKILL");
+          return;
+        }
+      } catch (_e) {}
+      if (!worker.destroyed) worker.destroy();
+    },
+  });
+};
+
+const mode = selectPearRunnerMode(detectPear());
+if (mode === "legacy") runLegacy();
+else await runModule();

package/scripts/run-peer.mjs

@@ -1,6 +1,7 @@
 import b4a from "b4a";
 import path from "path";
 import fs from "fs";
+import process from "process";
 import PeerWallet from "trac-wallet";
 import { Peer, Wallet, createConfig as createPeerConfig, ENV as PEER_ENV } from "../src/index.js";
 import { MainSettlementBus } from "trac-msb/src/index.js";
@@ -12,21 +13,20 @@ import { ensureTextCodecs } from "../src/textCodec.js";
 import TuxemonProtocol from "../dev/tuxemonProtocol.js";
 import TuxemonContract from "../dev/tuxemonContract.js";
 
-let process = globalThis.process;
-if (globalThis.Pear !== undefined) {
-  const { default: bareProcess } = await import("bare-process");
-  process = bareProcess;
-}
-
 const pearApp = typeof Pear !== "undefined" ? (Pear.app ?? Pear.config) : undefined;
 const runtimeArgs = typeof process !== "undefined" ? process.argv.slice(2) : [];
 const argv = pearApp?.args ?? runtimeArgs;
 const positionalStoreName = argv.find((a) => a !== undefined && !String(a).startsWith("--")) ?? null;
 
-const createMsb = (options) => {
-  const config = createMsbConfig(MSB_ENV.MAINNET, options)
-  return new MainSettlementBus(config);
-}
+const resolveEnvironment = (network) => {
+  if (network === PEER_ENV.DEVELOPMENT) {
+    return { peer: PEER_ENV.DEVELOPMENT, msb: MSB_ENV.DEVELOPMENT };
+  }
+  if (network === PEER_ENV.TESTNET1 || network === "testnet") {
+    return { peer: PEER_ENV.TESTNET1, msb: MSB_ENV.TESTNET1 };
+  }
+  return { peer: PEER_ENV.MAINNET, msb: MSB_ENV.MAINNET };
+};
 
 const toArgMap = (argv) => {
   const out = {};
@@ -54,17 +54,26 @@ const toArgMap = (argv) => {
 
 const ensureTrailingSlash = (value) => (value.endsWith("/") ? value : `${value}/`);
 
-const ensureKeypairFile = async (keyPairPath) => {
-  if (fs.existsSync(keyPairPath)) return;
+const loadOrCreateWallet = async (keyPairPath, walletOptions) => {
   fs.mkdirSync(path.dirname(keyPairPath), { recursive: true });
   await ensureTextCodecs();
-  const wallet = new PeerWallet();
+  const wallet = new PeerWallet(walletOptions);
   await wallet.ready;
+  if (fs.existsSync(keyPairPath)) {
+    wallet.importFromFile(keyPairPath, b4a.alloc(0));
+    return wallet;
+  }
   if (!wallet.secretKey) {
-    await wallet.generateKeyPair();
+    await wallet.generateKeyPair(null, walletOptions?.derivationPath ?? null);
     await wallet.ready;
   }
   wallet.exportToFile(keyPairPath, b4a.alloc(0));
+  return wallet;
+};
+
+const ensureKeypairFile = async (keyPairPath, walletOptions) => {
+  if (fs.existsSync(keyPairPath)) return;
+  await loadOrCreateWallet(keyPairPath, walletOptions);
 };
 
 const readHexFile = (filePath, byteLength) => {
@@ -78,6 +87,11 @@ const readHexFile = (filePath, byteLength) => {
 };
 
 const args = toArgMap(argv);
+const selectedEnvironment = resolveEnvironment(
+  (args["network"] && String(args["network"]).trim().toLowerCase()) ||
+  (process.env.NETWORK && String(process.env.NETWORK).trim().toLowerCase()) ||
+  PEER_ENV.MAINNET
+);
 
 const rpcEnabled =
   args["rpc"] === true || args["rpc"] === "true" || process.env.PEER_RPC === "true" || process.env.PEER_RPC === "1";
@@ -172,18 +186,6 @@ if (!msbBootstrapHex || !msbChannel) {
 // trac-peer currently requires an MSB instance to broadcast and to observe confirmed state.
 
 const effectiveMsbStoreName = msbStoreName ?? `${peerStoreNameRaw}-msb`;
-const msbStoresFullPath = path.join(ensureTrailingSlash(msbStoresDirectory), effectiveMsbStoreName);
-const msbKeyPairPath = path.join(msbStoresFullPath, "db", "keypair.json");
-await ensureKeypairFile(msbKeyPairPath);
-
-const peerKeyPairPath = path.join(
-  peerStoresDirectory,
-  peerStoreNameRaw,
-  "db",
-  "keypair.json"
-);
-
-await ensureKeypairFile(peerKeyPairPath);
 
 const subnetBootstrapFile = path.join(
   peerStoresDirectory,
@@ -208,11 +210,20 @@ if (subnetBootstrap) {
   }
 }
 
-const msb = createMsb({ bootstrap: msbBootstrap, channel: msbChannel, storeName: effectiveMsbStoreName, storesDirectory: msbStoresDirectory})
-await msb.ready();
+const msbConfig = createMsbConfig(selectedEnvironment.msb, {
+  bootstrap: msbBootstrap,
+  channel: msbChannel,
+  storeName: effectiveMsbStoreName,
+  storesDirectory: msbStoresDirectory,
+});
+const walletOptions = {
+  networkPrefix: msbConfig.addressPrefix,
+  derivationPath: msbConfig.derivationPath
+};
+const msbWallet = await loadOrCreateWallet(msbConfig.keyPairPath, walletOptions);
+const msb = new MainSettlementBus(msbConfig, msbWallet);
 
-// DevProtocol and DevContract moved to shared src files
-const peerConfig = createPeerConfig(PEER_ENV.MAINNET, {
+const peerConfig = createPeerConfig(selectedEnvironment.peer, {
   storesDirectory: ensureTrailingSlash(peerStoresDirectory),
   storeName: peerStoreNameRaw,
   bootstrap: subnetBootstrap ? b4a.from(subnetBootstrap, "hex") : null,
@@ -221,10 +232,15 @@ const peerConfig = createPeerConfig(PEER_ENV.MAINNET, {
   apiTxExposed: apiTxExposedEffective,
 });
 
+await ensureKeypairFile(peerConfig.keyPairPath, walletOptions);
+await msb.ready();
+
+// DevProtocol and DevContract moved to shared src files
+
 const peer = new Peer({
   config: peerConfig,
   msb,
-  wallet: new Wallet(),
+  wallet: new Wallet(walletOptions),
   protocol: TuxemonProtocol,
   contract: TuxemonContract,
 });
@@ -277,8 +293,16 @@ if (peer.config.enableInteractiveMode) {
   console.log("Interactive CLI disabled.");
 }
 
-process.on("SIGINT", async () => {
+let shuttingDown = false;
+
+const shutdown = async (signal) => {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
   if (rpcServer) await new Promise((resolve) => rpcServer.close(resolve));
   await Promise.allSettled([peer.close(), msb.close()]);
-  process.exit(130);
-});
+  process.exit(signal === "SIGINT" ? 130 : 143);
+};
+
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));

package/src/config/env.js

@@ -3,9 +3,9 @@ import { Config } from "./config.js";
 export const ENV = {
   MAINNET: "mainnet",
   DEVELOPMENT: "development",
+  TESTNET1: "testnet1",
 };
 // TODO: CREATE TEST ENV CONFIG SIMILAR TO MAINNET AND USE IT IN TESTS.
-// TODO: CREATE TESTNET1 ENV CONFIG and update npm scripts to run node witn mainnet or testnet1.
 
 const configData = {
     [ENV.MAINNET]: {
@@ -32,6 +32,30 @@ const configData = {
         apiMsgExposed: false,
         bootstrap: null,
     },
+    [ENV.TESTNET1]: {
+        channel: "1111trac1network1peer1testnet1111",
+        storesDirectory: "stores/",
+        storeName: "testnet",
+        txPoolMaxSize: 1_000,
+        maxTxDelay: 60,
+        maxMsbSignedLength: 1_000_000_000,
+        maxMsbApplyOperationBytes: 1024 * 1024,
+        enableInteractiveMode: true,
+        enableBackgroundTasks: true,
+        enableUpdater: true,
+        replicate: true,
+        dhtBootstrap: [
+            "116.202.214.149:10001",
+            "157.180.12.214:10001",
+            "node1.hyperdht.org:49737",
+            "node2.hyperdht.org:49737",
+            "node3.hyperdht.org:49737",
+        ],
+        enableTxlogs: false,
+        apiTxExposed: false,
+        apiMsgExposed: false,
+        bootstrap: null,
+    },
     [ENV.DEVELOPMENT]: {
         channel: "unit-test",
         storesDirectory: "stores/",

package/src/msbClient.js

@@ -1,7 +1,7 @@
 import b4a from 'b4a';
 import PeerWallet from 'trac-wallet';
 import ReadyResource from 'ready-resource';
-import PartialTransaction from 'trac-msb/src/core/network/protocols/shared/validators/PartialTransaction.js';
+import PartialTransactionValidator from 'trac-msb/src/core/network/protocols/shared/validators/PartialTransactionValidator.js';
 import { normalizeTransactionOperation } from 'trac-msb/src/utils/normalizers.js';
 
 export const MSB_OPERATION_TYPE = Object.freeze({
@@ -21,7 +21,7 @@ export class MsbClient extends ReadyResource {
 
     async _open() {
         await this.#msb.ready()
-        this.#partialTransactionValidator = new PartialTransaction(this.#msb.state, null, this.#msb.config)
+        this.#partialTransactionValidator = new PartialTransactionValidator(this.#msb.state, null, this.#msb.config)
     }
 
     #orchestratorCompatiblePayload(payload) {
@@ -41,6 +41,10 @@ export class MsbClient extends ReadyResource {
         return this.#msb.config.addressPrefix
     }
 
+    get derivationPath() {
+        return this.#msb.config.derivationPath
+    }
+
     get networkId() {
         return this.#msb.config.networkId
     }

package/src/pearCompat.js

@@ -0,0 +1,49 @@
+const parseSemverMajor = (value) => {
+  const match = /^v?(\d+)\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.exec(
+    String(value ?? "").trim()
+  );
+  return match ? Number(match[1]) : null;
+};
+
+const parseJsonMajor = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+
+  for (const key of ["semver", "SemVer", "version", "pear"]) {
+    const major = parseSemverMajor(value[key]);
+    if (major !== null) return major;
+  }
+
+  return null;
+};
+
+export const parsePearMajor = (output) => {
+  const text = String(output ?? "").trim();
+  if (!text) return null;
+
+  try {
+    const major = parseJsonMajor(JSON.parse(text));
+    if (major !== null) return major;
+  } catch (_e) {}
+
+  const jsonStart = text.indexOf("{");
+  const jsonEnd = text.lastIndexOf("}");
+  if (jsonStart !== -1 && jsonEnd > jsonStart) {
+    try {
+      const major = parseJsonMajor(JSON.parse(text.slice(jsonStart, jsonEnd + 1)));
+      if (major !== null) return major;
+    } catch (_e) {}
+  }
+
+  const labelled = /(?:^|\s)SemVer\s*[:=]\s*v?(\d+)\.\d+\.\d+(?=$|\s)/im.exec(text);
+  if (labelled) return Number(labelled[1]);
+
+  const versions = [
+    ...text.matchAll(/(?:^|[\s/])v?(\d+)\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?=$|\s)/g),
+  ];
+  return versions.length > 0 ? Number(versions[versions.length - 1][1]) : null;
+};
+
+export const selectPearRunnerMode = (output) => {
+  const major = parsePearMajor(output);
+  return major !== null && major < 3 ? "legacy" : "module";
+};

package/src/terminal/handlers.js

@@ -1,4 +1,5 @@
 import b4a from "b4a";
+import process from "process";
 import { createMessage } from 'trac-msb/src/utils/buffer.js';
 import { blake3 } from '@tracsystems/blake3';
 import { MSB_OPERATION_TYPE } from '../msbClient.js';
@@ -486,7 +487,7 @@ class TerminalHandlers {
         console.log('Exiting...');
         if(rl) rl.close();
         await this.#peer.close();
-        typeof process !== "undefined" ? process.exit(0) : Pear.exit(0);
+        process.exit(0);
         return { exit: true };
     }
 }

package/src/terminal/index.js

@@ -1,8 +1,16 @@
 /** @typedef {import('pear-interface')} */ /* global Pear */
+import process from 'process';
 import readline from 'readline';
-import tty from 'tty';
 import { TerminalHandlers } from './handlers.js';
 
+const createTerminalReadline = ({
+    readlineModule = readline,
+    runtimeProcess = process,
+} = {}) => readlineModule.createInterface({
+    input: runtimeProcess.stdin,
+    output: runtimeProcess.stdout,
+});
+
 class Terminal {
     #peer
     #handlers
@@ -51,21 +59,14 @@ class Terminal {
     async start({ readlineInstance = null } = {}) {
         const peer = this.#peer;
         if (!peer) return;
-        if (global.Pear !== undefined && global.Pear.config?.options?.type === 'desktop') return;
+        if (globalThis.Pear !== undefined && globalThis.Pear.config?.options?.type === 'desktop') return;
     
         let rl = readlineInstance;
         if (!rl) {
             try {
-                rl = readline.createInterface({
-                    input: new tty.ReadStream(0),
-                    output: new tty.WriteStream(1),
-                });
+                rl = createTerminalReadline();
             } catch (_e) {
-                try {
-                    rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-                } catch (_e2) {
-                    return;
-                }
+                return;
             }
         }
     
@@ -118,6 +119,4 @@ class Terminal {
     }
 }
 
-export { Terminal };
-
-
+export { Terminal, createTerminalReadline };

package/src/wallet.js

@@ -2,10 +2,6 @@ import PeerWallet from "trac-wallet"
 import b4a from "b4a";
 
 class Wallet extends PeerWallet {
-    constructor() {
-        super();
-    }
-
     get publicKey() {
         const pk = super.publicKey;
         if (!pk) return null;

package/tests/unit/pearCompat.test.js

@@ -0,0 +1,46 @@
+import test from "brittle";
+
+import { parsePearMajor, selectPearRunnerMode } from "../../src/pearCompat.js";
+
+test("pear compat: Pear v2 JSON selects the legacy runner", (t) => {
+  const output = JSON.stringify({
+    key: "example",
+    fork: 0,
+    length: 123,
+    semver: "2.6.5",
+  });
+
+  t.is(parsePearMajor(output), 2);
+  t.is(selectPearRunnerMode(output), "legacy");
+});
+
+test("pear compat: Pear v3 JSON selects the module runner", (t) => {
+  const output = JSON.stringify({
+    key: "example",
+    fork: 0,
+    length: 456,
+    semver: "3.0.0",
+  });
+
+  t.is(parsePearMajor(output), 3);
+  t.is(selectPearRunnerMode(output), "module");
+});
+
+test("pear compat: legacy SemVer output selects the legacy runner", (t) => {
+  const output = [
+    "v0.9609.example / v1.18.0",
+    "Key=example",
+    "Fork=0",
+    "Length=9609",
+    "SemVer=1.18.0",
+  ].join("\n");
+
+  t.is(parsePearMajor(output), 1);
+  t.is(selectPearRunnerMode(output), "legacy");
+});
+
+test("pear compat: unknown output safely selects the module runner", (t) => {
+  t.is(parsePearMajor("Pear development checkout"), null);
+  t.is(selectPearRunnerMode("Pear development checkout"), "module");
+  t.is(selectPearRunnerMode(""), "module");
+});

package/tests/unit/terminalRuntime.test.js

@@ -0,0 +1,25 @@
+import test from "brittle";
+
+import { createTerminalReadline } from "../../src/terminal/index.js";
+
+test("terminal runtime: readline uses process streams", (t) => {
+  const runtimeProcess = { stdin: {}, stdout: {} };
+  const expected = {};
+  let options = null;
+
+  const readlineModule = {
+    createInterface(value) {
+      options = value;
+      return expected;
+    },
+  };
+
+  const actual = createTerminalReadline({
+    readlineModule,
+    runtimeProcess,
+  });
+
+  t.is(actual, expected);
+  t.is(options.input, runtimeProcess.stdin);
+  t.is(options.output, runtimeProcess.stdout);
+});

package/tests/unit/unit.test.js

@@ -8,4 +8,7 @@ await import('./cliTx.test.js');
 await import('./operations.test.js');
 await import('./simFunds.test.js');
 await import('./msbTxValidation.test.js');
+await import('./walletNetworkConfig.test.js');
+await import('./pearCompat.test.js');
+await import('./terminalRuntime.test.js');
 test.resume();

package/tests/unit/walletNetworkConfig.test.js

@@ -0,0 +1,42 @@
+import test from "brittle";
+import b4a from "b4a";
+import PeerWallet from "trac-wallet";
+import { TRAC_NETWORK_MSB_TESTNET1_PREFIX } from "trac-wallet/constants.js";
+import { TRAC_NETWORK_TESTNET_ID } from "trac-crypto-api/constants.js";
+
+import Wallet from "../../src/wallet.js";
+import { createConfig, ENV } from "../../src/index.js";
+
+const MNEMONIC = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+const TESTNET_DERIVATION_PATH = `m/${TRAC_NETWORK_TESTNET_ID}'/0'/0'/0'`;
+
+test("wallet: constructor options are forwarded to trac-wallet", async (t) => {
+  const wallet = new Wallet({
+    networkPrefix: TRAC_NETWORK_MSB_TESTNET1_PREFIX,
+    derivationPath: TESTNET_DERIVATION_PATH,
+    mnemonic: MNEMONIC,
+  });
+  await wallet.ready;
+
+  const expected = new PeerWallet({
+    networkPrefix: TRAC_NETWORK_MSB_TESTNET1_PREFIX,
+    mnemonic: MNEMONIC,
+    derivationPath: TESTNET_DERIVATION_PATH,
+  });
+  await expected.ready;
+
+  t.is(wallet.address, expected.address);
+  t.is(wallet.publicKey, b4a.toString(expected.publicKey, "hex"));
+  t.is(wallet.secretKey, b4a.toString(expected.secretKey, "hex"));
+  t.is(wallet.derivationPath, TESTNET_DERIVATION_PATH);
+});
+
+test("config: TESTNET1 preset is exported and can be instantiated", async (t) => {
+  t.is(ENV.TESTNET1, "testnet1");
+
+  const config = createConfig(ENV.TESTNET1, {});
+
+  t.is(config.storeName, "testnet");
+  t.ok(b4a.isBuffer(config.channel));
+  t.is(config.bootstrap, null);
+});