trac-peer 0.2.12-rc.1 → 0.3.0

package/.github/workflows/publish.yml

@@ -36,4 +36,4 @@ jobs:
           registry-url: 'https://registry.npmjs.org/'
           cache: 'npm'
       - run: npm ci
-      - run: npm publish --tag rc
+      - run: npm publish --public

package/DOCS.md

@@ -1,6 +1,6 @@
 # trac-peer — Setup & App Guide
 
-This document explains how to run `trac-peer`, connect it to an existing MSB network, create/join a subnet, and test the built‑in demo app (“contract”) (`ping` + `set`), plus chat and the HTTP RPC API.
+This document explains how to run `trac-peer`, connect it to an existing MSB network, create/join a subnet, and test the built‑in demo app (“contract”) (`ping` + `set`), plus the HTTP RPC API used by wallets/apps.
 
 It’s written to be usable even if you’re not deeply familiar with P2P/blockchain systems.
 
@@ -373,9 +373,11 @@ Messages are replicated like any other subnet op.
 
 ---
 
-## HTTP RPC (operator API)
+## HTTP RPC (wallet/app API)
 
-RPC is an HTTP server that runs alongside your peer and lets you control it with requests.
+RPC is an HTTP server that runs alongside your peer and lets a wallet/app connect via URL (Ethereum-style).
+
+Important: operator/admin controls (deploy subnet, writer/indexer management, chat moderation) are **CLI-only** and are not exposed via RPC.
 
 ### Start with RPC enabled (Node)
 
@@ -383,6 +385,7 @@ RPC is an HTTP server that runs alongside your peer and lets you control it with
 npm run peer:run-rpc -- \
   --msb-bootstrap=<hex32> \
   --msb-channel=<channel> \
+  --api-tx-exposed \
   --rpc-host=127.0.0.1 \
   --rpc-port=5001
 ```
@@ -395,6 +398,7 @@ npm run peer:pear-rpc -- \
   --msb-channel=<channel> \
   --msb-store-name=peer-msb-rpc \
   --peer-store-name=peer-rpc \
+  --api-tx-exposed \
   --rpc-host=127.0.0.1 \
   --rpc-port=5001
 ```
@@ -408,25 +412,24 @@ npm run peer:pear-rpc -- \
 
 - Status:
   - `GET /v1/status`
+- Contract schema (JSON Schema; contract tx types + Protocol API methods):
+  - `GET /v1/contract/schema`
 - Read state:
   - `GET /v1/state?key=app%2Fkv%2Ffoo&confirmed=true`
-- Enable chat (admin-only):
-  - `POST /v1/chat/status` body: `{ "enabled": true }`
-- Post message:
-  - `POST /v1/chat/post` body: `{ "message": "hello" }`
-- Broadcast tx:
-  - `POST /v1/tx` body: `{ "command": "set foo bar", "sim": false }`
-- Add writer (admin-only):
-  - `POST /v1/admin/add-writer` body: `{ "key": "<writerKeyHex>" }`
+- Wallet tx flow:
+  - `GET /v1/contract/nonce`
+  - `POST /v1/contract/tx/prepare` body: `{ "prepared_command": { "type": "...", "value": {} }, "address": "<pubkey-hex32>", "nonce": "<hex32>" }`
+  - `POST /v1/contract/tx` body: `{ "tx": "<hex32>", "prepared_command": { ... }, "address": "<pubkey-hex32>", "signature": "<hex64>", "nonce": "<hex32>", "sim": true|false }`
 
 Notes:
-- These RPC endpoints currently operate the **local node** (operator style). They do not accept an external user signature format yet.
+- To allow wallet tx submission, start the peer with `--api-tx-exposed` (or env `PEER_API_TX_EXPOSED=1`).
+- The peer must be subnet-writable (writer) to broadcast a tx.
 
 ---
 
 ## Building your own app (Protocol + Contract)
 
