mpp32-mcp-server 1.3.1 → 1.4.1

package/CHANGELOG.md

@@ -4,6 +4,56 @@ All notable changes to `mpp32-mcp-server` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-05-21
+
+### Added
+
+* **`get_pivx_dao_intelligence` MCP tool — real-time PIVX DAO governance
+  intelligence.** Returns active budget proposals with masternode voting
+  tallies (Yes/No counts, net yes percentage), budget allocation status,
+  network health metrics, and deflation/fee burn analysis. PIVX is a fully
+  community-governed cryptocurrency where Masternode owners vote on budget
+  proposals every ~30 days (43,200 blocks per superblock cycle, 432,000 PIV
+  max monthly budget). Data is sourced live from pivx.org/proposals (HTML
+  scraping with structured `data-*` attributes) and the Chainz CryptoID
+  blockchain API. Cached for 5 minutes. Free — no payment key required.
+
+  Parameters:
+  - `filter` (optional, enum: `all` | `passing` | `failing`) — filter
+    proposals by voting status. Default: `all`.
+  - `includeStats` (optional, boolean) — include network stats and deflation
+    metrics. Default: `true`.
+
+  The response includes:
+  - **Network Overview:** masternode count, passing threshold (10% of
+    masternodes), monthly budget (PIV and USD), budget allocation percentage,
+    block height, total/circulating supply.
+  - **Deflation Metrics:** unallocated treasury PIV per cycle (never minted),
+    annual unallocated estimate, effective inflation reduction percentage,
+    proposal submission fee burn (50 PIV per proposal).
+  - **Active Proposals:** name, status (passing/failing), funded flag,
+    vote counts (yes/no), net yes percentage, monthly and total payment
+    amounts (PIV and USD), installments remaining, budget usage percentage,
+    and link to proposal details.
+
+* **PIVX Governance Oracle catalog entry.** Listed as `curated:pivx-governance`
+  in the federated catalog (category: crypto, free, verified). Discoverable
+  via `list_mpp32_services` with `q=pivx` or `category=crypto`.
+
+* **Backend `/api/governance` endpoints.** Three routes serve the PIVX data:
+  `GET /api/governance` (full governance data + deflation), `GET
+  /api/governance/proposals?status=passing|failing` (filtered proposals),
+  `GET /api/governance/stats` (network stats only). Rate limited to 30
+  req/min.
+
+* **Frontend `/governance` page** at mpp32.org/governance. Live dashboard
+  with proposal cards, vote bars, budget stats, deflation metrics, and an
+  explainer on how PIVX governance works.
+
+### Changed
+
+* **`server.json` version bumped to 1.4.0** to match the npm release.
+
 ## [1.3.1] - 2026-05-15
 
 ### Fixed

package/README.md

@@ -33,6 +33,7 @@ MPP32 replaces all of that with one MCP server. Your agent asks for a service by
 * Browse a live catalog of over 4,500 paid and free APIs across categories like token intelligence, market data, web search, image generation, embeddings, DeFi analytics, wallet scoring, on chain queries, and trading signals.
 * Pay any provider in the catalog using whichever protocol fits, with settlement that lands in seconds.
 * Run real time Solana token intelligence with alpha scoring, rug risk, whale flow, and 24 hour pump probability.
+* Query live PIVX DAO governance data: active proposals, masternode voting tallies, budget allocation, and network deflation metrics — all free, no payment key needed.
 * Track every call, every dollar settled, and every protocol used from a dashboard at mpp32.org.
 * Get an automatic 20 percent or 40 percent discount on native services for holding M32 once your wallet is verified.
 * Access M32-gated exclusive APIs: Whale Tracker (1M M32), Token Comparison (2.5M M32), and Portfolio Scanner (5M M32) — free for holders, unavailable to non-holders.
