@grinta-mcp/server 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+/**
+ * grinta-agent - Starknet AI Agent for Grinta CDP Protocol
+ *
+ * Full agent with:
+ * - Wallet operations
+ * - DeFi via AVNU
+ * - On-chain identity (ERC-8004)
+ * - Grinta CDP management (open SAFEs, borrow GRIT, monitor health)
+ */
+import { type AgentIdentity } from "./identity.js";
+import { GrintaClient } from "./grinta.js";
+declare class GrintaAgent {
+    private provider;
+    private account;
+    private identityClient;
+    private identity;
+    private grinta;
+    private isRunning;
+    private managedSafeIds;
+    constructor();
+    get address(): string;
+    /**
+     * Start the agent
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the agent
+     */
+    stop(): void;
+    /**
+     * Load on-chain identity
+     */
+    private loadIdentity;
+    /**
+     * Check wallet balances (ETH, WBTC, GRIT)
+     */
+    private checkBalances;
+    /**
+     * Display Grinta system status
+     */
+    private showSystemStatus;
+    /**
+     * Display a SAFE's health
+     */
+    private showSafeHealth;
+    /**
+     * Main monitoring loop
+     */
+    private monitorLoop;
+    /**
+     * Run one agent cycle: check health of all managed SAFEs
+     */
+    private runCycle;
+    /**
+     * Monitor a single SAFE and take action if needed
+     */
+    private monitorSafe;
+    /**
+     * Emergency repay to bring LTV back to target
+     */
+    private emergencyRepay;
+    /**
+     * Execute a swap via Ekubo Router
+     */
+    swap(sellToken: string, buyToken: string, humanAmount: string): Promise<string | null>;
+    /**
+     * Get agent info for A2A
+     */
+    getAgentCard(): {
+        name: string;
+        version: string;
+        capabilities: string[];
+        address: string;
+        identity: AgentIdentity | null;
+        managedSafes: number[];
+    };
+    /**
+     * Expose the Grinta client for direct use
+     */
+    get grintaClient(): GrintaClient;
+}
+export default GrintaAgent;

package/dist/index.js