-The runner uses a demo `DevProtocol` and `DevContract` (see `peer-main.mjs` / `scripts/run-peer.mjs`) so you can test quickly.
+The runner uses demo protocol/contract files under `src/dev/` (wired in `scripts/run-peer.mjs`) so you can test quickly.
 
 For a real app, you typically:
 
@@ -443,7 +446,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 "..."` (or call `POST /v1/tx`) the flow is:
+When you run `/tx --command "..."` in the CLI (or a wallet 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.
@@ -452,9 +455,13 @@ When you run `/tx --command "..."` (or call `POST /v1/tx`) the flow is:
 5) Every subnet node applies the subnet op and runs contract logic locally, deriving the same results from the same ordered log.
 
 Where does step (1) happen?
-- In the demo runner (`scripts/run-peer.mjs` / `peer-main.mjs`) it’s in `DevProtocol.mapTxCommand(...)`.
+- In the demo runner (`scripts/run-peer.mjs`) it’s in the protocol class’s `mapTxCommand(...)` (example: `src/dev/pokemonProtocol.js`).
 - The base protocol method is `Protocol.mapTxCommand(...)` in `src/protocol.js`. For your own app you override that function.
 
+Wallet tx flow specifics:
+- The wallet 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.
+
 ---
 
 ## Reset / clean start

package/README.md

@@ -91,13 +91,16 @@ npm run peer:run -- \
 
 ## RPC API (HTTP)
 
-You can start an HTTP API alongside the interactive peer:
+You can start an HTTP API alongside the interactive peer.
+
+This RPC is intended for **wallet/app connectivity** (URL + JSON), not for operating the peer node. Operator/admin actions remain CLI-only.
 
 ```sh
 npm run peer:run -- \
   --msb-bootstrap <32-byte-hex> \
   --msb-channel <channel-string> \
   --rpc \
