mycomesh-consumer 0.8.0 → 0.9.1

package/networks/mycomesh-v11-sepolia.json

@@ -6,7 +6,7 @@
   "stablecoin": "0xbce27efad4191277167fe76819581a97959048cf",
   "registry": "0x0ff3210e8e8abf5f5bfa73a39e60db7416b6c8c7",
   "relay_directory": "0xa0aaad9393f51cb5786c69f152133a174588bdab",
-  "probe_ledger": "0x3bbc6fc971a6c4e528af9228b95d4b83ef188795",
+  "probe_ledger": "0x1f26a2285eb366d0fd201bea6969abd1aaacb62b",
   "emission": "0x85ee0e8f63400041f0c76010c590c330bc135a8d",
   "token": "0x620d026ad854fb17c7b16534a0f28ef5499e2d4a",
   "emission_block": 11815544,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "MycoMesh V11 Consumer: a custodied deposit, relay-blind encrypted requests to any Provider, and a local OpenAI-compatible endpoint.",
   "repository": {
     "type": "git",

package/src/chain.mjs

@@ -22,6 +22,17 @@ export async function rpcCall(urls, method, params, { timeoutMs = 15000 } = {})
 
 export const quantity = (value) => BigInt(value);
 
+/** eth_getLogs that tolerates a load-balanced RPC answering from a node a block or two behind the head. */
+export async function getLogs(urls, filter) {
+  try {
+    return await rpcCall(urls, "eth_getLogs", [filter]);
+  } catch (error) {
+    if (!/beyond current head/.test(error.message)) throw error;
+    const to = BigInt(filter.toBlock) - 3n;
+    return to < BigInt(filter.fromBlock) ? [] : rpcCall(urls, "eth_getLogs", [{ ...filter, toBlock: `0x${to.toString(16)}` }]);
+  }
+}
+
 export async function ethCallWord(urls, to, data) {
   return BigInt(await rpcCall(urls, "eth_call", [{ to, data }, "latest"]));
 }
@@ -30,14 +41,27 @@ export async function availableBalance(network, owner) {
   return ethCallWord(network.rpc_urls, network.settlement, encodeCall("availableBalance(address)", [["address", owner]]));
 }
 
+/**
+ * Twice the latest base fee plus the suggested tip, as EIP-1559 wallets cap a fee. Some nodes (anvil)
+ * derive eth_gasPrice from recent transactions, so pricing above it compounds block after block.
+ */
+export async function suggestedGasPrice(urls) {
+  try {
+    const [block, tip] = await Promise.all([rpcCall(urls, "eth_getBlockByNumber", ["latest", false]),
+      rpcCall(urls, "eth_maxPriorityFeePerGas", [])]);
+    if (block?.baseFeePerGas) return quantity(block.baseFeePerGas) * 2n + quantity(tip);
+  } catch {}
+  return quantity(await rpcCall(urls, "eth_gasPrice", [])) * 12n / 10n;
+}
+
 export async function sendTransaction(urls, privateKey, { to, data, gasLimit }) {
   const from = addressOf(privateKey);
   const [chainId, nonce, gasPrice] = await Promise.all([
-    rpcCall(urls, "eth_chainId", []), rpcCall(urls, "eth_getTransactionCount", [from, "pending"]), rpcCall(urls, "eth_gasPrice", []),
+    rpcCall(urls, "eth_chainId", []), rpcCall(urls, "eth_getTransactionCount", [from, "pending"]), suggestedGasPrice(urls),
   ]);
   const limit = gasLimit ?? (quantity(await rpcCall(urls, "eth_estimateGas", [{ from, to, data }])) * 12n / 10n + 10000n);
   const raw = signLegacyTransaction(privateKey, {
-    nonce: quantity(nonce), gasPrice: quantity(gasPrice) * 12n / 10n, gasLimit: limit, to, data, chainId: quantity(chainId),
+    nonce: quantity(nonce), gasPrice, gasLimit: limit, to, data, chainId: quantity(chainId),
   });
   const hash = await rpcCall(urls, "eth_sendRawTransaction", [raw]);
   for (let i = 0; i < 180; i += 1) {

package/src/probes.mjs

@@ -80,6 +80,36 @@ function capabilityTask(kind, p) {
   throw new Error(`unknown capability kind ${kind}`);
 }
 
+// Hunters' own questions: {question, reference, grader} graded "number", "choice" or "text".
+function customTask(p) {
+  const question = String(p.question); const reference = String(p.reference).trim(); const grader = String(p.grader);
+  if (!["number", "choice", "text"].includes(grader) || !question || !reference || question.length > 20_000 || reference.length > 200) {
+    throw new Error("invalid custom task");
+  }
+  if ((grader === "number" && !/^[0-9]+$/.test(reference)) || (grader === "choice" && !/^[A-J]$/.test(reference))) {
+    throw new Error("invalid custom task reference");
+  }
+  return { question, reference, grader };
+}
+
+const normal = (text) => text.toLowerCase().split(/\s+/).filter(Boolean).join(" ");
+
+function gradeCustom(task, answer) {
+  const text = String(answer);
+  if (task.grader === "number") return gradeCapability({ ...task, kind: "custom-number" }, text);
+  if (task.grader === "choice") {
+    const pick = (part) => [...part.matchAll(/\b([A-J])\b/g)].map((m) => m[1]);
+    const boxed = [...text.matchAll(/\\boxed\{([^{}]*)\}/g)];
+    let stated = [];
+    if (boxed.length) stated = pick(boxed[boxed.length - 1][1]);
+    else for (const line of text.split(LINE_BREAKS).reverse()) { const found = pick(line); if (found.length) { stated = found; break; } }
+    return stated.length === 1 && stated[0] === task.reference ? "pass" : "wrong";
+  }
+  const lines = text.split(LINE_BREAKS).filter((line) => line.trim());
+  const final = lines.length ? normal(lines[lines.length - 1]) : "";
+  return final.includes(normal(task.reference)) || (text.length <= 200 && normal(text).includes(normal(task.reference))) ? "pass" : "wrong";
+}
+
 function gradeCapability(task, answer) {
   // The answer finally stated decides: the last \boxed{...}, else the last line that states a value.
   // A handful of values at most: listing candidates is not answering.
@@ -106,6 +136,7 @@ export const capabilityFlagged = (passes, total, floor, minimum = 20) => total >
 
 export function buildTask(kind, params) {
   if (CAPABILITY_KINDS.includes(kind)) return { kind, capability: true, ...capabilityTask(kind, params) };
+  if (kind === "custom") return { kind, capability: true, ...customTask(params) };
   if (kind === "multiply") return { kind, question: `What is ${params.a} multiplied by ${params.b}?`, reference: String(BigInt(params.a) * BigInt(params.b)), numeric: true };
   if (kind === "sum") {
     return { kind, question: `What is the sum of ${params.values.join(", ")}?`, reference: String(params.values.reduce((a, b) => a + Number(b), 0)), numeric: true };
@@ -125,6 +156,7 @@ export function buildTask(kind, params) {
 }
 
 export function grade(task, answer) {
+  if (task.kind === "custom") return gradeCustom(task, answer);
   if (task.capability) return gradeCapability(task, answer);
   const text = String(answer).trim();
   if (!text) return "unrelated";

package/src/reputation.mjs

@@ -1,9 +1,10 @@
 // Provider ranking from what the chain and the probe ledger prove, not from what anyone claims.
 import { encodeCall, keccak, hex } from "./eip712.mjs";
-import { rpcCall } from "./chain.mjs";
+import { getLogs, rpcCall } from "./chain.mjs";
 import { evidenceHash } from "./disputes.mjs";
 import { CAPABILITY_FLOORS, capabilityFlagged, verifyProbeEvidence } from "./probes.mjs";
 
+// Recorded by the hunter that voided the probe: a Relay or any third party (open probing).
 const PROBE_RECORDED = hex(keccak(Buffer.from("ProbeRecorded(address,address,bytes32,bytes32,uint8)")));
 const LOOKBACK_BLOCKS = 50_400n; // about 7 days of 12-second blocks
 const LOG_CHUNK = 10_000n;
@@ -31,9 +32,9 @@ async function ledgerEvents(network) {
   const events = [];
   for (let from = head > LOOKBACK_BLOCKS ? head - LOOKBACK_BLOCKS : 0n; from <= head; from += LOG_CHUNK) {
     const to = from + LOG_CHUNK - 1n < head ? from + LOG_CHUNK - 1n : head;
-    for (const log of await rpcCall(network.rpc_urls, "eth_getLogs", [{ address: network.probe_ledger, topics: [PROBE_RECORDED],
-      fromBlock: `0x${from.toString(16)}`, toBlock: `0x${to.toString(16)}` }])) {
-      events.push({ provider: address(log.topics[1]), relay: address(log.topics[2]), key: log.topics[3],
+    for (const log of await getLogs(network.rpc_urls, { address: network.probe_ledger, topics: [PROBE_RECORDED],
+      fromBlock: `0x${from.toString(16)}`, toBlock: `0x${to.toString(16)}` })) {
+      events.push({ provider: address(log.topics[1]), hunter: address(log.topics[2]), key: log.topics[3],
         evidence: `0x${log.data.slice(2, 66)}`, ...VERDICT_CODES[Number(BigInt(`0x${log.data.slice(66, 130)}`))] });
     }
   }
@@ -61,17 +62,22 @@ export async function reputation(consumer, descriptors, relaysByOwner) {
     const entry = byOwner[event.provider];
     if (!entry || !event.verdict) continue;
     if (event.verdict === "pass") { entry[event.capability ? "capability_passed" : "probes_passed"] += 1; continue; }
-    const relay = relaysByOwner[event.relay];
-    if (!relay || verified >= MAX_VERIFIED) continue;
+    if (verified >= MAX_VERIFIED) continue;
     verified += 1;
-    try {
-      const { status, body } = await consumer.fetchJson(`${relay.url}/v11/evidence/${event.evidence}`,
-        { ca: network.tls_ca, pin: relay.pin, timeoutMs: 8_000 });
-      const checked = status === 200 && evidenceHash(body) === event.evidence ? verifyProbeEvidence(body, consumer.deployment) : null;
-      if (checked?.verdict === "wrong" && checked.capability === event.capability) {
-        entry[event.capability ? "capability_failed_verified" : "probes_failed_verified"] += 1;
-      }
-    } catch {}
+    // Hunters publish their evidence to every Relay's desk; a hunter that is a Relay serves its own first.
+    const relays = [relaysByOwner[event.hunter], ...Object.values(relaysByOwner)].filter(Boolean);
+    for (const relay of [...new Set(relays)].slice(0, 3)) {
+      try {
+        const { status, body } = await consumer.fetchJson(`${relay.url}/v11/evidence/${event.evidence}`,
+          { ca: network.tls_ca, pin: relay.pin, timeoutMs: 8_000 });
+        if (status !== 200 || evidenceHash(body) !== event.evidence) continue;
+        const checked = verifyProbeEvidence(body, consumer.deployment);
+        if (checked.verdict === "wrong" && checked.capability === event.capability) {
+          entry[event.capability ? "capability_failed_verified" : "probes_failed_verified"] += 1;
+        }
+        break;
+      } catch {}
+    }
   }
   return Object.fromEntries(descriptors.filter((d) => records[d.provider_signer]).map((descriptor) => {
     const entry = { ...byOwner[records[descriptor.provider_signer].owner] };

package/src/rewards.mjs

@@ -1,7 +1,7 @@
 // MYCO rewards: every hour's fees mint MYCO for the Consumers who paid them (80%), their Providers (10%,
 // 48 hours later, by success rate), Relays (7%) and keepers (3%). Find, show and claim an account's share.
 import { encodeCall, encodeWords, hex, keccak } from "./eip712.mjs";
-import { rpcCall, sendTransaction } from "./chain.mjs";
+import { getLogs, rpcCall, sendTransaction } from "./chain.mjs";
 
 export const ROLES = ["consumer", "provider", "relay", "bridge"];
 const POINTS = hex(keccak(new TextEncoder().encode("Points(uint64,uint8,address,uint256)")));
@@ -18,8 +18,8 @@ export async function earnedBlocks(network, account) {
   const topic = `0x${account.toLowerCase().replace(/^0x/, "").padStart(64, "0")}`;
   const found = new Map();
   for (let start = Number(network.emission_block || 0); start <= head; start += LOG_CHUNK) {
-    const logs = await rpcCall(network.rpc_urls, "eth_getLogs", [{ address: network.emission, topics: [POINTS, null, null, topic],
-      fromBlock: `0x${start.toString(16)}`, toBlock: `0x${Math.min(head, start + LOG_CHUNK - 1).toString(16)}` }]);
+    const logs = await getLogs(network.rpc_urls, { address: network.emission, topics: [POINTS, null, null, topic],
+      fromBlock: `0x${start.toString(16)}`, toBlock: `0x${Math.min(head, start + LOG_CHUNK - 1).toString(16)}` });
     for (const log of logs) {
       const role = Number(BigInt(log.topics[2]));
       if (!found.has(role)) found.set(role, new Set());