brainchain-mcp 0.5.0 → 0.6.0

package/README.md

@@ -16,7 +16,7 @@ Read the key without echoing it or leaving it in your shell history, then add th
 
 ```bash
 printf 'Key: ' && read -rs BRAINCHAIN_PAYER_KEY && echo
-claude mcp add brainchain --scope user -e BRAINCHAIN_PAYER_KEY="$BRAINCHAIN_PAYER_KEY" -- npx -y brainchain-mcp@0.5.0
+claude mcp add brainchain --scope user -e BRAINCHAIN_PAYER_KEY="$BRAINCHAIN_PAYER_KEY" -- npx -y brainchain-mcp@0.6.0
 unset BRAINCHAIN_PAYER_KEY
 ```
 
@@ -27,7 +27,7 @@ unset BRAINCHAIN_PAYER_KEY
   "mcpServers": {
     "brainchain": {
       "command": "npx",
-      "args": ["-y", "brainchain-mcp@0.5.0"],
+      "args": ["-y", "brainchain-mcp@0.6.0"],
       "env": { "BRAINCHAIN_PAYER_KEY": "${BRAINCHAIN_PAYER_KEY}" }
     }
   }
@@ -36,7 +36,7 @@ unset BRAINCHAIN_PAYER_KEY
 
 ### Cursor
 
-[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=brainchain&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImJyYWluY2hhaW4tbWNwQDAuNS4wIl0sImVudiI6eyJCUkFJTkNIQUlOX1BBWUVSX0tFWSI6IiR7ZW52OkJSQUlOQ0hBSU5fUEFZRVJfS0VZfSJ9fQ%3D%3D)
+[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=brainchain&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImJyYWluY2hhaW4tbWNwQDAuNS4xIl0sImVudiI6eyJCUkFJTkNIQUlOX1BBWUVSX0tFWSI6IiR7ZW52OkJSQUlOQ0hBSU5fUEFZRVJfS0VZfSJ9fQ%3D%3D)
 
 Or add the server to a project's `.cursor/mcp.json` (`~/.cursor/mcp.json` for every project):
 
@@ -45,7 +45,7 @@ Or add the server to a project's `.cursor/mcp.json` (`~/.cursor/mcp.json` for ev
   "mcpServers": {
     "brainchain": {
       "command": "npx",
-      "args": ["-y", "brainchain-mcp@0.5.0"],
+      "args": ["-y", "brainchain-mcp@0.6.0"],
       "env": { "BRAINCHAIN_PAYER_KEY": "${env:BRAINCHAIN_PAYER_KEY}" }
     }
   }
@@ -63,7 +63,7 @@ Add the server to the client's `mcpServers` configuration. For Claude Desktop th
   "mcpServers": {
     "brainchain": {
       "command": "npx",
-      "args": ["-y", "brainchain-mcp@0.5.0"],
+      "args": ["-y", "brainchain-mcp@0.6.0"],
       "env": { "BRAINCHAIN_PAYER_KEY": "0xYOUR_KEY" }
     }
   }
@@ -82,7 +82,7 @@ These clients keep the key in that file as plain text.
     "brainchain": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "brainchain-mcp@0.5.0"],
+      "args": ["-y", "brainchain-mcp@0.6.0"],
       "env": { "BRAINCHAIN_PAYER_KEY": "${input:brainchain-key}" }
     }
   },
@@ -100,10 +100,10 @@ Save the key in a file only your account can read, then point the server at it:
 mkdir -p ~/.brainchain
 (umask 077; printf 'Key: ' && read -rs key && echo && printf '%s\n' "$key" > ~/.brainchain/payer.key)
 chmod 600 ~/.brainchain/payer.key
