trac-peer 0.4.4 → 0.4.6

package/APP_DEV.md

@@ -118,7 +118,7 @@ Endpoints (all JSON, all under `/v1`):
 - `GET /v1/status`
 - `GET /v1/contract/schema`
 - `GET /v1/contract/nonce`
-- `POST /v1/contract/tx/prepare`
+- `GET /v1/contract/tx/context` (returns MSB tx context)
 - `POST /v1/contract/tx`
 - `GET /v1/state?key=<urlencoded>&confirmed=true|false`
 
@@ -128,19 +128,20 @@ Important notes:
 
 ---
 
-## 6) Wallet → peer → contract flow (end-to-end)
+## 6) Client → peer → contract flow (end-to-end)
 
-This is the “Ethereum-style” flow: wallet discovers a peer URL, fetches a schema, prepares a tx, signs locally, then submits it.
+This is the “Ethereum-style” flow: a client (typically a dapp/backend) discovers a peer URL, fetches a schema, prepares a tx, requests a wallet signature, then submits it.
 
-### Where the dapp fits
+### Where the dapp fits (dapp constructs, wallet signs)
 
-- A **dapp** (web/mobile UI) talks to a peer’s RPC URL to fetch `GET /v1/contract/schema` and to read state via `GET /v1/state`.
-- For writes, the dapp asks the wallet to:
-  1) request `nonce` + `prepare` from the peer,
-  2) sign the returned `tx` hash locally,
-  3) submit `sim: true` then `sim: false` to the peer.
+- A **dapp** (web/mobile UI) can read: `GET /v1/contract/schema` and `GET /v1/state`.
+- For **writes**, the dapp (or a backend the dapp calls) typically:
+  1) fetches `nonce` + `tx/context` from the peer,
+  2) constructs the tx hash (`tx`) locally,
+  3) asks the wallet to **sign** the tx hash,
+  4) submits `sim: true` then `sim: false` to the peer.
 
-In other words: the dapp never needs the private key; it just passes data between the peer RPC and the wallet signer.
+In other words: the wallet only needs to sign; it does not need to talk to the peer RPC.
 
 ### Step A — Discover contract schema
 
@@ -148,42 +149,44 @@ In other words: the dapp never needs the private key; it just passes data betwee
 curl -s http://127.0.0.1:5001/v1/contract/schema | jq
 ```
 
-Wallet uses:
+Client uses:
 - `contract.txTypes` (what tx types exist)
 - `contract.ops[type]` (input structure for each type, when available)
 - `api.methods` (optional read/query methods exposed by the protocol api)
 
-### Step B — Get a nonce
+### Step B — Get a nonce (client)
 
 ```sh
 curl -s http://127.0.0.1:5001/v1/contract/nonce | jq
 ```
 
-### Step C — Prepare a tx hash to sign
+### Step C — Get tx context + build tx hash (client)
 
-The wallet constructs a typed command (this is app-specific):
+The client constructs a typed command (this is app-specific):
 
 ```json
 { "type": "catch", "value": {} }
 ```
 
-Then it asks the peer to compute the `tx` hash:
+Then the client asks the peer for the MSB tx context (no computation):
 
 ```sh
-curl -s -X POST http://127.0.0.1:5001/v1/contract/tx/prepare \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "prepared_command": { "type": "catch", "value": {} },
-    "address": "<wallet-pubkey-hex32>",
-    "nonce": "<nonce-hex32>"
-  }' | jq
+curl -s http://127.0.0.1:5001/v1/contract/tx/context | jq
 ```
 
-The response contains:
-- `tx` (hex32): the exact 32-byte tx hash that must be signed
-- `command_hash` (hex32): hash of the prepared command (used by MSB payload)
+The response contains an `msb` object with the fields the client needs to build the tx preimage:
+- `networkId`
+- `txv`
+- `iw` (peer writer key)
+- `bs` (subnet bootstrap)
+- `mbs` (MSB bootstrap)
+- `operationType` (currently `12`)
+
+From there, the client computes locally:
+- `command_hash = blake3(JSON.stringify(prepared_command))` (hex32)
+- `tx = blake3(createMessage(networkId, txv, iw, command_hash, bs, mbs, nonce, operationType))` (hex32)
 
-### Step D — Sign locally in the wallet
+### Step D — Sign locally with the wallet
 
 Wallet signs the **bytes** of `tx` (32 bytes) with its private key to produce:
 - `signature` (hex64)
@@ -222,10 +225,17 @@ curl -s -X POST http://127.0.0.1:5001/v1/contract/tx \
 
 ### Step G — Read app state
 
-Apps typically write under `app/...`. Read via:
+Apps typically write under `app/...` (app-defined). Read via:
 
 ```sh
