@grinta-mcp/server 0.2.0

package/dist/grinta.js

@@ -0,0 +1,561 @@
+/**
+ * Grinta CDP Protocol Client
+ *
+ * Manages SAFEs, borrows GRIT stablecoin, monitors health.
+ * All write operations go through SafeManager.
+ */
+import { Contract } from "starknet";
+import { GRINTA, TOKENS } from "./config.js";
+import { formatAmount } from "./utils.js";
+// --- Constants ---
+const WAD = BigInt(10) ** 18n;
+const RAY = BigInt(10) ** 27n;
+// --- ABIs ---
+const SAFE_MANAGER_ABI = [
+    {
+        type: "interface",
+        name: "ISafeManager",
+        items: [
+            {
+                type: "function",
+                name: "open_safe",
+                inputs: [],
+                outputs: [{ type: "core::integer::u64" }],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "open_and_borrow",
+                inputs: [
+                    { name: "collateral_amount", type: "core::integer::u256" },
+                    { name: "borrow_amount", type: "core::integer::u256" },
+                ],
+                outputs: [{ type: "core::integer::u64" }],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "deposit",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "amount", type: "core::integer::u256" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "withdraw",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "amount", type: "core::integer::u256" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "borrow",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "amount", type: "core::integer::u256" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "repay",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "amount", type: "core::integer::u256" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "close_safe",
+                inputs: [{ name: "safe_id", type: "core::integer::u64" }],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "authorize_agent",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "agent", type: "core::starknet::contract_address::ContractAddress" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "revoke_agent",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "agent", type: "core::starknet::contract_address::ContractAddress" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "get_position_health",
+                inputs: [{ name: "safe_id", type: "core::integer::u64" }],
+                outputs: [
+                    {
+                        type: "(core::integer::u256, core::integer::u256, core::integer::u256, core::integer::u256)",
+                    },
+                ],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_max_borrow",
+                inputs: [{ name: "safe_id", type: "core::integer::u64" }],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_safe_owner",
+                inputs: [{ name: "safe_id", type: "core::integer::u64" }],
+                outputs: [{ type: "core::starknet::contract_address::ContractAddress" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "is_authorized",
+                inputs: [
+                    { name: "safe_id", type: "core::integer::u64" },
+                    { name: "agent", type: "core::starknet::contract_address::ContractAddress" },
+                ],
+                outputs: [{ type: "core::bool" }],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+const SAFE_ENGINE_ABI = [
+    {
+        type: "interface",
+        name: "ISAFEEngine",
+        items: [
+            {
+                type: "function",
+                name: "get_safe",
+                inputs: [{ name: "safe_id", type: "core::integer::u64" }],
+                outputs: [{ type: "(core::integer::u256, core::integer::u256)" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_safe_count",
+                inputs: [],
+                outputs: [{ type: "core::integer::u64" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_collateral_price",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_redemption_price",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_redemption_rate",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_total_debt",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_total_collateral",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_debt_ceiling",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_liquidation_ratio",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_grit_balance",
+                inputs: [{ name: "account", type: "core::starknet::contract_address::ContractAddress" }],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_system_health",
+                inputs: [],
+                outputs: [
+                    {
+                        type: "(core::integer::u256, core::integer::u256, core::integer::u256, core::integer::u256)",
+                    },
+                ],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+const GRINTA_HOOK_ABI = [
+    {
+        type: "interface",
+        name: "IGrintaHook",
+        items: [
+            {
+                type: "function",
+                name: "update",
+                inputs: [],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "set_market_price",
+                inputs: [{ name: "price", type: "core::integer::u256" }],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "get_market_price",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_collateral_price",
+                inputs: [],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_last_update_time",
+                inputs: [],
+                outputs: [{ type: "core::integer::u64" }],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+const ERC20_ABI = [
+    {
+        type: "interface",
+        name: "IERC20",
+        items: [
+            {
+                type: "function",
+                name: "approve",
+                inputs: [
+                    { name: "spender", type: "core::starknet::contract_address::ContractAddress" },
+                    { name: "amount", type: "core::integer::u256" },
+                ],
+                outputs: [{ type: "core::bool" }],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "balance_of",
+                inputs: [{ name: "account", type: "core::starknet::contract_address::ContractAddress" }],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+// --- Client ---
+export class GrintaClient {
+    safeManager;
+    safeEngine;
+    grintaHook;
+    wbtc;
+    account;
+    constructor(account, provider) {
+        this.account = account;
+        this.safeManager = new Contract({
+            abi: SAFE_MANAGER_ABI,
+            address: GRINTA.SAFE_MANAGER,
+            providerOrAccount: account,
+        });
+        this.safeEngine = new Contract({
+            abi: SAFE_ENGINE_ABI,
+            address: GRINTA.SAFE_ENGINE,
+            providerOrAccount: provider,
+        });
+        this.grintaHook = new Contract({
+            abi: GRINTA_HOOK_ABI,
+            address: GRINTA.GRINTA_HOOK,
+            providerOrAccount: provider,
+        });
+        this.wbtc = new Contract({
+            abi: ERC20_ABI,
+            address: TOKENS.WBTC,
+            providerOrAccount: account,
+        });
+    }
+    // --- Read Operations ---
+    async getPositionHealth(safeId) {
+        const result = await this.safeManager.get_position_health(safeId);
+        return {
+            collateralValue: BigInt(result[0]),
+            debt: BigInt(result[1]),
+            ltv: BigInt(result[2]),
+            liquidationPrice: BigInt(result[3]),
+        };
+    }
+    async getMaxBorrow(safeId) {
+        const result = await this.safeManager.get_max_borrow(safeId);
+        return BigInt(result);
+    }
+    async getSafeOwner(safeId) {
+        const result = await this.safeManager.get_safe_owner(safeId);
+        return String(result);
+    }
+    async isAuthorized(safeId, agent) {
+        const result = await this.safeManager.is_authorized(safeId, agent);
+        return Boolean(result);
+    }
+    async getSafe(safeId) {
+        const result = await this.safeEngine.get_safe(safeId);
+        return {
+            collateral: BigInt(result[0]),
+            debt: BigInt(result[1]),
+        };
+    }
+    async getSystemStatus() {
+        const [totalDebt, totalCollateral, debtCeiling, liquidationRatio, collateralPrice, redemptionPrice, redemptionRate, marketPrice,] = await Promise.all([
+            this.safeEngine.get_total_debt().then((r) => BigInt(r)),
+            this.safeEngine.get_total_collateral().then((r) => BigInt(r)),
+            this.safeEngine.get_debt_ceiling().then((r) => BigInt(r)),
+            this.safeEngine.get_liquidation_ratio().then((r) => BigInt(r)),
+            this.safeEngine.get_collateral_price().then((r) => BigInt(r)),
+            this.safeEngine.get_redemption_price().then((r) => BigInt(r)),
+            this.safeEngine.get_redemption_rate().then((r) => BigInt(r)),
+            this.grintaHook.get_market_price().then((r) => BigInt(r)),
+        ]);
+        return {
+            totalDebt,
+            totalCollateral,
+            debtCeiling,
+            liquidationRatio,
+            collateralPrice,
+            redemptionPrice,
+            redemptionRate,
+            marketPrice,
+        };
+    }
+    async getGritBalance(address) {
+        const result = await this.safeEngine.get_grit_balance(address);
+        return BigInt(result);
+    }
+    async getWbtcBalance(address) {
+        const result = await this.wbtc.balance_of(address);
+        return BigInt(result);
+    }
+    // --- Write Operations ---
+    /**
+     * Open an empty SAFE. Returns the safe_id.
+     */
+    async openSafe() {
+        const result = await this.account.execute([
+            this.safeManager.populate("open_safe", []),
+        ]);
+        console.log(`  open_safe tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        // The safe_id is returned by the contract; parse from events
+        return -1; // TODO: parse safe_id from tx receipt events
+    }
+    /**
+     * Open a SAFE, deposit WBTC collateral, and borrow GRIT in one transaction.
+     * @param collateralAmount WBTC in 8 decimals (e.g. 50_000_000 = 0.5 BTC)
+     * @param borrowAmount GRIT in WAD (e.g. 10000n * WAD = 10,000 GRIT)
+     */
+    async openAndBorrow(collateralAmount, borrowAmount) {
+        // Step 1: Approve WBTC to CollateralJoin
+        // Step 2: Open and borrow via SafeManager
+        // Batched as multicall
+        const calls = [
+            this.wbtc.populate("approve", [GRINTA.COLLATERAL_JOIN, collateralAmount]),
+            this.safeManager.populate("open_and_borrow", [collateralAmount, borrowAmount]),
+        ];
+        const result = await this.account.execute(calls);
+        console.log(`  open_and_borrow tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Deposit WBTC collateral into an existing SAFE.
+     * @param amount WBTC in 8 decimals
+     */
+    async deposit(safeId, amount) {
+        const calls = [
+            this.wbtc.populate("approve", [GRINTA.COLLATERAL_JOIN, amount]),
+            this.safeManager.populate("deposit", [safeId, amount]),
+        ];
+        const result = await this.account.execute(calls);
+        console.log(`  deposit tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Withdraw WBTC collateral from a SAFE.
+     * @param amount Internal WAD amount (not 8 decimals)
+     */
+    async withdraw(safeId, amount) {
+        const result = await this.account.execute([
+            this.safeManager.populate("withdraw", [safeId, amount]),
+        ]);
+        console.log(`  withdraw tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Borrow additional GRIT against existing collateral.
+     * @param amount GRIT in WAD
+     */
+    async borrow(safeId, amount) {
+        const result = await this.account.execute([
+            this.safeManager.populate("borrow", [safeId, amount]),
+        ]);
+        console.log(`  borrow tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Repay GRIT debt. If amount > debt, only repays the debt.
+     * @param amount GRIT in WAD
+     */
+    async repay(safeId, amount) {
+        const result = await this.account.execute([
+            this.safeManager.populate("repay", [safeId, amount]),
+        ]);
+        console.log(`  repay tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Close a SAFE. Requires zero debt. Returns remaining collateral.
+     */
+    async closeSafe(safeId) {
+        const result = await this.account.execute([
+            this.safeManager.populate("close_safe", [safeId]),
+        ]);
+        console.log(`  close_safe tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Authorize an agent address to operate on a SAFE.
+     */
+    async authorizeAgent(safeId, agent) {
+        const result = await this.account.execute([
+            this.safeManager.populate("authorize_agent", [safeId, agent]),
+        ]);
+        console.log(`  authorize_agent tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Revoke an agent's permission on a SAFE.
+     */
+    async revokeAgent(safeId, agent) {
+        const result = await this.account.execute([
+            this.safeManager.populate("revoke_agent", [safeId, agent]),
+        ]);
+        console.log(`  revoke_agent tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Trigger a price/rate update on the GrintaHook.
+     */
+    async triggerUpdate() {
+        const hookWithAccount = new Contract({
+            abi: GRINTA_HOOK_ABI,
+            address: GRINTA.GRINTA_HOOK,
+            providerOrAccount: this.account,
+        });
+        const result = await this.account.execute([
+            hookWithAccount.populate("update", []),
+        ]);
+        console.log(`  update tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    /**
+     * Set the GRIT market price (WAD). Anyone can call.
+     * @param priceWad Price in WAD (e.g. 1e18 = $1.00)
+     */
+    async setMarketPrice(priceWad) {
+        const hookWithAccount = new Contract({
+            abi: GRINTA_HOOK_ABI,
+            address: GRINTA.GRINTA_HOOK,
+            providerOrAccount: this.account,
+        });
+        const result = await this.account.execute([
+            hookWithAccount.populate("set_market_price", [priceWad]),
+        ]);
+        console.log(`  set_market_price tx: ${result.transaction_hash}`);
+        await this.account.waitForTransaction(result.transaction_hash);
+        return result.transaction_hash;
+    }
+    // --- Display Helpers ---
+    formatHealth(health) {
+        const ltvPct = Number(health.ltv * 10000n / WAD) / 100;
+        return [
+            `  Collateral Value: $${formatAmount(health.collateralValue, 18)}`,
+            `  Debt:             ${formatAmount(health.debt, 18)} GRIT`,
+            `  LTV:              ${ltvPct}%`,
+            `  Liquidation Price: $${formatAmount(health.liquidationPrice, 18)}`,
+        ].join("\n");
+    }
+    formatSystemStatus(status) {
+        const liqRatioPct = Number(status.liquidationRatio * 100n / WAD);
+        const redemptionPriceUsd = Number(status.redemptionPrice * 1000000n / RAY) / 1000000;
+        const rateDelta = Number(status.redemptionRate - RAY);
+        const rateSign = rateDelta >= 0 ? "+" : "";
+        return [
+            `  BTC/USD:          $${formatAmount(status.collateralPrice, 18)}`,
+            `  GRIT Market:      $${formatAmount(status.marketPrice, 18)}`,
+            `  Redemption Price: $${redemptionPriceUsd.toFixed(6)}`,
+            `  Redemption Rate:  ${rateSign}${rateDelta} (per-second, RAY delta)`,
+            `  Total Debt:       ${formatAmount(status.totalDebt, 18)} GRIT`,
+            `  Total Collateral: ${formatAmount(status.totalCollateral, 18)} WBTC (WAD)`,
+            `  Debt Ceiling:     ${formatAmount(status.debtCeiling, 18)} GRIT`,
+            `  Liquidation Ratio: ${liqRatioPct}%`,
+        ].join("\n");
+    }
+}
+export { WAD, RAY };

package/dist/identity.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Identity Module - ERC-8004 Integration
+ *
+ * Provides on-chain identity and reputation for the agent.
+ */
+import { type RpcProvider, type Account } from "starknet";
+export interface AgentIdentity {
+    tokenId: bigint;
+    name: string;
+    agentType: string;
+    version: string;
+}
+export declare class IdentityClient {
+    private contract;
+    constructor(registryAddress: string, providerOrAccount: RpcProvider | Account);
+    /**
+     * Get agent metadata by token ID
+     */
+    getMetadata(tokenId: bigint, key: string): Promise<string>;
+    /**
+     * Get full agent identity
+     */
+    getIdentity(tokenId: bigint): Promise<AgentIdentity | null>;
+}

package/dist/identity.js

@@ -0,0 +1,74 @@
+/**
+ * Identity Module - ERC-8004 Integration
+ *
+ * Provides on-chain identity and reputation for the agent.
+ */
+import { Contract } from "starknet";
+// Minimal ABI for IdentityRegistry
+const IDENTITY_REGISTRY_ABI = [
+    {
+        type: "interface",
+        name: "IIdentityRegistry",
+        items: [
+            {
+                type: "function",
+                name: "get_metadata",
+                inputs: [
+                    { name: "token_id", type: "core::integer::u256" },
+                    { name: "key", type: "core::byte_array::ByteArray" },
+                ],
+                outputs: [{ type: "core::byte_array::ByteArray" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "set_metadata",
+                inputs: [
+                    { name: "token_id", type: "core::integer::u256" },
+                    { name: "key", type: "core::byte_array::ByteArray" },
+                    { name: "value", type: "core::byte_array::ByteArray" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+        ],
+    },
+];
+export class IdentityClient {
+    contract;
+    constructor(registryAddress, providerOrAccount) {
+        this.contract = new Contract({
+            abi: IDENTITY_REGISTRY_ABI,
+            address: registryAddress,
+            providerOrAccount,
+        });
+    }
+    /**
+     * Get agent metadata by token ID
+     */
+    async getMetadata(tokenId, key) {
+        try {
+            const result = await this.contract.get_metadata(tokenId, key);
+            return String(result);
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Get full agent identity
+     */
+    async getIdentity(tokenId) {
+        try {
+            const [name, agentType, version] = await Promise.all([
+                this.getMetadata(tokenId, "agentName"),
+                this.getMetadata(tokenId, "agentType"),
+                this.getMetadata(tokenId, "version"),
+            ]);
+            return { tokenId, name, agentType, version };
+        }
+        catch {
+            return null;
+        }
+    }
+}