@@ -0,0 +1,284 @@
+/**
+ * grinta-agent - Starknet AI Agent for Grinta CDP Protocol
+ *
+ * Full agent with:
+ * - Wallet operations
+ * - DeFi via AVNU
+ * - On-chain identity (ERC-8004)
+ * - Grinta CDP management (open SAFEs, borrow GRIT, monitor health)
+ */
+// Load .env BEFORE any other imports that read process.env
+import dotenv from "dotenv";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: join(__dirname, "..", ".env") });
+import { Account, RpcProvider, Contract } from "starknet";
+import { CONFIG, TOKENS, AGENT_METADATA } from "./config.js";
+import { IdentityClient } from "./identity.js";
+import { GrintaClient, WAD } from "./grinta.js";
+import { ekuboSwap } from "./swap.js";
+import { formatAmount, sleep } from "./utils.js";
+// ERC20 ABI
+const ERC20_ABI = [
+    {
+        type: "interface",
+        name: "openzeppelin::token::erc20::interface::IERC20",
+        items: [
+            {
+                type: "function",
+                name: "balance_of",
+                inputs: [{ name: "account", type: "core::starknet::contract_address::ContractAddress" }],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+// --- Health Management Config ---
+const TARGET_LTV = 0.40; // 40%
+const DANGER_LTV = 0.60; // 60%
+const CRITICAL_LTV = 0.62; // 62% (approaching 66.7% liquidation at 150% ratio)
+class GrintaAgent {
+    provider;
+    account;
+    identityClient = null;
+    identity = null;
+    grinta;
+    isRunning = false;
+    managedSafeIds = [];
+    constructor() {
+        this.provider = new RpcProvider({ nodeUrl: CONFIG.RPC_URL });
+        this.account = new Account({
+            provider: this.provider,
+            address: CONFIG.ACCOUNT_ADDRESS,
+            signer: CONFIG.PRIVATE_KEY,
+        });
+        // Initialize Grinta CDP client
+        this.grinta = new GrintaClient(this.account, this.provider);
+        // Initialize identity client if registry configured
+        if (CONFIG.IDENTITY_REGISTRY_ADDRESS) {
+            this.identityClient = new IdentityClient(CONFIG.IDENTITY_REGISTRY_ADDRESS, this.provider);
+        }
+        // Load managed SAFE IDs from env
+        const safeIds = process.env.GRINTA_SAFE_IDS;
+        if (safeIds) {
+            this.managedSafeIds = safeIds.split(",").map((id) => parseInt(id.trim(), 10));
+        }
+    }
+    get address() {
+        return this.account.address;
+    }
+    /**
+     * Start the agent
+     */
+    async start() {
+        console.log("Grinta Agent Starting...");
+        console.log(`Address: ${this.address}`);
+        console.log(`Agent: ${AGENT_METADATA.name} v${AGENT_METADATA.version}`);
+        await this.checkBalances();
+        await this.showSystemStatus();
+        if (this.managedSafeIds.length > 0) {
+            console.log(`\nManaged SAFEs: ${this.managedSafeIds.join(", ")}`);
+            for (const safeId of this.managedSafeIds) {
+                await this.showSafeHealth(safeId);
+            }
+        }
+        else {
+            console.log("\nNo managed SAFEs configured. Set GRINTA_SAFE_IDS in .env");
+        }
+        if (this.identityClient) {
+            await this.loadIdentity();
+        }
+        this.isRunning = true;
+        console.log(`\nAgent ready. Monitoring every ${CONFIG.CHECK_INTERVAL_MS / 1000}s\n`);
+        this.monitorLoop();
+    }
+    /**
+     * Stop the agent
+     */
+    stop() {
+        this.isRunning = false;
+        console.log("Agent stopped");
+    }
+    /**
+     * Load on-chain identity
+     */
+    async loadIdentity() {
+        if (!this.identityClient)
+            return;
+        console.log("Loading on-chain identity...");
+        console.log("  Identity system available (configure IDENTITY_REGISTRY_ADDRESS)");
+    }
+    /**
+     * Check wallet balances (ETH, WBTC, GRIT)
+     */
+    async checkBalances() {
+        console.log("\n--- Wallet Balances ---");
+        const ethContract = new Contract({
+            abi: ERC20_ABI,
+            address: TOKENS.ETH,
+            providerOrAccount: this.provider,
+        });
+        try {
+            const [ethBal, wbtcBal, gritBal] = await Promise.all([
+                ethContract.balance_of(this.address).then((r) => BigInt(r)),
+                this.grinta.getWbtcBalance(this.address),
+                this.grinta.getGritBalance(this.address),
+            ]);
+            console.log(`  ETH:  ${formatAmount(ethBal, 18)} ETH`);
+            console.log(`  WBTC: ${formatAmount(wbtcBal, 8)} WBTC`);
+            console.log(`  GRIT: ${formatAmount(gritBal, 18)} GRIT`);
+        }
+        catch (error) {
+            console.error("  Error fetching balances:", error);
+        }
+    }
+    /**
+     * Display Grinta system status
+     */
+    async showSystemStatus() {
+        console.log("\n--- Grinta System Status ---");
+        try {
+            const status = await this.grinta.getSystemStatus();
+            console.log(this.grinta.formatSystemStatus(status));
+        }
+        catch (error) {
+            console.error("  Error fetching system status:", error);
+        }
+    }
+    /**
+     * Display a SAFE's health
+     */
+    async showSafeHealth(safeId) {
+        console.log(`\n--- SAFE #${safeId} Health ---`);
+        try {
+            const health = await this.grinta.getPositionHealth(safeId);
+            console.log(this.grinta.formatHealth(health));
+        }
+        catch (error) {
+            console.error(`  Error fetching SAFE #${safeId} health:`, error);
+        }
+    }
+    /**
+     * Main monitoring loop
+     */
+    async monitorLoop() {
+        while (this.isRunning) {
+            try {
+                await this.runCycle();
+            }
+            catch (error) {
+                console.error("Cycle error:", error);
+            }
+            await sleep(CONFIG.CHECK_INTERVAL_MS);
+        }
+    }
+    /**
+     * Run one agent cycle: check health of all managed SAFEs
+     */
+    async runCycle() {
+        const now = new Date().toLocaleTimeString();
+        console.log(`[${now}] Running cycle...`);
+        for (const safeId of this.managedSafeIds) {
+            await this.monitorSafe(safeId);
+        }
+    }
+    /**
+     * Monitor a single SAFE and take action if needed
+     */
+    async monitorSafe(safeId) {
+        try {
+            const health = await this.grinta.getPositionHealth(safeId);
+            const currentLtv = Number(health.ltv) / Number(WAD);
+            if (health.debt === 0n) {
+                console.log(`  SAFE #${safeId}: empty (no debt)`);
+                return;
+            }
+            console.log(`  SAFE #${safeId}: LTV ${(currentLtv * 100).toFixed(2)}%`);
+            if (currentLtv > CRITICAL_LTV) {
+                console.log(`  ⚠ CRITICAL: SAFE #${safeId} LTV ${(currentLtv * 100).toFixed(1)}% > ${CRITICAL_LTV * 100}%`);
+                await this.emergencyRepay(safeId, health);
+            }
+            else if (currentLtv > DANGER_LTV) {
+                console.log(`  ⚠ WARNING: SAFE #${safeId} LTV ${(currentLtv * 100).toFixed(1)}% > ${DANGER_LTV * 100}%`);
+                // Could auto-deposit or repay here
+            }
+        }
+        catch (error) {
+            console.error(`  Error monitoring SAFE #${safeId}:`, error);
+        }
+    }
+    /**
+     * Emergency repay to bring LTV back to target
+     */
+    async emergencyRepay(safeId, health) {
+        // Calculate how much to repay to reach target LTV
+        // target_ltv = (debt - repay) / collateral_value
+        // repay = debt - target_ltv * collateral_value
+        const targetDebt = (health.collateralValue * BigInt(Math.floor(TARGET_LTV * 1e18))) / WAD;
+        const repayAmount = health.debt - targetDebt;
+        if (repayAmount <= 0n)
+            return;
+        const gritBalance = await this.grinta.getGritBalance(this.address);
+        const actualRepay = repayAmount > gritBalance ? gritBalance : repayAmount;
+        if (actualRepay <= 0n) {
+            console.log(`  No GRIT available to repay. Need ${formatAmount(repayAmount, 18)} GRIT`);
+            return;
+        }
+        console.log(`  Repaying ${formatAmount(actualRepay, 18)} GRIT on SAFE #${safeId}...`);
+        await this.grinta.repay(safeId, actualRepay);
+        console.log(`  Repayment complete.`);
+    }
+    /**
+     * Execute a swap via Ekubo Router
+     */
+    async swap(sellToken, buyToken, humanAmount) {
+        try {
+            const { txHash } = await ekuboSwap(this.account, this.provider, sellToken, buyToken, humanAmount);
+            return txHash;
+        }
+        catch (error) {
+            console.error("Swap error:", error);
+            return null;
+        }
+    }
+    /**
+     * Get agent info for A2A
+     */
+    getAgentCard() {
+        return {
+            name: AGENT_METADATA.name,
+            version: AGENT_METADATA.version,
+            capabilities: AGENT_METADATA.capabilities,
+            address: this.address,
+            identity: this.identity,
+            managedSafes: this.managedSafeIds,
+        };
+    }
+    /**
+     * Expose the Grinta client for direct use
+     */
+    get grintaClient() {
+        return this.grinta;
+    }
+}
+async function main() {
+    if (!CONFIG.ACCOUNT_ADDRESS || !CONFIG.PRIVATE_KEY) {
+        console.error("Missing environment variables!");
+        console.error("Please configure .env with STARKNET_ACCOUNT_ADDRESS and STARKNET_PRIVATE_KEY");
+        process.exit(1);
+    }
+    const agent = new GrintaAgent();
+    process.on("SIGINT", () => {
+        console.log("\nShutting down...");
+        agent.stop();
+        process.exit(0);
+    });
+    await agent.start();
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+export default GrintaAgent;

package/dist/mcp.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Grinta CDP MCP Server (dev mode — signs and executes directly)
+ *
+ * Exposes all Grinta protocol operations as MCP tools.
+ * Run: npx tsx src/mcp.ts
+ */
+export {};

package/dist/mcp.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+/**
+ * Grinta CDP MCP Server (dev mode — signs and executes directly)
+ *
+ * Exposes all Grinta protocol operations as MCP tools.
+ * Run: npx tsx src/mcp.ts
+ */
+import dotenv from "dotenv";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: join(__dirname, "..", ".env") });
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { Account, RpcProvider, Contract } from "starknet";
+import { CONFIG, TOKENS } from "./config.js";
+import { GrintaClient, WAD } from "./grinta.js";
+import { ekuboSwap } from "./swap.js";
+import { updateBtcPrice } from "./price-feed.js";
+import { formatAmount, parseAmount } from "./utils.js";
+// --- Starknet setup ---
+const provider = new RpcProvider({ nodeUrl: CONFIG.RPC_URL });
+const account = new Account({
+    provider,
+    address: CONFIG.ACCOUNT_ADDRESS,
+    signer: CONFIG.PRIVATE_KEY,
+});
+const grinta = new GrintaClient(account, provider);
+// ERC20 for balance reads
+const ERC20_ABI = [
+    {
+        type: "interface",
+        name: "IERC20",
+        items: [
+            {
+                type: "function",
+                name: "balance_of",
+                inputs: [{ name: "account", type: "core::starknet::contract_address::ContractAddress" }],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+// --- Tool definitions ---
+const TOOLS = [
+    // Read
+    {
+        name: "grinta_get_system_status",
+        description: "Get full system status: BTC/USD price, GRIT market price, redemption price/rate, total debt, collateral, debt ceiling, liquidation ratio.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "grinta_get_position_health",
+        description: "Get a SAFE's health: collateral value, debt, LTV, liquidation price.",
+        inputSchema: {
+            type: "object",
+            properties: { safe_id: { type: "string", description: "SAFE ID (e.g. '1')" } },
+            required: ["safe_id"],
+        },
+    },
+    {
+        name: "grinta_get_safe",
+        description: "Get raw SAFE data: collateral (WAD) and debt (WAD).",
+        inputSchema: {
+            type: "object",
+            properties: { safe_id: { type: "string", description: "SAFE ID" } },
+            required: ["safe_id"],
+        },
+    },
+    {
+        name: "grinta_get_max_borrow",
+        description: "Get the maximum additional GRIT that can be borrowed from a SAFE.",
+        inputSchema: {
+            type: "object",
+            properties: { safe_id: { type: "string", description: "SAFE ID" } },
+            required: ["safe_id"],
+        },
+    },
+    {
+        name: "grinta_get_balances",
+        description: "Get wallet balances for ETH, WBTC, GRIT, USDC. Defaults to the agent's address.",
+        inputSchema: {
+            type: "object",
+            properties: { address: { type: "string", description: "Starknet address (optional, defaults to agent)" } },
+        },
+    },
+    // CDP writes
+    {
+        name: "grinta_open_safe",
+        description: "Open a new empty SAFE. Returns the transaction hash.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "grinta_deposit",
+        description: "Deposit WBTC collateral into a SAFE. Amount in BTC (e.g. '0.5').",
+        inputSchema: {
+            type: "object",
+            properties: {
+                safe_id: { type: "string", description: "SAFE ID" },
+                amount: { type: "string", description: "WBTC amount in BTC (e.g. '0.5')" },
+            },
+            required: ["safe_id", "amount"],
+        },
+    },
+    {
+        name: "grinta_withdraw",
+        description: "Withdraw WBTC collateral from a SAFE. Amount in BTC (WAD units, e.g. '0.5').",
+        inputSchema: {
+            type: "object",
+            properties: {
+                safe_id: { type: "string", description: "SAFE ID" },
+                amount: { type: "string", description: "WBTC amount in BTC (e.g. '0.5')" },
+            },
+            required: ["safe_id", "amount"],
+        },
+    },
+    {
+        name: "grinta_borrow",
+        description: "Borrow GRIT against existing collateral in a SAFE. Amount in GRIT (e.g. '1000').",
+        inputSchema: {
+            type: "object",
+            properties: {
+                safe_id: { type: "string", description: "SAFE ID" },
+                amount: { type: "string", description: "GRIT amount (e.g. '1000')" },
+            },
+            required: ["safe_id", "amount"],
+        },
+    },
+    {
+        name: "grinta_repay",
+        description: "Repay GRIT debt on a SAFE. Amount in GRIT (e.g. '500').",
+        inputSchema: {
+            type: "object",
+            properties: {
+                safe_id: { type: "string", description: "SAFE ID" },
+                amount: { type: "string", description: "GRIT amount (e.g. '500')" },
+            },
+            required: ["safe_id", "amount"],
+        },
+    },
+    {
+        name: "grinta_close_safe",
+        description: "Close a SAFE. Requires zero debt. Returns remaining collateral.",
+        inputSchema: {
+            type: "object",
+            properties: { safe_id: { type: "string", description: "SAFE ID" } },
+            required: ["safe_id"],
+        },
+    },
+    // DEX
+    {
+        name: "grinta_swap",
+        description: "Swap tokens via Ekubo DEX. Supported: USDC, GRIT. Example: sell_token='GRIT', buy_token='USDC', amount='100'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sell_token: { type: "string", description: "Token to sell (e.g. 'GRIT', 'USDC')" },
+                buy_token: { type: "string", description: "Token to buy (e.g. 'USDC', 'GRIT')" },
+                amount: { type: "string", description: "Amount to sell in human units (e.g. '100')" },
+            },
+            required: ["sell_token", "buy_token", "amount"],
+        },
+    },
+    // Oracle
+    {
+        name: "grinta_update_btc_price",
+        description: "Fetch BTC/USD from CoinGecko and push to the OracleRelayer on-chain.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "grinta_trigger_update",
+        description: "Trigger a manual price/rate update on the GrintaHook.",
+        inputSchema: { type: "object", properties: {} },
+    },
+];
+// --- Tool handler ---
+async function handleTool(name, args) {
+    switch (name) {
+        // --- Reads ---
+        case "grinta_get_system_status": {
+            const s = await grinta.getSystemStatus();
+            const marketPrice = Number(s.marketPrice) / 1e18;
+            const redemptionPrice = Number(s.redemptionPrice) / 1e27;
+            const RAY_ONE = 10n ** 27n;
+            const ratePerSec = Number(s.redemptionRate - RAY_ONE) / 1e27;
+            const rateAnnual = ratePerSec * 365.25 * 24 * 3600 * 100;
+            return [
+                `BTC/USD: $${formatAmount(s.collateralPrice, 18)}`,
+                `GRIT Market Price: $${marketPrice.toFixed(6)}`,
+                `Redemption Price: $${redemptionPrice.toFixed(6)}`,
+                `Redemption Rate: ${rateAnnual >= 0 ? "+" : ""}${rateAnnual.toFixed(6)}% annual`,
+                `Total Debt: ${formatAmount(s.totalDebt, 18)} GRIT`,
+                `Total Collateral: ${formatAmount(s.totalCollateral, 18)} WBTC (WAD)`,
+                `Debt Ceiling: ${formatAmount(s.debtCeiling, 18)} GRIT`,
+                `Liquidation Ratio: ${Number(s.liquidationRatio * 100n / WAD)}%`,
+            ].join("\n");
+        }
+        case "grinta_get_position_health": {
+            const safeId = parseInt(args.safe_id, 10);
+            const h = await grinta.getPositionHealth(safeId);
+            const ltv = Number(h.ltv * 10000n / WAD) / 100;
+            return [
+                `SAFE #${safeId}`,
+                `Collateral Value: $${formatAmount(h.collateralValue, 18)}`,
+                `Debt: ${formatAmount(h.debt, 18)} GRIT`,
+                `LTV: ${ltv}%`,
+                `Liquidation Price: $${formatAmount(h.liquidationPrice, 18)}`,
+            ].join("\n");
+        }
+        case "grinta_get_safe": {
+            const safeId = parseInt(args.safe_id, 10);
+            const s = await grinta.getSafe(safeId);
+            return `SAFE #${safeId}\nCollateral: ${formatAmount(s.collateral, 18)} WBTC (WAD)\nDebt: ${formatAmount(s.debt, 18)} GRIT`;
+        }
+        case "grinta_get_max_borrow": {
+            const safeId = parseInt(args.safe_id, 10);
+            const max = await grinta.getMaxBorrow(safeId);
+            return `SAFE #${safeId} max borrow: ${formatAmount(max, 18)} GRIT`;
+        }
+        case "grinta_get_balances": {
+            const addr = args.address || CONFIG.ACCOUNT_ADDRESS;
+            const eth = new Contract({ abi: ERC20_ABI, address: TOKENS.ETH, providerOrAccount: provider });
+            const usdc = new Contract({ abi: ERC20_ABI, address: TOKENS.USDC, providerOrAccount: provider });
+            const [ethBal, wbtcBal, gritBal, usdcBal] = await Promise.all([
+                eth.balance_of(addr).then((r) => BigInt(r)),
+                grinta.getWbtcBalance(addr),
+                grinta.getGritBalance(addr),
+                usdc.balance_of(addr).then((r) => BigInt(r)),
+            ]);
+            return [
+                `Balances for ${addr}`,
+                `ETH:  ${formatAmount(ethBal, 18)}`,
+                `WBTC: ${formatAmount(wbtcBal, 8)}`,
+                `GRIT: ${formatAmount(gritBal, 18)}`,
+                `USDC: ${formatAmount(usdcBal, 6)}`,
+            ].join("\n");
+        }
+        // --- CDP Writes ---
+        case "grinta_open_safe": {
+            await grinta.openSafe();
+            return "SAFE opened successfully.";
+        }
+        case "grinta_deposit": {
+            const safeId = parseInt(args.safe_id, 10);
+            const amount = parseAmount(args.amount, 8);
+            const tx = await grinta.deposit(safeId, amount);
+            return `Deposited ${args.amount} WBTC into SAFE #${safeId}\ntx: ${tx}`;
+        }
+        case "grinta_withdraw": {
+            const safeId = parseInt(args.safe_id, 10);
+            const amount = parseAmount(args.amount, 18);
+            const tx = await grinta.withdraw(safeId, amount);
+            return `Withdrew ${args.amount} WBTC from SAFE #${safeId}\ntx: ${tx}`;
+        }
+        case "grinta_borrow": {
+            const safeId = parseInt(args.safe_id, 10);
+            const amount = parseAmount(args.amount, 18);
+            const tx = await grinta.borrow(safeId, amount);
+            return `Borrowed ${args.amount} GRIT from SAFE #${safeId}\ntx: ${tx}`;
+        }
+        case "grinta_repay": {
+            const safeId = parseInt(args.safe_id, 10);
+            const amount = parseAmount(args.amount, 18);
+            const tx = await grinta.repay(safeId, amount);
+            return `Repaid ${args.amount} GRIT on SAFE #${safeId}\ntx: ${tx}`;
+        }
+        case "grinta_close_safe": {
+            const safeId = parseInt(args.safe_id, 10);
+            const tx = await grinta.closeSafe(safeId);
+            return `Closed SAFE #${safeId}\ntx: ${tx}`;
+        }
+        // --- DEX ---
+        case "grinta_swap": {
+            const { txHash, sellName, buyName } = await ekuboSwap(account, provider, args.sell_token, args.buy_token, args.amount);
+            return `Swapped ${args.amount} ${sellName} → ${buyName}\ntx: ${txHash}`;
+        }
+        // --- Oracle ---
+        case "grinta_update_btc_price": {
+            const { txHash, priceUsd } = await updateBtcPrice(account);
+            return `Updated BTC/USD to $${priceUsd}\ntx: ${txHash}`;
+        }
+        case "grinta_trigger_update": {
+            const tx = await grinta.triggerUpdate();
+            return `Triggered GrintaHook update\ntx: ${tx}`;
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+// --- MCP Server ---
+const server = new Server({ name: "grinta-cdp", version: "0.2.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const result = await handleTool(name, (args ?? {}));
+        return { content: [{ type: "text", text: result }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    if (!CONFIG.ACCOUNT_ADDRESS || !CONFIG.PRIVATE_KEY) {
+        console.error("Missing STARKNET_ACCOUNT_ADDRESS or STARKNET_PRIVATE_KEY in .env");
+        process.exit(1);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`Grinta MCP server running (dev mode) — account: ${CONFIG.ACCOUNT_ADDRESS}`);
+}
+main().catch((e) => {
+    console.error("Fatal:", e);
+    process.exit(1);
+});