-curl -s 'http://127.0.0.1:5001/v1/state?key=app%tuxedex%2F<wallet-pubkey-hex32>&confirmed=false' | jq
+curl -s 'http://127.0.0.1:5001/v1/state?key=<urlencoded-hyperbee-key>&confirmed=false' | jq
+```
+
+Example (Tuxemon demo app):
+
+```sh
+curl -s 'http://127.0.0.1:5001/v1/state?key=app%2Ftuxedex%2F<wallet-pubkey-hex32>&confirmed=false' | jq
+```
 ```
 
 The `confirmed` flag controls whether you read from:

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> \
@@ -418,9 +424,9 @@ npm run peer:pear-rpc -- \
   - `GET /v1/contract/schema`
 - Read state:
   - `GET /v1/state?key=app%2Fkv%2Ffoo&confirmed=true`
-- Wallet/dApp tx flow:
+- Client tx flow (dapp constructs, wallet signs):
   - `GET /v1/contract/nonce`
-  - `POST /v1/contract/tx/prepare` body: `{ "prepared_command": { "type": "...", "value": {} }, "address": "<pubkey-hex32>", "nonce": "<hex32>" }`
+  - `GET /v1/contract/tx/context` (returns MSB tx context for client-side tx derivation)
   - `POST /v1/contract/tx` body: `{ "tx": "<hex32>", "prepared_command": { ... }, "address": "<pubkey-hex32>", "signature": "<hex64>", "nonce": "<hex32>", "sim": true|false }`
 
 Notes:
@@ -446,7 +452,7 @@ All nodes in the subnet must run the same Protocol/Contract logic for determinis
 
 ## How `/tx` works (the lifecycle)
 
-When you run `/tx --command "..."` in the CLI (or a wallet uses the RPC tx flow), the flow is:
+When you run `/tx --command "..."` in the CLI (or a client uses the RPC tx flow), the flow is:
 
 1) The command string is mapped into an operation object: `{ type, value }`.
 2) trac-peer hashes and signs the operation and broadcasts a settlement tx to MSB.
@@ -458,9 +464,11 @@ Where does step (1) happen?
 - In the demo runner (`scripts/run-peer.mjs`) it’s in the protocol class’s `mapTxCommand(...)` (example: `src/dev/tuxemonProtocol.js`).
 - The base protocol method is `Protocol.mapTxCommand(...)` in `src/protocol.js`. For your own app you override that function.
 
-dApp tx flow specifics:
-- The dApp sends a typed command (`prepared_command`) and asks the peer to compute `tx` via `POST /v1/contract/tx/prepare`.
-- The wallet signs `tx` and submits it to `POST /v1/contract/tx` with `sim: true` to simulate (recommended), then `sim: false` to broadcast.
+Client tx flow specifics:
+- The client fetches MSB tx context from `GET /v1/contract/tx/context`.
+- The client computes `command_hash = blake3(JSON.stringify(prepared_command))`, then computes `tx` from the MSB preimage fields + `nonce`.
+- The wallet signs `tx`.
+- The client submits the signed payload to `POST /v1/contract/tx` with `sim: true` to simulate (recommended), then `sim: false` to broadcast.
 
 ---
 

package/PEER_RPC.md