@@ -177,6 +178,27 @@ M32-gated full wallet portfolio scan. Discovers all SPL tokens in a wallet, runs
 { "wallet": "<wallet-to-scan>", "walletAddress": "<your-solana-wallet>" }
 ```
 
+### `get_pivx_dao_intelligence`
+
+Real-time PIVX DAO governance intelligence. Returns active budget proposals with masternode voting tallies, budget allocation status, network deflation metrics, and masternode network health. PIVX is a fully community-governed cryptocurrency where Masternode owners vote on budget proposals every ~30 days. Data sourced live from pivx.org/proposals and the PIVX blockchain. Free — no payment key required.
+
+```json
+{ "filter": "all" }
+```
+
+```json
+{ "filter": "passing", "includeStats": true }
+```
+
+Two parameters:
+
+* **filter** (optional) — `all` (default), `passing`, or `failing`. Filters proposals by voting status.
+* **includeStats** (optional, default true) — include network overview and deflation metrics alongside proposals.
+
+The response includes a network overview (masternode count, passing threshold, monthly budget in PIV and USD, budget allocation percentage, block height, supply stats), deflation metrics (unallocated treasury PIV that are never minted, effective inflation reduction, proposal fee burn), and all active proposals with vote counts, payment amounts, installments, and links.
+
+View the governance dashboard at [mpp32.org/governance](https://mpp32.org/governance).
+
 ### `manage_agent_budget`
 
 View, set, or reset the economic circuit breaker for your agent session. Prevents runaway spending with infrastructure-level budget enforcement.

package/dist/index.js

@@ -3,7 +3,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { signX402Payment } from "./x402-signers.js";
-const SERVER_VERSION = "1.3.1";
+const SERVER_VERSION = "1.4.1";
 // ── Env loading: trim and sanitize aggressively ─────────────────────────────
 // Copy-paste from Claude Desktop / Cursor / Windsurf JSON config UIs frequently
 // adds trailing \n, \r, NBSP, BOM, or wraps the value in literal quotes. Any
@@ -574,6 +574,92 @@ server.tool("scan_portfolio_m32", "M32-gated full wallet portfolio scan. Discove
         return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }] };
     }
 });
+// ── Tool 7: get_pivx_dao_intelligence ─────────────────────────────────────
+// Self-contained: scrapes pivx.org/proposals + Chainz CryptoID directly.
+// Does NOT depend on any backend endpoint — works for every npm user out of the box.
+import { fetchPivxGovernance } from "./pivx-provider.js";
+server.tool("get_pivx_dao_intelligence", "Get real-time PIVX DAO governance intelligence. Returns active budget proposals with masternode voting tallies (Yes/No counts, net yes percentages), budget allocation status, network deflation metrics (unallocated treasury PIV that are never minted), and masternode network health. PIVX is a fully community-governed cryptocurrency where Masternode owners vote on budget proposals every ~30 days (43,200 blocks per superblock cycle, 432,000 PIV max monthly budget). Data scraped live from pivx.org/proposals and the PIVX blockchain via Chainz CryptoID. Cached for 5 minutes. Free — no payment or API key required.", {
+    filter: z
+        .enum(["all", "passing", "failing"])
+        .default("all")
+        .optional()
+        .describe("Filter proposals by status: 'all' (default), 'passing' (funded proposals), or 'failing' (below threshold)."),
+    includeStats: z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe("Include network stats and deflation metrics (default: true)."),
+}, async ({ filter, includeStats }) => {
+    try {
+        const gov = await fetchPivxGovernance();
+        const lines = [];
+        lines.push("# PIVX DAO Governance Intelligence");
+        lines.push("");
+        if (includeStats !== false) {
+            const n = gov.network;
+            lines.push("## Network Overview");
+            lines.push(`- **Masternodes Online:** ${n.masternodeCount.toLocaleString()}`);
+            lines.push(`- **Passing Threshold:** ${n.passingThreshold} votes (10% of masternodes)`);
+            lines.push(`- **Monthly Budget:** ${n.monthlyBudgetPiv.toLocaleString()} PIV (~$${n.monthlyBudgetUsd.toLocaleString()})`);
+            lines.push(`- **Budget Allocated:** ${n.budgetAllocatedPiv.toLocaleString()} PIV (${n.budgetAllocatedPercent}%)`);
+            if (n.blockHeight)
+                lines.push(`- **Block Height:** ${n.blockHeight.toLocaleString()}`);
+            if (n.totalSupply)
+                lines.push(`- **Total Supply:** ${Math.round(n.totalSupply).toLocaleString()} PIV`);
+            lines.push("");
+            const d = gov.deflation;
+            lines.push("## Deflation / Fee Burn Metrics");
+            lines.push(`- **Unallocated PIV This Cycle:** ${d.unallocatedPivPerCycle.toLocaleString()} PIV (never minted)`);
+            lines.push(`- **Annual Unallocated (est.):** ${d.annualUnallocatedPiv.toLocaleString()} PIV`);
+            lines.push(`- **Effective Inflation Reduction:** ${d.effectiveInflationReduction}`);
+            lines.push(`- **Proposal Submission Fee:** ${d.proposalFeeBurnPiv} PIV (burned/destroyed)`);
+            lines.push("");
+        }
+        let proposals = gov.proposals;
+        if (filter === "passing")
+            proposals = proposals.filter((p) => p.status === "passing");
+        else if (filter === "failing")
+            proposals = proposals.filter((p) => p.status === "failing");
+        if (proposals.length > 0) {
+            lines.push(`## Active Proposals (${proposals.length})`);
+            lines.push("");
+            for (const p of proposals) {
+                const status = p.status === "passing" ? "PASSING" : "FAILING";
+                const fundedTag = p.funded ? " (Funded)" : "";
+                lines.push(`### ${p.name} — ${status}${fundedTag}`);
+                lines.push(`- **Votes:** ${p.yesVotes} Yes / ${p.noVotes} No (${p.netYesPercent}% net yes)`);
+                lines.push(`- **Monthly Payment:** ${p.monthlyPaymentPiv.toLocaleString()} PIV (~$${p.monthlyPaymentUsd.toLocaleString()})`);
+                if (p.totalPaymentPiv > p.monthlyPaymentPiv) {
+                    lines.push(`- **Total Budget:** ${p.totalPaymentPiv.toLocaleString()} PIV`);
+                }
+                if (p.installmentsRemaining > 0) {
+                    lines.push(`- **Installments Remaining:** ${p.installmentsRemaining}`);
+                }
+                if (p.budgetPercent)
+                    lines.push(`- **Budget Usage:** ${p.budgetPercent}%`);
+                if (p.url)
+                    lines.push(`- **Details:** ${p.url}`);
+                lines.push("");
+            }
+        }
+        else {
+            lines.push("No proposals found matching the filter.");
+        }
+        lines.push("---");
+        lines.push(`Source: ${gov.source} | ${gov.timestamp}${gov.cacheHit ? " (cached)" : ""}`);
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to fetch PIVX governance data: ${err instanceof Error ? err.message : String(err)}. The tool scrapes pivx.org/proposals directly — the site may be temporarily unreachable.`,
+                }],
+        };
+    }
+});
 // ── Tool 8: manage_agent_budget ────────────────────────────────────────────
 server.tool("manage_agent_budget", "View, set, or reset the spending circuit breaker for your MPP32 agent session. Use 'get' to check current budget status (remaining budget, hourly velocity, circuit breaker state). Use 'set' to configure spending limits (budget cap in USD, hourly velocity limit, alert threshold percentage). Use 'reset' to manually reset a tripped circuit breaker so the session can resume spending. Circuit breakers trip automatically when budget or velocity limits are exceeded, preventing runaway agent spending.", {
     action: z.enum(["get", "set", "reset"]).describe("Action: 'get' = view budget status, 'set' = update limits, 'reset' = clear tripped circuit breaker"),

package/dist/pivx-provider.d.ts

@@ -0,0 +1,42 @@
+export interface PivxProposal {
+    name: string;
+    url: string;
+    status: "passing" | "failing";
+    funded: boolean;
+    netYesPercent: number;
+    yesVotes: number;
+    noVotes: number;
+    monthlyPaymentPiv: number;
+    monthlyPaymentUsd: number;
+    totalPaymentPiv: number;
+    installmentsRemaining: number;
+    totalInstallments: number;
+    budgetPercent: number;
+}
+export interface PivxNetworkStats {
+    masternodeCount: number;
+    passingThreshold: number;
+    monthlyBudgetPiv: number;
+    monthlyBudgetUsd: number;
+    budgetAllocatedPiv: number;
+    budgetAllocatedUsd: number;
+    budgetAllocatedPercent: number;
+    blockHeight: number;
+    totalSupply: number;
+    circulatingSupply: number;
+}
+export interface PivxGovernanceData {
+    proposals: PivxProposal[];
+    network: PivxNetworkStats;
+    deflation: {
+        unallocatedPivPerCycle: number;
+        unallocatedPercent: number;
+        annualUnallocatedPiv: number;
+        proposalFeeBurnPiv: number;
+        effectiveInflationReduction: string;
+    };
+    timestamp: string;
+    source: string;
+    cacheHit: boolean;
+}
+export declare function fetchPivxGovernance(): Promise<PivxGovernanceData>;

package/dist/pivx-provider.js

@@ -0,0 +1,232 @@
+import * as cheerio from "cheerio";
+// 5-minute cache
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cachedData = null;
+let cacheTimestamp = 0;
+const CHAINZ_BASE = "https://chainz.cryptoid.info/pivx/api.dws";
+async function chainzFetch(query) {
+    const res = await fetch(`${CHAINZ_BASE}?q=${query}`, {
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`Chainz API ${query}: HTTP ${res.status}`);
+    return (await res.text()).trim();
+}
+async function fetchNetworkStats() {
+    const [masternodeCount, blockHeight, totalSupply, circulating] = await Promise.allSettled([
+        chainzFetch("masternodecount"),
+        chainzFetch("getblockcount"),
+        chainzFetch("totalcoins"),
+        chainzFetch("circulating"),
+    ]);
+    const mn = masternodeCount.status === "fulfilled"
+        ? parseInt(masternodeCount.value, 10)
+        : 0;
+    const bh = blockHeight.status === "fulfilled"
+        ? parseInt(blockHeight.value, 10)
+        : 0;
+    const ts = totalSupply.status === "fulfilled"
+        ? parseFloat(totalSupply.value)
+        : 0;
+    const cs = circulating.status === "fulfilled"
+        ? parseFloat(circulating.value)
+        : 0;
+    return {
+        masternodeCount: isNaN(mn) ? 0 : mn,
+        blockHeight: isNaN(bh) ? 0 : bh,
+        totalSupply: isNaN(ts) ? 0 : ts,
+        circulatingSupply: isNaN(cs) ? 0 : cs,
+        passingThreshold: isNaN(mn) ? 0 : Math.ceil(mn * 0.1),
+    };
+}
+function parseNumber(text) {
+    const cleaned = text.replace(/[^0-9.\-]/g, "");
+    const num = parseFloat(cleaned);
+    return isNaN(num) ? 0 : num;
+}
+async function scrapePivxProposals() {
+    const res = await fetch("https://pivx.org/proposals", {
+        signal: AbortSignal.timeout(15000),
+        headers: {
+            "User-Agent": "MPP32-Governance-Oracle/1.0 (+https://mpp32.org)",
+            Accept: "text/html",
+        },
+    });
+    if (!res.ok)
+        throw new Error(`pivx.org/proposals returned HTTP ${res.status}`);
+    const html = await res.text();
+    const $ = cheerio.load(html);
+    const pageText = $("body").text();
+    let monthlyBudgetPiv = 432000;
+    let monthlyBudgetUsd = 0;
+    let budgetAllocatedPiv = 0;
+    let budgetAllocatedUsd = 0;
+    let masternodeCount = 0;
+    let passingThreshold = 0;
+    const budgetMatch = pageText.match(/Monthly\s*Budget[:\s]*([\d,]+)\s*PIV/i);
+    if (budgetMatch?.[1])
+        monthlyBudgetPiv = parseNumber(budgetMatch[1]);
+    const budgetUsdMatch = pageText.match(/Monthly\s*Budget[^$]*US?\$([\d,.]+)/i);
+    if (budgetUsdMatch?.[1])
+        monthlyBudgetUsd = parseNumber(budgetUsdMatch[1]);
+    const allocatedMatch = pageText.match(/Budget\s*Allocated[:\s]*([\d,]+)\s*PIV/i);
+    if (allocatedMatch?.[1])
+        budgetAllocatedPiv = parseNumber(allocatedMatch[1]);
+    const allocatedUsdMatch = pageText.match(/Budget\s*Allocated[^$]*US?\$([\d,.]+)/i);
+    if (allocatedUsdMatch?.[1])
+        budgetAllocatedUsd = parseNumber(allocatedUsdMatch[1]);
+    const mnMatch = pageText.match(/([\d,]+)\s*masternodes?\s*online/i);
+    if (mnMatch?.[1])
+        masternodeCount = parseNumber(mnMatch[1]);
+    const thresholdMatch = pageText.match(/Positive\s*votes\s*required[^:]*:\s*(\d+)/i);
+    if (thresholdMatch?.[1])
+        passingThreshold = parseInt(thresholdMatch[1], 10);
+    const proposals = [];
+    const seenHashes = new Set();
+    $("table#js_table tbody tr[data-hash]").each((_i, el) => {
+        const $row = $(el);
+        const hash = $row.attr("data-hash") || "";
+        if (!hash || seenHashes.has(hash))
+            return;
+        seenHashes.add(hash);
+        const name = ($row.attr("data-title") || "").trim();
+        if (!name)
+            return;
+        const cells = $row.find("td");
+        if (cells.length < 5)
+            return;
+        const statusCell = $(cells[0]);
+        const statusText = statusCell.text();
+        const isPassing = /passing/i.test(statusText);
+        const funded = /funded/i.test(statusText);
+        let netYesPercent = 0;
+        const netYesMatch = statusText.match(/([-\d.]+)%/);
+        if (netYesMatch?.[1])
+            netYesPercent = parseFloat(netYesMatch[1]);
+        const nameCell = $(cells[1]);
+        const link = nameCell.find("a").first();
+        const url = link.attr("href") || "";
+        const paymentCell = $(cells[2]);
+        const monthlyPaymentPiv = parseNumber(paymentCell.attr("data-piv") || paymentCell.attr("data-order") || "0");
+        const budgetPercent = parseFloat(paymentCell.attr("data-percent") || "0");
+        let monthlyPaymentUsd = 0;
+        const usdSpan = paymentCell.find(".curr-prefix").parent();
+        if (usdSpan.length) {
+            const usdText = usdSpan.text();
+            const usdMatch = usdText.match(/US?\$\s*([\d,]+(?:\.\d+)?)/i);
+            if (usdMatch?.[1])
+                monthlyPaymentUsd = parseNumber(usdMatch[1]);
+        }
+        let installmentsRemaining = 1;
+        const longLine = paymentCell.find(".long-line");
+        if (longLine.length) {
+            const installB = longLine.find("b").first();
+            if (installB.length) {
+                const n = parseInt(installB.text().trim(), 10);
+                if (!isNaN(n))
+                    installmentsRemaining = n;
+            }
+        }
+        let totalPaymentPiv = monthlyPaymentPiv;
+        if (longLine.length) {
+            const totalB = longLine.find("b").last();
+            if (totalB.length) {
+                const totalText = totalB.text();
+                const totalMatch = totalText.match(/([\d,]+(?:\.\d+)?)\s*PIV/i);
+                if (totalMatch?.[1])
+                    totalPaymentPiv = parseNumber(totalMatch[1]);
+            }
+        }
+        const voteCell = $(cells[4]);
+        const voteText = voteCell.text();
+        let yesVotes = 0;
+        let noVotes = 0;
+        const voteMatch = voteText.match(/(\d+)\s*\/\s*(\d+)/);
+        if (voteMatch?.[1] && voteMatch[2]) {
+            yesVotes = parseInt(voteMatch[1], 10);
+            noVotes = parseInt(voteMatch[2], 10);
+        }
+        proposals.push({
+            name,
+            url,
+            status: isPassing ? "passing" : "failing",
+            funded,
+            netYesPercent,
+            yesVotes,
+            noVotes,
+            monthlyPaymentPiv,
+            monthlyPaymentUsd,
+            totalPaymentPiv,
+            installmentsRemaining,
+            totalInstallments: installmentsRemaining,
+            budgetPercent,
+        });
+    });
+    return {
+        proposals,
+        budgetSummary: {
+            monthlyBudgetPiv,
+            monthlyBudgetUsd,
+            budgetAllocatedPiv,
+            budgetAllocatedUsd,
+            masternodeCount,
+            passingThreshold,
+        },
+    };
+}
+export async function fetchPivxGovernance() {
+    if (cachedData && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
+        return { ...cachedData, cacheHit: true };
+    }
+    const [scrapeResult, networkStats] = await Promise.allSettled([
+        scrapePivxProposals(),
+        fetchNetworkStats(),
+    ]);
+    const scraped = scrapeResult.status === "fulfilled" ? scrapeResult.value : null;
+    const chainzStats = networkStats.status === "fulfilled" ? networkStats.value : {};
+    if (!scraped) {
+        throw new Error(`Failed to fetch PIVX governance data: ${scrapeResult.status === "rejected" ? scrapeResult.reason : "unknown"}`);
+    }
+    const budgetAllocatedPercent = scraped.budgetSummary.monthlyBudgetPiv > 0
+        ? Math.round((scraped.budgetSummary.budgetAllocatedPiv /
+            scraped.budgetSummary.monthlyBudgetPiv) *
+            10000) / 100
+        : 0;
+    const network = {
+        masternodeCount: scraped.budgetSummary.masternodeCount ||
+            chainzStats.masternodeCount ||
+            0,
+        passingThreshold: scraped.budgetSummary.passingThreshold ||
+            chainzStats.passingThreshold ||
+            0,
+        monthlyBudgetPiv: scraped.budgetSummary.monthlyBudgetPiv,
+        monthlyBudgetUsd: scraped.budgetSummary.monthlyBudgetUsd,
+        budgetAllocatedPiv: scraped.budgetSummary.budgetAllocatedPiv,
+        budgetAllocatedUsd: scraped.budgetSummary.budgetAllocatedUsd,
+        budgetAllocatedPercent,
+        blockHeight: chainzStats.blockHeight || 0,
+        totalSupply: chainzStats.totalSupply || 0,
+        circulatingSupply: chainzStats.circulatingSupply || 0,
+    };
+    const unallocatedPivPerCycle = network.monthlyBudgetPiv - network.budgetAllocatedPiv;
+    const annualUnallocatedPiv = unallocatedPivPerCycle * 12;
+    const data = {
+        proposals: scraped.proposals,
+        network,
+        deflation: {
+            unallocatedPivPerCycle,
+            unallocatedPercent: 100 - budgetAllocatedPercent,
+            annualUnallocatedPiv,
+            proposalFeeBurnPiv: 50,
+            effectiveInflationReduction: network.totalSupply > 0
+                ? `${((annualUnallocatedPiv / network.totalSupply) * 100).toFixed(3)}%`
+                : "N/A",
+        },
+        timestamp: new Date().toISOString(),
+        source: "pivx.org/proposals + chainz.cryptoid.info",
+        cacheHit: false,
+    };
+    cachedData = data;
+    cacheTimestamp = Date.now();
+    return data;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mpp32-mcp-server",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "mcpName": "io.github.MPP32/mpp32-mcp-server",
   "description": "Payment layer for AI agents. One MCP, five protocols, thousands of paid APIs your agent can call.",
   "type": "module",
@@ -52,7 +52,10 @@
     "crypto",
     "defi",
     "token-intelligence",
-    "api-marketplace"
+    "api-marketplace",
+    "pivx",
+    "governance",
+    "dao"
   ],
   "license": "MIT",
   "author": "MPP32 <admin@mpp32.org> (https://mpp32.org)",
@@ -73,6 +76,7 @@
     "@solana-program/token": "^0.13.0",
     "@solana/kit": "^6.9.0",
     "bs58": "^6.0.0",
+    "cheerio": "^1.2.0",
     "tweetnacl": "^1.0.3",
     "viem": "^2.48.11",
     "zod": "^3.23.0"