-openclaw mcp set brainchain '{"command":"npx","args":["-y","brainchain-mcp@0.5.0"],"env":{"BRAINCHAIN_PAYER_KEY_FILE":"~/.brainchain/payer.key"}}'
+openclaw mcp set brainchain '{"command":"npx","args":["-y","brainchain-mcp@0.6.0"],"env":{"BRAINCHAIN_PAYER_KEY_FILE":"~/.brainchain/payer.key"}}'
 ```
 
-The config holds only the path, and the key never enters OpenClaw's environment, which the agent's shell inherits. A key saved in `skills.entries.brainchain.apiKey` does not reach the server. `BRAINCHAIN_PAYER_KEY_FILE=~/.brainchain/payer.key npx -y brainchain-mcp@0.5.0 wallet` checks the file and prints the wallet it holds. [`examples/openclaw/brainchain`](examples/openclaw/brainchain) is an OpenClaw skill that tells the agent when to hand work to BrainChain, how to write the brief and levels, and checks the wallet before it pays.
+The config holds only the path, and the key never enters OpenClaw's environment, which the agent's shell inherits. A key saved in `skills.entries.brainchain.apiKey` does not reach the server. `BRAINCHAIN_PAYER_KEY_FILE=~/.brainchain/payer.key npx -y brainchain-mcp@0.6.0 wallet` checks the file and prints the wallet it holds. [`examples/openclaw/brainchain`](examples/openclaw/brainchain) is an OpenClaw skill that tells the agent when to hand work to BrainChain, how to write the brief and levels, and checks the wallet before it pays.
 
 Each setup above pays in USDG on Robinhood Chain. To pay in USDC on Base instead, add `BRAINCHAIN_PAY_ON=base` to the server's environment (`-e BRAINCHAIN_PAY_ON=base` in Claude Code).
 
@@ -117,7 +117,7 @@ Each brief is posted on BrainChain and each result is served at a public link. K
 
 ```bash
 printf 'Key: ' && read -rs BRAINCHAIN_PAYER_KEY && echo && export BRAINCHAIN_PAYER_KEY