@@ -0,0 +1,189 @@
+# trac-peer RPC (HTTP) — API Reference
+
+This is a **reference** for the public HTTP RPC exposed by `trac-peer`.
+
+Base URL example:
+- `http://127.0.0.1:5001`
+
+All endpoints below are under the `/v1` prefix.
+
+## Conventions
+
+- All responses are JSON.
+- Request bodies (where applicable) are JSON.
+- Hex formats:
+  - `hex32`: 32-byte hex string (64 hex chars)
+  - `hex64`: 64-byte hex string (128 hex chars)
+
+## Errors
+
+Error responses have the shape:
+
+```json
+{ "error": "message" }
+```
+
+Common status codes:
+- `200` success
+- `400` bad request (missing/invalid parameters)
+- `404` not found (unknown route)
+- `413` request body too large
+- `500` internal error
+
+---
+
+## `GET /v1/health`
+
+Health check.
+
+### Response `200`
+
+```json
+{ "ok": true }
+```
+
+---
+
+## `GET /v1/status`
+
+Returns a status summary for the running peer and its MSB client view.
+
+### Query parameters
+None
+
+### Response `200`
+
+Object with:
+- `peer`: identifiers + subnet view info (writability, signed length, bootstrap, etc.)
+- `msb`: MSB bootstrap/networkId/signedLength as seen by this peer’s MSB client
+
+---
+
+## `GET /v1/contract/schema`
+
+Returns an ABI-like schema describing:
+- which contract tx types exist (`contract.txTypes`)
+- optional per-tx input structure (`contract.ops`)
+- the Protocol API method schema (`api.methods`)
+
+### Query parameters
+None
+
+### Response `200`
+
+```json
+{
+  "schemaVersion": 1,
+  "schemaFormat": "json-schema",
+  "contract": {
+    "contractClass": "TuxemonContract",
+    "protocolClass": "TuxemonProtocol",
+    "txTypes": ["catch"],
+    "ops": {
+      "catch": { "value": {} }
+    }
+  },
+  "api": { "methods": {} }
+}
+```
+
+---
+
+## `GET /v1/contract/nonce`
+
+Generates a nonce for signing.
+
+### Query parameters
+None
+
+### Response `200`
+
+```json
+{ "nonce": "<hex32>" }
+```
+
+---
+
+## `GET /v1/contract/tx/context`
+
+Returns the MSB transaction context needed by a client/dapp to compute the `tx` hash locally.
+
+### Query parameters
+None
+
+### Response `200`
+
+```json
+{
+  "msb": {
+    "networkId": 918,
+    "txv": "<hex32>",
+    "iw": "<hex32>",
+    "bs": "<hex32>",
+    "mbs": "<hex32>",
+    "operationType": 12
+  }
+}
+```
+
+---
+
+## `POST /v1/contract/tx`
+
+Simulates or broadcasts a signed contract transaction.
+
+### Request body (JSON)
+
+Required fields:
+- `tx` (`hex32`): transaction hash computed by the client/dapp
+- `prepared_command` (`object`): `{ "type": "<string>", "value": <any> }`
+- `address` (`hex32`): wallet public key (hex) used for signature verification
+- `signature` (`hex64`): ed25519 signature over `tx` bytes
+- `nonce` (`hex32`)
+
+Optional:
+- `sim` (`boolean`, default `false`): when `true`, run MSB preflight + contract simulation; when `false`, broadcast
+
+Example:
+
+```json
+{
+  "tx": "<hex32>",
+  "prepared_command": { "type": "catch", "value": {} },
+  "address": "<hex32>",
+  "signature": "<hex64>",
+  "nonce": "<hex32>",
+  "sim": true
+}
+```
+
+### Response `200`
+
+```json
+{ "result": {} }
+```
+
+Result shape is protocol-dependent.
+
+---
+
+## `GET /v1/state`
+
+Reads a single key from the subnet state (Hyperbee).
+
+### Query parameters
+
+- `key` (required, string): the exact Hyperbee key to read
+- `confirmed` (optional, boolean, default `true`):
+  - `true`: read from signed/confirmed view
+  - `false`: read from latest local view
+
+### Response `200`
+
+```json
+{
+  "key": "app/tuxedex/<pubKeyHex>",
+  "confirmed": false,
+  "value": {}
+}
+```

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.4",
+  "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/rpc/handlers.js