+  --api-tx-exposed \
   --rpc-host 127.0.0.1 \
   --rpc-port 5001
 ```
@@ -106,17 +109,11 @@ Endpoints (all JSON):
 - `GET /v1/health`
 - `GET /v1/status`
 - `GET /v1/state?key=<hyperbee-key>&confirmed=true|false`
-- `POST /v1/tx` body: `{ "command": "ping hello", "sim": false }`
-- `POST /v1/deploy-subnet`
-- `POST /v1/chat/status` body: `{ "enabled": true }`
-- `POST /v1/chat/post` body: `{ "message": "hello", "reply_to": 1 }`
-- `POST /v1/chat/nick` body: `{ "nick": "alice" }`
-- `POST /v1/admin/add-admin` body: `{ "address": "<pubkey-hex32>" }`
-- `POST /v1/admin/add-writer` body: `{ "key": "<writerKey-hex32>" }`
-- `POST /v1/admin/add-indexer` body: `{ "key": "<writerKey-hex32>" }`
-- `POST /v1/admin/remove-writer` body: `{ "key": "<writerKey-hex32>" }`
-- `POST /v1/msb/join-validator` body: `{ "address": "<msb-bech32m-address>" }`
+- `GET /v1/contract/schema` (JSON Schema; contract tx types + Protocol API methods)
+- `GET /v1/contract/nonce`
+- `POST /v1/contract/tx/prepare` body: `{ "prepared_command": { "type": "...", "value": {} }, "address": "<pubkey-hex32>", "nonce": "<hex32>" }`
+- `POST /v1/contract/tx` body: `{ "tx": "<hex32>", "prepared_command": { ... }, "address": "<pubkey-hex32>", "signature": "<hex64>", "nonce": "<hex32>", "sim": true|false }`
 
 Notes:
-- Write endpoints require the node to be subnet-writable (`/v1/status` shows `peer.baseWritable`).
+- To allow wallet tx submission, start the peer with `--api-tx-exposed` (or env `PEER_API_TX_EXPOSED=1`).
 - RPC request bodies are limited to `1_000_000` bytes by default (override with `--rpc-max-body-bytes`).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-peer",
   "main": "src/index.js",
-  "version": "0.2.12-rc.1",
+  "version": "0.3.0",
   "type": "module",
   "pear": {
     "name": "trac-peer",
@@ -13,11 +13,9 @@
   },
   "exports": {
     ".": {
-      "bare": "./peer.mjs",
       "node": "./src/index.js",
       "default": "./src/index.js"
     },
-    "./peer": "./peer.mjs",
     "./src/*": "./src/*"
   },
   "scripts": {
@@ -57,7 +55,7 @@
     "bare-tls": "2.0.4",
     "bare-tty": "5.0.2",
     "bare-url": "2.1.5",
-    "bare-utils": "1.2.0",
+    "bare-utils": "1.5.1",
     "bare-worker": "3.0.0",
     "bare-zlib": "1.2.5",
     "bip39": "3.1.0",
@@ -85,7 +83,7 @@
     "multicoin-address-validator": "0.5.25",
     "os": "npm:bare-node-os",
     "path": "npm:bare-node-path",
-    "pear-interface": "1.0.0",
+    "pear-interface": "1.1.0",
     "process": "npm:bare-node-process",
     "protomux": "^3.10.1",
     "protomux-wakeup": "^2.4.0",

package/rpc/handlers.js

@@ -3,17 +3,10 @@ import { readJsonBody } from "./utils/body.js";
 import {
   getStatus,
   getState,
-  broadcastTx,
-  deploySubnet,
-  setChatStatus,
-  postChatMessage,
-  setNick,
-  addAdmin,
-  addWriter,
-  addIndexer,
-  removeWriter,
-  removeIndexer,
-  joinValidator,
+  getContractSchema,
+  contractGenerateNonce,
+  contractPrepareTx,
+  contractTx,
 } from "./services.js";
 
 export async function handleHealth({ respond }) {
@@ -33,79 +26,37 @@ export async function handleGetState({ req, respond, peer }) {
   respond(200, { key, confirmed: confirmedBool, value });
 }
 
-export async function handleBroadcastTx({ 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 broadcastTx(peer, { command: body.command, sim: body.sim });
-  respond(200, { payload });
-}
-
-export async function handleDeploySubnet({ req, respond, peer, maxBodyBytes }) {
-  // Optional body for future compatibility.
-  await readJsonBody(req, { maxBytes: maxBodyBytes }).catch(() => null);
-  const payload = await deploySubnet(peer);
-  respond(200, { payload });
-}
-
-export async function handleSetChatStatus({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await setChatStatus(peer, body.enabled);
-  respond(200, { ok: true });
-}
-
-export async function handlePostChatMessage({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await postChatMessage(peer, { message: body.message, reply_to: body.reply_to });
-  respond(200, { ok: true });
+export async function handleGetContractSchema({ respond, peer }) {
+  const schema = await getContractSchema(peer);
+  respond(200, schema);
 }
 
-export async function handleSetNick({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await setNick(peer, { nick: body.nick, user: body.user });
-  respond(200, { ok: true });
+export async function handleContractNonce({ respond, peer }) {
+  const nonce = await contractGenerateNonce(peer);
+  respond(200, { nonce });
 }
 
-export async function handleAddAdmin({ req, respond, peer, maxBodyBytes }) {
+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." });
-  await addAdmin(peer, { address: body.address });
-  respond(200, { ok: true });
+  const payload = await contractPrepareTx(peer, {
+    prepared_command: body.prepared_command,
+    address: body.address,
+    nonce: body.nonce,
+  });
+  respond(200, payload);
 }
 
-export async function handleAddWriter({ req, respond, peer, maxBodyBytes }) {
+export async function handleContractTx({ req, respond, peer, maxBodyBytes }) {
   const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
   if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await addWriter(peer, { key: body.key });
-  respond(200, { ok: true });
-}
-
-export async function handleAddIndexer({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await addIndexer(peer, { key: body.key });
-  respond(200, { ok: true });
-}
-
-export async function handleRemoveWriter({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await removeWriter(peer, { key: body.key });
-  respond(200, { ok: true });
-}
-
-export async function handleRemoveIndexer({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await removeIndexer(peer, { key: body.key });
-  respond(200, { ok: true });
-}
-
-export async function handleJoinValidator({ req, respond, peer, maxBodyBytes }) {
-  const body = await readJsonBody(req, { maxBytes: maxBodyBytes });
-  if (!body || typeof body !== "object") return respond(400, { error: "Missing JSON body." });
-  await joinValidator(peer, { address: body.address });
-  respond(200, { ok: true });
+  const payload = await contractTx(peer, {
+    tx: body.tx,
+    prepared_command: body.prepared_command,
+    address: body.address,
+    signature: body.signature,
+    nonce: body.nonce,
+    sim: body.sim,
+  });
+  respond(200, payload);
 }

package/rpc/routes/v1.js

@@ -2,36 +2,19 @@ import {
   handleHealth,
   handleStatus,
   handleGetState,
-  handleBroadcastTx,
-  handleDeploySubnet,
-  handleSetChatStatus,
-  handlePostChatMessage,
-  handleSetNick,
-  handleAddAdmin,
-  handleAddWriter,
-  handleAddIndexer,
-  handleRemoveWriter,
-  handleRemoveIndexer,
-  handleJoinValidator,
+  handleGetContractSchema,
+  handleContractNonce,
+  handleContractPrepareTx,
+  handleContractTx,
 } from "../handlers.js";
 
 export const v1Routes = [
   { method: "GET", path: "/health", handler: handleHealth },
   { method: "GET", path: "/status", handler: handleStatus },
   { method: "GET", path: "/state", handler: handleGetState },
-
-  { method: "POST", path: "/tx", handler: handleBroadcastTx },
-  { method: "POST", path: "/deploy-subnet", handler: handleDeploySubnet },
-
-  { method: "POST", path: "/chat/status", handler: handleSetChatStatus },
-  { method: "POST", path: "/chat/post", handler: handlePostChatMessage },
-  { method: "POST", path: "/chat/nick", handler: handleSetNick },
-
-  { method: "POST", path: "/admin/add-admin", handler: handleAddAdmin },
-  { method: "POST", path: "/admin/add-writer", handler: handleAddWriter },
-  { method: "POST", path: "/admin/add-indexer", handler: handleAddIndexer },
-  { method: "POST", path: "/admin/remove-writer", handler: handleRemoveWriter },
-  { method: "POST", path: "/admin/remove-indexer", handler: handleRemoveIndexer },
-
-  { method: "POST", path: "/msb/join-validator", handler: handleJoinValidator },
+  { 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: "POST", path: "/contract/tx", handler: handleContractTx },
 ];

package/rpc/services.js

@@ -1,6 +1,5 @@
 import b4a from "b4a";
-import { deploySubnet as deploySubnetFn, setChatStatus as setChatStatusFn, setNick as setNickFn } from "../src/functions.js";
-import { addAdminKey, addWriterKey, addIndexerKey, removeWriterKey, removeIndexerKey, joinValidator as joinValidatorFn } from "../src/functions.js";
+import { fastestToJsonSchema } from "./utils/schemaToJson.js";
 
 const asHex32 = (value, field) => {
   const hex = String(value ?? "").trim().toLowerCase();
@@ -8,6 +7,14 @@ const asHex32 = (value, field) => {
   return hex;
 };
 
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+
+const requireApi = (peer) => {
+  const api = peer?.protocol_instance?.api;
+  if (!api) throw new Error("Protocol API not initialized.");
+  return api;
+};
+
 export async function getStatus(peer) {
   const subnetBootstrapHex = b4a.isBuffer(peer.bootstrap)
     ? b4a.toString(peer.bootstrap, "hex")
@@ -44,107 +51,112 @@ export async function getStatus(peer) {
   };
 }
 
-export async function getState(peer, key, { confirmed = true } = {}) {
-  const k = String(key ?? "");
-  if (!k) throw new Error("Missing key.");
-  if (!peer.base?.view) throw new Error("Peer view not ready.");
-  if (confirmed) {
-    const viewSession = peer.base.view.checkout(peer.base.view.core.signedLength);
-    try {
-      const res = await viewSession.get(k);
-      return res?.value ?? null;
-    } finally {
-      await viewSession.close();
-    }
+const inferPrototypeOps = (contract) => {
+  const proto = Object.getPrototypeOf(contract);
+  const baseProto = Object.getPrototypeOf(proto);
+  const baseNames = new Set(Object.getOwnPropertyNames(baseProto ?? {}));
+  const names = Object.getOwnPropertyNames(proto);
+  const ops = [];
+  for (const name of names) {
+    if (name === "constructor") continue;
+    if (name.startsWith("_")) continue;
+    if (baseNames.has(name)) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, name);
+    if (!desc || typeof desc.value !== "function") continue;
+    ops.push(name);
   }
-  const res = await peer.base.view.get(k);
-  return res?.value ?? null;
-}
+  return ops;
+};
 
-export async function broadcastTx(peer, { command, sim = false } = {}) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required for /tx).");
-  const cmd = command;
-  if (!cmd) throw new Error("Missing command.");
-  return await peer.protocol_instance.tx({ command: cmd }, !!sim);
-}
+const convertContractOpSchema = (fv) => {
+  if (!isObject(fv)) return { value: {} };
+  const out = {};
+  if (fv.key !== undefined) out.key = fastestToJsonSchema(fv.key);
+  if (fv.value !== undefined) out.value = fastestToJsonSchema(fv.value);
+  if (Object.keys(out).length === 0) out.value = fastestToJsonSchema(fv);
+  return out;
+};
 
-export async function deploySubnet(peer) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required for /deploy-subnet).");
-  return await deploySubnetFn("/deploy_subnet", peer);
-}
+export async function getContractSchema(peer) {
+  const contract = peer?.contract_instance;
+  if (!contract) throw new Error("Contract instance not initialized.");
 
-export async function setChatStatus(peer, enabled) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const on = enabled === true || enabled === 1 || enabled === "1";
-  return await setChatStatusFn(`/set_chat_status --enabled ${on ? 1 : 0}`, peer);
-}
+  const registrations = contract.metadata ?? {};
+  const regSchemas = registrations.schemas ?? {};
+  const regFunctions = registrations.functions ?? {};
+  const regFeatures = registrations.features ?? {};
+
+  const schemaNames = Object.keys(regSchemas);
+  const functionNames = Object.keys(regFunctions);
+  const featureNames = Object.keys(regFeatures);
 
-export async function postChatMessage(peer, { message, reply_to = null } = {}) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const chatStatus = await peer.base.view.get('chat_status');
-  if (chatStatus === null || chatStatus.value !== 'on') throw new Error('Chat is disabled.');
-  const msg = String(message ?? "");
-  if (!msg.trim()) throw new Error("Empty message not allowed.");
-  if (b4a.byteLength(msg) > peer.protocol_instance.msgMaxBytes()) throw new Error("Message too large.");
-  const nonce = peer.protocol_instance.generateNonce();
-  const signature = {
-    dispatch: {
-      type: "msg",
-      msg,
-      address: peer.wallet.publicKey,
-      attachments: [],
-      deleted_by: null,
-      reply_to: reply_to != null ? parseInt(reply_to) : null,
-      pinned: false,
-      pin_id: null,
+  const hasAnyExplicit = schemaNames.length > 0 || functionNames.length > 0 || featureNames.length > 0;
+
+  const inferred = hasAnyExplicit ? [] : inferPrototypeOps(contract);
+  const txTypes = [...new Set([...schemaNames, ...functionNames, ...featureNames, ...inferred])].sort();
+
+  const ops = {};
+  for (const type of txTypes) {
+    if (regSchemas[type] !== undefined) ops[type] = convertContractOpSchema(regSchemas[type]);
+    else ops[type] = { value: {} };
+  }
+
+  return {
+    schemaVersion: 1,
+    schemaFormat: "json-schema",
+    contract: {
+      contractClass: contract.constructor?.name ?? null,
+      protocolClass: peer.protocol_instance?.constructor?.name ?? null,
+      txTypes,
+      ops,
     },
+    api: peer.protocol_instance?.getApiSchema ? peer.protocol_instance.getApiSchema() : { methods: {} },
   };
-  const hash = peer.wallet.sign(JSON.stringify(signature) + nonce);
-  await peer.base.append({ type: "msg", value: signature, hash, nonce });
-  return { ok: true };
 }
 
-export async function setNick(peer, { nick, user = null } = {}) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const n = String(nick ?? "").trim();
-  if (!n) throw new Error("Missing nick.");
-  const u = user != null ? String(user).trim().toLowerCase() : null;
-  const input = u ? `/set_nick --nick "${n}" --user "${u}"` : `/set_nick --nick "${n}"`;
-  return await setNickFn(input, peer);
+export async function contractGenerateNonce(peer) {
+  const api = requireApi(peer);
+  return api.generateNonce();
 }
 
-export async function addAdmin(peer, { address }) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const pk = asHex32(address, "address");
-  return await addAdminKey(pk, peer);
-}
+export async function contractPrepareTx(peer, { prepared_command, address, nonce } = {}) {
+  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");
 
-export async function addWriter(peer, { key }) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const wk = asHex32(key, "key");
-  return await addWriterKey(wk, peer);
-}
+  if (peer?.protocol_instance?.safeJsonStringify == null) {
+    throw new Error("safeJsonStringify is not available on protocol instance.");
+  }
 
-export async function addIndexer(peer, { key }) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const wk = asHex32(key, "key");
-  return await addIndexerKey(wk, peer);
-}
+  const json = peer.protocol_instance.safeJsonStringify(prepared_command);
+  if (json == null) throw new Error("Failed to stringify prepared_command.");
 
-export async function removeWriter(peer, { key }) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const wk = asHex32(key, "key");
-  return await removeWriterKey(wk, peer);
+  const command_hash = await peer.createHash("blake3", json);
+  const tx = await api.generateTx(addr, command_hash, n);
+  return { tx, command_hash };
 }
 
-export async function removeIndexer(peer, { key }) {
-  if (!peer.base?.writable) throw new Error("Peer subnet is not writable (writer required).");
-  const wk = asHex32(key, "key");
-  return await removeIndexerKey(wk, peer);
+export async function contractTx(peer, { tx, prepared_command, address, signature, nonce, sim = false } = {}) {
+  const api = requireApi(peer);
+  if (!isObject(prepared_command)) throw new Error("prepared_command must be an object.");
+  const res = await api.tx(tx, prepared_command, address, signature, nonce, sim === true);
+  return { result: res };
 }
 
-export async function joinValidator(peer, { address }) {
-  const addr = String(address ?? "").trim();
-  if (!addr) throw new Error("Missing address.");
-  return await joinValidatorFn(`/join_validator --address ${addr}`, peer);
+export async function getState(peer, key, { confirmed = true } = {}) {
+  const k = String(key ?? "");
+  if (!k) throw new Error("Missing key.");
+  if (!peer.base?.view) throw new Error("Peer view not ready.");
+  if (confirmed) {
+    const viewSession = peer.base.view.checkout(peer.base.view.core.signedLength);
+    try {
+      const res = await viewSession.get(k);
+      return res?.value ?? null;
+    } finally {
+      await viewSession.close();
+    }
+  }
+  const res = await peer.base.view.get(k);
+  return res?.value ?? null;
 }