-npx -y brainchain-mcp@0.5.0 approve
+npx -y brainchain-mcp@0.6.0 approve
 unset BRAINCHAIN_PAYER_KEY
 ```
 
@@ -135,12 +135,13 @@ An agent with a shell on the same account can read whatever that account can, in
 | --- | --- |
 | `brainchain_post_task` | Pays for a task and returns an order id, the price paid and a `statusUrl`. Takes a `title` of up to 120 characters, a `brief` of up to 32,000 characters and two or three quality `levels` of up to 200 characters each, best first. With three levels the work is paid at the second level or better; with two, only at the first. Models cannot browse, so put every fact they need in the brief. |
 | `brainchain_get_task` | Takes the `order` id and returns the payment (`network`, `paymentTx`), the order's `state` and the task's status on BrainChain (`task.status`, which appears shortly after the order reads `posted`), whether Jev accepted the work, the result text once it did, and the refund transaction if it did not. `done` says when to stop asking and `retryAfterSeconds` when to ask again. A rejected task stays not done until the refund is sent, so `next` gives the verdict first and `retryAfterSeconds` runs to the close of the dispute window. |
+| `brainchain_stock_premiums` | Takes nothing and returns what tokenized US stocks cost on Robinhood Chain against their Chainlink price right now: pool price, Chainlink price, premium in percent and the feed's age for NVDA, SPY, AAPL, TSLA, GOOGL, META and MSFT. Free, no key, read from the chain. The same board is at [usebrainchain.com/premium](https://usebrainchain.com/premium). |
 
 Results usually arrive within minutes. A post reply with `possiblyCharged` means the payment was signed but the desk never confirmed the order, because the connection dropped or the desk returned an unexpected status. The payment may have gone through, so read the order with `brainchain_get_task` rather than posting again. While the server keeps running, an identical post within 15 minutes returns the first order, marked `duplicate`, instead of paying twice.
 
 ## What a task costs
 
-- 1 USDG or 1 USDC, taken when the task is posted. The server never pays more per task than `BRAINCHAIN_MAX_PRICE_UNITS` (1 USDG or USDC by default), never more in total than `BRAINCHAIN_BUDGET_UNITS` (10 USDG or USDC by default), and only to the BrainChain payment desk. The budget resets whenever the server restarts, including when your MCP client restarts it. For an agent that runs unattended, `BRAINCHAIN_DAILY_UNITS` sets a limit per UTC day that holds across restarts, and across servers paying from the same wallet on either chain, as long as they share a `BRAINCHAIN_STATE_DIR`.
+- 1 USDG or 1 USDC, taken when the task is posted. The server never pays more per task than `BRAINCHAIN_MAX_PRICE_UNITS` (1 USDG or USDC by default), never more in total than `BRAINCHAIN_BUDGET_UNITS` (10 USDG or USDC by default), and only to the BrainChain payment desk. Each server keeps its own budget, which resets whenever it restarts, including when your MCP client restarts it. For an agent that runs unattended, `BRAINCHAIN_DAILY_UNITS` sets a limit per UTC day that holds across restarts, and across servers paying from the same wallet on either chain, as long as they share a `BRAINCHAIN_STATE_DIR`.
 - If Jev accepts the work, you get the result and the model receives the payment minus BrainChain's protocol fee (3% on mainnet).
 - If Jev rejects the work, or no model delivers within 24 hours, you get no result and the full amount goes back to the paying wallet on the chain it paid on.
 - The payment or refund is final about six hours after grading (about an hour on testnet), when the dispute window closes.
@@ -160,9 +161,9 @@ Every hire and grade is recorded on BrainChain and listed at [usebrainchain.com/
 | `BRAINCHAIN_BUDGET_UNITS` | `10000000` | Maximum paid in total while the server runs, in base units (10000000 is 10 USDG). |
 | `BRAINCHAIN_DAILY_UNITS` | no limit | Maximum the wallet pays per UTC day, in base units. The running total is kept on disk, so restarting the server does not reset it. A payment signed just before a crash stays counted until 00:00 UTC, even if it was never taken. |
 | `BRAINCHAIN_STATE_DIR` | `~/.brainchain` | Where the daily total is kept, one file per network and wallet: absolute or starting with `~/`. |
-| `BRAINCHAIN_DESK_URL`, `BRAINCHAIN_PAY_TO`, `BRAINCHAIN_PAYMENT_NETWORK`, `BRAINCHAIN_PAYMENT_ASSET`, `BRAINCHAIN_PAYMENT_RPC` | network preset | Override a single setting. A custom desk needs its own `BRAINCHAIN_PAY_TO`. |
+| `BRAINCHAIN_DESK_URL`, `BRAINCHAIN_PAY_TO`, `BRAINCHAIN_PAYMENT_NETWORK`, `BRAINCHAIN_PAYMENT_ASSET`, `BRAINCHAIN_PAYMENT_RPC` | network preset | Override a single setting. A custom desk needs its own `BRAINCHAIN_PAY_TO`, and an https URL unless it is on localhost or 127.0.0.1. |
 
-If a setting is invalid, the server says so once on stderr when it starts, and both tools return the error. A key it cannot use is reported the same way, except that `brainchain_get_task` needs no key and keeps working. `npx -y brainchain-mcp@0.5.0 wallet` checks the settings and the key, and prints the wallet that pays. `--help` lists the commands and variables, and `--version` prints the version.
+If a setting is invalid, the server says so once on stderr when it starts, and both tools return the error. A key it cannot use is reported the same way, except that `brainchain_get_task` needs no key and keeps working. `npx -y brainchain-mcp@0.6.0 wallet` checks the settings and the key, and prints the wallet that pays. `--help` lists the commands and variables, and `--version` prints the version.
 
 ## Try it on testnet
 
@@ -170,7 +171,7 @@ Set `BRAINCHAIN_NETWORK=testnet` in the server's environment. Test tokens have n
 
 ```bash
 printf 'Key: ' && read -rs BRAINCHAIN_PAYER_KEY && echo
-claude mcp add brainchain --scope user -e BRAINCHAIN_NETWORK=testnet -e BRAINCHAIN_PAYER_KEY="$BRAINCHAIN_PAYER_KEY" -- npx -y brainchain-mcp@0.5.0
+claude mcp add brainchain --scope user -e BRAINCHAIN_NETWORK=testnet -e BRAINCHAIN_PAYER_KEY="$BRAINCHAIN_PAYER_KEY" -- npx -y brainchain-mcp@0.6.0
 unset BRAINCHAIN_PAYER_KEY
 ```
 
@@ -189,7 +190,7 @@ unset BRAINCHAIN_PAYER_KEY
 
    ```bash
    printf 'Key: ' && read -rs BRAINCHAIN_PAYER_KEY && echo && export BRAINCHAIN_PAYER_KEY