@@ -5,7 +5,7 @@ import {
   getState,
   getContractSchema,
   contractGenerateNonce,
-  contractPrepareTx,
+  contractTxContext,
   contractTx,
 } from "./services.js";
 
@@ -36,14 +36,8 @@ export async function handleContractNonce({ respond, peer }) {
   respond(200, { nonce });
 }
 
-export async function handleContractPrepareTx({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  const payload = await contractPrepareTx(peer, {
-    prepared_command: body.prepared_command,
-    address: body.address,
-    nonce: body.nonce,
-  });
+export async function handleContractTxContext({ req, respond, peer, maxBodyBytes }) {
+  const payload = await contractTxContext(peer);
   respond(200, payload);
 }
 

package/rpc/routes/v1.js

@@ -4,7 +4,7 @@ import {
   handleGetState,
   handleGetContractSchema,
   handleContractNonce,
-  handleContractPrepareTx,
+  handleContractTxContext,
   handleContractTx,
 } from "../handlers.js";
 
@@ -13,8 +13,7 @@ export const v1Routes = [
   { method: "GET", path: "/status", handler: handleStatus },
   { method: "GET", path: "/state", handler: handleGetState },
   { method: "GET", path: "/contract/schema", handler: handleGetContractSchema },
-  // Wallet→peer flow: server-side tx prepare + wallet signature + broadcast.
   { method: "GET", path: "/contract/nonce", handler: handleContractNonce },
-  { method: "POST", path: "/contract/tx/prepare", handler: handleContractPrepareTx },
+  { method: "GET", path: "/contract/tx/context", handler: handleContractTxContext },
   { method: "POST", path: "/contract/tx", handler: handleContractTx },
 ];

package/rpc/services.js

@@ -1,12 +1,5 @@
 import b4a from "b4a";
 import { fastestToJsonSchema } from "./utils/schemaToJson.js";
-import { createHash } from "../src/utils/types.js";
-
-const asHex32 = (value, field) => {
-  const hex = String(value ?? "").trim().toLowerCase();
-  if (!/^[0-9a-f]{64}$/.test(hex)) throw new Error(`Invalid ${field}. Expected 32-byte hex (64 chars).`);
-  return hex;
-};
 
 const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 
@@ -17,10 +10,10 @@ const requireApi = (peer) => {
 };
 
 export async function getStatus(peer) {
-  const subnetBootstrapHex = b4a.isBuffer(peer.bootstrap)
-    ? b4a.toString(peer.bootstrap, "hex")
-    : peer.bootstrap != null
-      ? String(peer.bootstrap)
+  const subnetBootstrapHex = b4a.isBuffer(peer.config.bootstrap)
+    ? b4a.toString(peer.config.bootstrap, "hex")
+    : peer.config.bootstrap != null
+      ? String(peer.config.bootstrap)
       : null;
 
   const peerMsbAddress = peer.msbClient.pubKeyHexToAddress(peer.wallet.publicKey);
@@ -120,22 +113,34 @@ export async function contractGenerateNonce(peer) {
   return api.generateNonce();
 }
 
-export async function contractPrepareTx(peer, { prepared_command, address, nonce } = {}) {
+export async function contractTxContext(peer) {
   const api = requireApi(peer);
-  if (!isObject(prepared_command)) throw new Error("prepared_command must be an object.");
-  const addr = asHex32(address, "address");
-  const n = asHex32(nonce, "nonce");
 
-  if (peer?.protocol.instance?.safeJsonStringify == null) {
-    throw new Error("safeJsonStringify is not available on protocol instance.");
-  }
+  const networkId = peer.msbClient.networkId;
+  const mbs = peer.msbClient.bootstrapHex;
+  const txv = await peer.msbClient.getTxvHex();
+
+  const bs =
+    b4a.isBuffer(peer.config.bootstrap)
+      ? b4a.toString(peer.config.bootstrap, "hex")
+      : peer.config.bootstrap != null
+        ? String(peer.config.bootstrap)
+        : null;
 
-  const json = peer.protocol.instance.safeJsonStringify(prepared_command);
-  if (json == null) throw new Error("Failed to stringify prepared_command.");
+  const iw = peer.writerLocalKey ?? api.getPeerWriterKey?.();
+  if (!iw || !/^[0-9a-f]{64}$/i.test(String(iw))) throw new Error("Peer writer key is not available.");
+  if (!bs || !/^[0-9a-f]{64}$/i.test(String(bs))) throw new Error("Peer subnet bootstrap is not available.");
 
-  const command_hash = await createHash(json);
-  const tx = await api.generateTx(addr, command_hash, n);
-  return { tx, command_hash };
+  return {
+    msb: {
+      networkId,
+      txv,
+      iw: String(iw).toLowerCase(),
+      bs: String(bs).toLowerCase(),
+      mbs: String(mbs).toLowerCase(),
+      operationType: 12,
+    },
+  };
 }
 
 export async function contractTx(peer, { tx, prepared_command, address, signature, nonce, sim = false } = {}) {

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/acceptance/rpc.test.js

@@ -12,6 +12,7 @@ import { Peer, Protocol, Contract, createConfig, ENV } from "../../src/index.js"
 import TuxemonContract from "../../dev/tuxemonContract.js";
 import TuxemonProtocol from "../../dev/tuxemonProtocol.js";
 import Wallet from "../../src/wallet.js";
+import { createHash, jsonStringify } from "../../src/utils/types.js";
 import { mkdtempPortable, rmrfPortable } from "../helpers/tmpdir.js";
 
 async function withTempDir(fn) {
@@ -205,10 +206,13 @@ test("rpc: body size limit returns 413", async (t) => {
       const baseUrl = rpc.baseUrl;
 
       const big = "x".repeat(100);
-      const r = await httpJson("POST", `${baseUrl}/v1/contract/tx/prepare`, {
+      const r = await httpJson("POST", `${baseUrl}/v1/contract/tx`, {
+        tx: "0".repeat(64),
         prepared_command: { type: big, value: {} },
         address: wallet.publicKey,
+        signature: "0".repeat(128),
         nonce: "0".repeat(64),
+        sim: true,
       });
       t.is(r.status, 413);
     } finally {
@@ -281,13 +285,25 @@ test("rpc: wallet-signed tx simulate via prepare+sign+broadcast", async (t) => {
       const nonce = nonceRes.json?.nonce;
 
       const prepared_command = { type: "catch", value: {} };
-      const prep = await httpJson("POST", `${baseUrl}/v1/contract/tx/prepare`, {
-        prepared_command,
-        address: externalWallet.publicKey,
-        nonce,
-      });
-      t.is(prep.status, 200);
-      const tx = prep.json?.tx;
+      const ctx = await httpJson("GET", `${baseUrl}/v1/contract/tx/context`);
+      t.is(ctx.status, 200);
+      t.is(ctx.json?.msb?.operationType, 12);
+      t.is(typeof ctx.json?.msb?.networkId, "number");
+      t.is(typeof ctx.json?.msb?.txv, "string");
+      t.is(typeof ctx.json?.msb?.iw, "string");
+      t.is(typeof ctx.json?.msb?.bs, "string");
+      t.is(typeof ctx.json?.msb?.mbs, "string");
+
+      const command_hash = await createHash(jsonStringify(prepared_command));
+      const tx = await peer.protocol.instance.generateTx(
+        ctx.json.msb.networkId,
+        ctx.json.msb.txv,
+        ctx.json.msb.iw,
+        command_hash,
+        ctx.json.msb.bs,
+        ctx.json.msb.mbs,
+        nonce
+      );
 
       const signature = externalWallet.sign(b4a.from(tx, "hex"));
       const simRes = await httpJson("POST", `${baseUrl}/v1/contract/tx`, {

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