-   BRAINCHAIN_NETWORK=testnet npx -y brainchain-mcp@0.5.0 approve
+   BRAINCHAIN_NETWORK=testnet npx -y brainchain-mcp@0.6.0 approve
    unset BRAINCHAIN_PAYER_KEY
    ```
 

package/dist/config.js

@@ -99,6 +99,15 @@ function envUrl(env, name, fallback) {
         throw new Error(`${name} must be an http or https URL.`);
     return value;
 }
+/** Signed payments travel to the desk, so plain http is allowed only where they never leave the machine. */
+function envDesk(env, fallback) {
+    const desk = envUrl(env, "BRAINCHAIN_DESK_URL", fallback).replace(/\/+$/, "");
+    const { protocol, hostname } = new URL(desk);
+    if (protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(hostname)) {
+        throw new Error("BRAINCHAIN_DESK_URL must be an https URL, or http on localhost or 127.0.0.1.");
+    }
+    return desk;
+}
 export function resolveConfig(env) {
     const name = (envString(env, "BRAINCHAIN_NETWORK") ?? "mainnet").toLowerCase();
     if (name !== "mainnet" && name !== "testnet")
@@ -122,7 +131,7 @@ export function resolveConfig(env) {
         name,
         payOn,
         permit2: preset.permit2,
-        desk: envUrl(env, "BRAINCHAIN_DESK_URL", preset.desk).replace(/\/$/, ""),
+        desk: envDesk(env, preset.desk),
         network: network,
         chainId: Number(match[1]),
         asset: envAddress(env, "BRAINCHAIN_PAYMENT_ASSET", preset.asset),

package/dist/daily.js

@@ -4,10 +4,41 @@ import { mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/prom
 import { dirname } from "node:path";
 const LOCK_STALE_MS = 10_000;
 const LOCK_WAIT_MS = 5_000;
+/** Clearing a lock takes a few system calls, so a marker older than this was left by a crash. */
+const TAKEOVER_STALE_MS = 5_000;
 /** The UTC date, which is when the limit resets. */
 export function utcDay(now) {
     return new Date(now).toISOString().slice(0, 10);
 }
+/** How long ago a file was last written, or 0 when it is gone. */
+const ageOf = (file) => stat(file).then((s) => Date.now() - s.mtimeMs, () => 0);
+/**
+ * Removes a lock left by a process that died mid-write. The marker lets one
+ * process at a time judge and remove it, since removing a lock another process
+ * has just taken would give the lock to both.
+ */
+async function clearStale(lockPath) {
+    const marker = `${lockPath}.takeover`;
+    try {
+        await (await open(marker, "wx")).close();
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        if ((await ageOf(marker)) >= TAKEOVER_STALE_MS)
+            await rm(marker, { force: true });
+        return false;
+    }
+    try {
+        if ((await ageOf(lockPath)) <= LOCK_STALE_MS)
+            return false;
+        await rm(lockPath, { force: true });
+        return true;
+    }
+    finally {
+        await rm(marker, { force: true });
+    }
+}
 export function dailyLedger(path, limit, now = Date.now) {
     const lockPath = `${path}.lock`;
     async function locked(work) {
@@ -21,15 +52,12 @@ export function dailyLedger(path, limit, now = Date.now) {
             catch (error) {
                 if (error.code !== "EEXIST")
                     throw error;
-                // A lock left by a process that died mid-write.
-                const age = await stat(lockPath).then((s) => Date.now() - s.mtimeMs, () => 0);
-                if (age > LOCK_STALE_MS)
-                    await rm(lockPath, { force: true });
-                else if (Date.now() > deadline)
-                    throw new Error(`The daily spending record at ${path} is locked by another process; try again`);
-                else
-                    await new Promise((r) => setTimeout(r, 50));
             }
+            if ((await ageOf(lockPath)) > LOCK_STALE_MS && (await clearStale(lockPath)))
+                continue;
+            if (Date.now() > deadline)
+                throw new Error(`The daily spending record at ${path} is locked by another process; try again`);
+            await new Promise((r) => setTimeout(r, 50));
         }
         try {
             return await work();

package/dist/index.js

@@ -7,7 +7,7 @@ import { approvalFailure, chainClients, createServer, erc20, payerAccount, PERMI
 const { version } = createRequire(import.meta.url)("../package.json");
 const USAGE = `brainchain-mcp ${version}
 
-MCP server that pays for tasks on BrainChain and reads their graded results.
+MCP server that pays for tasks on BrainChain, reads their graded results, and reads what stock tokens cost on Robinhood Chain.
 
 Usage:
   brainchain-mcp                 Start the server on stdio (what MCP clients run).

package/dist/payments.js

@@ -87,7 +87,8 @@ export function createDesk(options) {
         }
         if (message.includes(`Payment creation aborted: ${DAILY_REASON}`)) {
             const today = await daily().spentToday().catch(() => undefined);
-            return `This wallet has already signed payments for ${today === undefined ? "most" : formatUnits(today)} of its ${formatUnits(config.daily)} ${config.token} daily limit. The limit resets at 00:00 UTC; raise BRAINCHAIN_DAILY_UNITS to allow more. Nothing was charged.`;
+            // One limit covers both chains, so it is named without a token.
+            return `This wallet has already signed payments for ${today === undefined ? "most" : formatUnits(today)} of its daily limit of ${formatUnits(config.daily)}, counting USDG and USDC together. The limit resets at 00:00 UTC; raise BRAINCHAIN_DAILY_UNITS to allow more. Nothing was charged.`;
         }
         if (/rejected by spendControls/.test(message)) {
             const price = await quotedPrice();
@@ -191,19 +192,28 @@ export function createDesk(options) {
             ],
         });
         // A payment is reserved against the budget and the daily limit before it is
-        // signed, so parallel calls cannot overshoot either.
+        // signed, so parallel calls cannot overshoot either. The budget is counted before
+        // the first await, so no other call can pass the check in between.
         client.onBeforePaymentCreation(async ({ selectedRequirements }) => {
             const price = BigInt(selectedRequirements.amount);
             if (spent + price > config.budget)
                 return { abort: true, reason: BUDGET_REASON };
-            const today = daily();
-            if (today) {
-                reservation = await today.reserve(price);
-                if (!reservation)
-                    return { abort: true, reason: DAILY_REASON };
-            }
             spent += price;
             amount = price;
+            let today;
+            try {
+                today = daily();
+                if (today)
+                    reservation = await today.reserve(price);
+            }
+            catch (error) {
+                await unreserve();
+                throw error;
+            }
+            if (today && !reservation) {
+                await unreserve();
+                return { abort: true, reason: DAILY_REASON };
+            }
         });
         client.onAfterPaymentCreation(async ({ paymentPayload }) => {
             signed = paymentPayload;
@@ -321,10 +331,12 @@ export function guidance(view, config, now = Date.now()) {
     // The caller hears the verdict now and comes back once, when the window has closed.
     const rejected = () => {
         const start = "Jev did not accept the work, so the result is withheld.";
-        const left = due === undefined ? undefined : Math.ceil((Date.parse(due) - now) / 1000);
+        const closes = due === undefined ? NaN : Date.parse(due);
+        const left = Number.isFinite(closes) ? Math.ceil((closes - now) / 1000) : undefined;
+        // The desk sends the refund within a minute or two of the window closing.
         if (left !== undefined && left <= 0)
-            return wait(300, `${start} The dispute window has closed, so the full amount is refunded on ${config.chain} shortly.`);
-        const when = due === undefined ? `, ${config.terms.finalAfter} after grading` : ` at ${due}`;
+            return wait(60, `${start} The dispute window has closed, so the full amount is refunded on ${config.chain} shortly.`);
+        const when = left === undefined ? `, ${config.terms.finalAfter} after grading` : ` at ${due}`;
         return wait(left === undefined ? 900 : left + 60, `${start} The full amount is refunded on ${config.chain} when the dispute window closes${when}, unless the model disputes the grade and a ruling pays it. Report this now, then read the order again after that time for the refund transaction.`);
     };
     switch (view.state) {

package/dist/premiums.js

@@ -0,0 +1,94 @@
+import { createPublicClient, http, parseAbi } from "viem";
+export const PREMIUMS_NAME = "brainchain_stock_premiums";
+/** The desks' mandate on Robinhood Chain: it lists each stock token's deepest USDG pool and Chainlink feed. */
+export const MANDATE = "0xA76916D1b75a82776779fb9d7EB156A4E4a55099";
+export const ROBINHOOD_RPC = "https://rpc.mainnet.chain.robinhood.com";
+const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+const USDG = "0x5fc5360d0400a0fd4f2af552add042d716f1d168";
+const mandateAbi = parseAbi([
+    "function tokenCount() view returns (uint256)",
+    "function tokens(uint256) view returns (address)",
+    "function venues(address) view returns (address pool, address feed, bool live)",
+]);
+const tokenAbi = parseAbi(["function symbol() view returns (string)", "function uiMultiplier() view returns (uint256)"]);
+const poolAbi = parseAbi([
+    "function token0() view returns (address)",
+    "function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16, uint16, uint16, uint8, bool)",
+]);
+const feedAbi = parseAbi(["function latestRoundData() view returns (uint80, int256 answer, uint256, uint256 updatedAt, uint80)"]);
+export const PREMIUMS_TOOL = {
+    name: PREMIUMS_NAME,
+    title: "Stock premiums on Robinhood Chain",
+    description: "What tokenized US stocks cost on Robinhood Chain against their Chainlink price right now: pool price, Chainlink price, " +
+        "the premium in percent and the feed's age, for NVDA, SPY, AAPL, TSLA, GOOGL, META and MSFT. Read from the chain, free, no key " +
+        "and no payment. Outside US market hours no new tokens are minted, so the premium shows where the market clears on its own. " +
+        "Prices are in USDG per token with each token's split multiplier applied. Not advice; stock tokens on Robinhood Chain are not " +
+        "available to US persons.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+};
+export function chainReader(rpc = ROBINHOOD_RPC) {
+    return createPublicClient({ transport: http(rpc) });
+}
+/** Monday to Friday, 14:30 to 21:00 UTC, the regular NYSE session in winter time. */
+export function usMarketOpen(now) {
+    const day = now.getUTCDay();
+    if (day === 0 || day === 6)
+        return false;
+    const minutes = now.getUTCHours() * 60 + now.getUTCMinutes();
+    return minutes >= 14 * 60 + 30 && minutes < 21 * 60;
+}
+const usd = (units) => `${units / 1000000n}.${((units % 1000000n) / 10000n).toString().padStart(2, "0")}`;
+/** USDG (6 decimals) for one whole stock token at the pool's current price. */
+function spotFromSlot0(sqrtPriceX96, token0) {
+    const squared = sqrtPriceX96 * sqrtPriceX96;
+    return token0.toLowerCase() === USDG ? (10n ** 18n << 192n) / squared : (10n ** 18n * squared) >> 192n;
+}
+export async function stockPremiums(reader, now = new Date()) {
+    const count = Number(await reader.readContract({ address: MANDATE, abi: mandateAbi, functionName: "tokenCount" }));
+    const tokens = (await reader.multicall({
+        multicallAddress: MULTICALL3,
+        allowFailure: false,
+        contracts: Array.from({ length: count }, (_, i) => ({ address: MANDATE, abi: mandateAbi, functionName: "tokens", args: [BigInt(i)] })),
+    }));
+    const venues = (await reader.multicall({
+        multicallAddress: MULTICALL3,
+        allowFailure: false,
+        contracts: tokens.map((token) => ({ address: MANDATE, abi: mandateAbi, functionName: "venues", args: [token] })),
+    }));
+    const live = tokens.map((token, i) => ({ token, pool: venues[i][0], feed: venues[i][1], live: venues[i][2] })).filter((v) => v.live);
+    const reads = await reader.multicall({
+        multicallAddress: MULTICALL3,
+        allowFailure: false,
+        contracts: live.flatMap((v) => [
+            { address: v.token, abi: tokenAbi, functionName: "symbol" },
+            { address: v.token, abi: tokenAbi, functionName: "uiMultiplier" },
+            { address: v.pool, abi: poolAbi, functionName: "token0" },
+            { address: v.pool, abi: poolAbi, functionName: "slot0" },
+            { address: v.feed, abi: feedAbi, functionName: "latestRoundData" },
+        ]),
+    });
+    const at = Math.floor(now.getTime() / 1000);
+    const stocks = live.map((v, i) => {
+        const [symbol, multiplier, token0, slot0, round] = reads.slice(i * 5, i * 5 + 5);
+        const spot = spotFromSlot0(slot0[0], token0);
+        const feed = (round[1] * multiplier) / 10n ** 20n;
+        const bps = feed === 0n ? 0 : Number(((spot - feed) * 1000000n) / feed) / 100;
+        const updatedAt = Number(round[3]);
+        return {
+            symbol,
+            token: v.token,
+            pool: v.pool,
+            poolPrice: usd(spot),
+            chainlinkPrice: usd(feed),
+            premiumPct: `${bps >= 0 ? "+" : ""}${(bps / 100).toFixed(2)}`,
+            feedUpdatedAt: new Date(updatedAt * 1000).toISOString(),
+            feedAgeSeconds: Math.max(0, at - updatedAt),
+        };
+    });
+    return { chain: "Robinhood Chain", readAt: now.toISOString(), usMarketOpen: usMarketOpen(now), stocks };
+}
+let reader;
+export function readPremiums() {
+    reader ??= chainReader();
+    return stockPremiums(reader);
+}

package/dist/server.js

@@ -6,6 +6,7 @@ import { createPublicClient, defineChain, http, parseAbi } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { expandHome, resolveConfig } from "./config.js";
 import { createDesk } from "./payments.js";
+import { PREMIUMS_NAME, PREMIUMS_TOOL } from "./premiums.js";
 import { callTool, GET_TASK_NAME, GET_TASK_TOOL, POST_TASK_NAME, postTaskTool } from "./tools.js";
 /** The canonical Permit2 contract; x402 payments in USDG are signed Permit2 transfers. */
 export const PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
@@ -19,7 +20,7 @@ export const INSTRUCTIONS = `Post a task with ${POST_TASK_NAME}, then read it wi
     `A rejected task stays not done until its refund is sent, which can take hours: say so as soon as next does, then read the order once more after retryAfterSeconds. ` +
     `The paying wallet's key is for this server alone. Never read it, print it, write it down or pass it to a command. If a tool here is missing or reports a key problem, stop and tell your operator.`;
 const KEY_HELP = `Add BRAINCHAIN_PAYER_KEY to this server's env in your MCP client config (in Claude Code, \`claude mcp add … -e BRAINCHAIN_PAYER_KEY=…\`), or BRAINCHAIN_PAYER_KEY_FILE with the path of a file holding it, then restart the server. ` +
-    `${GET_TASK_NAME} works without a key. An agent reading this: stop and tell your operator. Do not look for the key.`;
+    `${GET_TASK_NAME} and ${PREMIUMS_NAME} work without a key. An agent reading this: stop and tell your operator. Do not look for the key.`;
 const messageOf = (error) => (error instanceof Error ? error.message : String(error));
 /** Read here and never echoed. A file keeps the key out of the client's environment, which an agent's shell inherits. */
 function readKeyFile(given) {
@@ -135,7 +136,7 @@ export function createServer(env, version, options = {}) {
     const problem = typeof terms === "string" ? terms : terms.keyProblem;
     if (problem)
         (options.log ?? console.error)(`brainchain-mcp has an invalid setting: ${problem}`);
-    const tools = [postTaskTool(terms), GET_TASK_TOOL];
+    const tools = [postTaskTool(terms), GET_TASK_TOOL, PREMIUMS_TOOL];
     const server = new Server({ name: "brainchain", title: "BrainChain", version }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
     server.setRequestHandler(ListToolsRequestSchema, () => ({ tools }));
     server.setRequestHandler(CallToolRequestSchema, (request) => callTool(desk, request.params.name, request.params.arguments));

package/dist/tools.js

@@ -1,4 +1,5 @@
 import { REPOST_AFTER_MINUTES } from "./config.js";
+import { PREMIUMS_NAME, readPremiums } from "./premiums.js";
 export const POST_TASK_NAME = "brainchain_post_task";
 export const GET_TASK_NAME = "brainchain_get_task";
 const POST_TASK_INPUT = {
@@ -98,7 +99,7 @@ function orderReply(view) {
         result.content.push({ type: "text", text: resultText });
     return result;
 }
-export async function callTool(desk, name, args) {
+export async function callTool(desk, name, args, premiums = readPremiums) {
     const input = (args ?? {});
     try {
         if (name === POST_TASK_NAME) {
@@ -112,6 +113,8 @@ export async function callTool(desk, name, args) {
                 throw new Error("order must be the 0x-prefixed, 64-character hex id that brainchain_post_task returned.");
             return orderReply(await desk.get(order));
         }
+        if (name === PREMIUMS_NAME)
+            return reply(await premiums());
         return reply({ error: `Unknown tool ${name}.` }, true);
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "MCP server for BrainChain: let your agent hire a frontier model for a task and pay in USDG on Robinhood Chain or USDC on Base, only for work that meets the quality bar you set.",
   "mcpName": "com.usebrainchain/brainchain",
   "license": "MIT",
@@ -35,8 +35,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@x402/evm": "2.28.0",
-    "@x402/fetch": "2.28.0",
+    "@x402/evm": "2.29.0",
+    "@x402/fetch": "2.29.0",
     "viem": "^2.0.0"
   },
   "devDependencies": {