@grinta-mcp/server 0.2.0

package/dist/price-feed.d.ts

@@ -0,0 +1,23 @@
+/**
+ * BTC/USD Price Feed for Grinta OracleRelayer
+ *
+ * Fetches BTC/USD from CoinGecko and pushes to OracleRelayer on Starknet Sepolia.
+ * TypeScript equivalent of update_btc_price.sh
+ */
+import { type Account, type RpcProvider } from "starknet";
+/**
+ * Push BTC/USD price to OracleRelayer and return the tx hash.
+ */
+export declare function updateBtcPrice(account: Account): Promise<{
+    txHash: string;
+    priceUsd: number;
+    priceWad: bigint;
+}>;
+/**
+ * Read the current stored BTC/USD price from OracleRelayer.
+ */
+export declare function readBtcPrice(provider: RpcProvider): Promise<{
+    priceWad: bigint;
+    priceUsd: number;
+    lastUpdateTime: number;
+}>;

package/dist/price-feed.js

@@ -0,0 +1,151 @@
+/**
+ * BTC/USD Price Feed for Grinta OracleRelayer
+ *
+ * Fetches BTC/USD from CoinGecko and pushes to OracleRelayer on Starknet Sepolia.
+ * TypeScript equivalent of update_btc_price.sh
+ */
+import { Contract } from "starknet";
+import { GRINTA, TOKENS } from "./config.js";
+const WAD = BigInt(10) ** 18n;
+const ORACLE_RELAYER_ABI = [
+    {
+        type: "interface",
+        name: "IOracleRelayer",
+        items: [
+            {
+                type: "function",
+                name: "update_price",
+                inputs: [
+                    { name: "base_token", type: "core::starknet::contract_address::ContractAddress" },
+                    { name: "quote_token", type: "core::starknet::contract_address::ContractAddress" },
+                    { name: "price_usd_wad", type: "core::integer::u256" },
+                ],
+                outputs: [],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "get_price_wad",
+                inputs: [
+                    { name: "base_token", type: "core::starknet::contract_address::ContractAddress" },
+                    { name: "quote_token", type: "core::starknet::contract_address::ContractAddress" },
+                ],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "view",
+            },
+            {
+                type: "function",
+                name: "get_last_update_time",
+                inputs: [],
+                outputs: [{ type: "core::integer::u64" }],
+                state_mutability: "view",
+            },
+        ],
+    },
+];
+/**
+ * Fetch BTC/USD price from CoinGecko (free, no API key)
+ */
+async function fetchBtcPrice() {
+    const res = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd");
+    if (!res.ok)
+        throw new Error(`CoinGecko HTTP ${res.status}`);
+    const data = (await res.json());
+    const price = data?.bitcoin?.usd;
+    if (!price)
+        throw new Error(`Invalid CoinGecko response: ${JSON.stringify(data)}`);
+    return price;
+}
+/**
+ * Convert a USD price to WAD (18 decimals)
+ */
+function priceToWad(price) {
+    // Use string manipulation to avoid floating point precision loss
+    const [whole, frac = ""] = price.toString().split(".");
+    const paddedFrac = frac.padEnd(18, "0").slice(0, 18);
+    return BigInt(whole + paddedFrac);
+}
+/**
+ * Push BTC/USD price to OracleRelayer and return the tx hash.
+ */
+export async function updateBtcPrice(account) {
+    // 1. Fetch price
+    const priceUsd = await fetchBtcPrice();
+    const priceWad = priceToWad(priceUsd);
+    console.log(`  BTC/USD: $${priceUsd}`);
+    console.log(`  Price WAD: ${priceWad}`);
+    // 2. Push to OracleRelayer
+    const oracleRelayer = new Contract({
+        abi: ORACLE_RELAYER_ABI,
+        address: GRINTA.ORACLE_RELAYER,
+        providerOrAccount: account,
+    });
+    console.log("  Calling OracleRelayer.update_price()...");
+    const result = await account.execute([
+        oracleRelayer.populate("update_price", [TOKENS.WBTC, TOKENS.USDC, priceWad]),
+    ]);
+    console.log(`  tx: ${result.transaction_hash}`);
+    await account.waitForTransaction(result.transaction_hash);
+    return { txHash: result.transaction_hash, priceUsd, priceWad };
+}
+/**
+ * Read the current stored BTC/USD price from OracleRelayer.
+ */
+export async function readBtcPrice(provider) {
+    const oracleRelayer = new Contract({
+        abi: ORACLE_RELAYER_ABI,
+        address: GRINTA.ORACLE_RELAYER,
+        providerOrAccount: provider,
+    });
+    const [priceWad, lastUpdateTime] = await Promise.all([
+        oracleRelayer.get_price_wad(TOKENS.WBTC, TOKENS.USDC).then((r) => BigInt(r)),
+        oracleRelayer.get_last_update_time().then((r) => Number(r)),
+    ]);
+    const priceUsd = Number(priceWad * 100n / WAD) / 100;
+    return { priceWad, priceUsd, lastUpdateTime };
+}
+/**
+ * Standalone runner — can be executed directly with: npx tsx src/price-feed.ts
+ */
+async function main() {
+    // Load env
+    const { default: dotenv } = await import("dotenv");
+    const { fileURLToPath } = await import("url");
+    const { dirname, join } = await import("path");
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    dotenv.config({ path: join(__dirname, "..", ".env") });
+    const { CONFIG } = await import("./config.js");
+    const { Account, RpcProvider } = await import("starknet");
+    if (!CONFIG.ACCOUNT_ADDRESS || !CONFIG.PRIVATE_KEY) {
+        console.error("Missing STARKNET_ACCOUNT_ADDRESS or STARKNET_PRIVATE_KEY in .env");
+        process.exit(1);
+    }
+    const provider = new RpcProvider({ nodeUrl: CONFIG.RPC_URL });
+    const account = new Account({
+        provider,
+        address: CONFIG.ACCOUNT_ADDRESS,
+        signer: CONFIG.PRIVATE_KEY,
+    });
+    console.log("--- Update BTC/USD Price ---");
+    console.log(`Account: ${CONFIG.ACCOUNT_ADDRESS}`);
+    // Read current price
+    console.log("\nCurrent on-chain price:");
+    const before = await readBtcPrice(provider);
+    console.log(`  Stored: $${before.priceUsd} (last update: ${new Date(before.lastUpdateTime * 1000).toISOString()})`);
+    // Push new price
+    console.log("\nPushing new price...");
+    const { priceUsd } = await updateBtcPrice(account);
+    // Verify
+    console.log("\nVerifying...");
+    const after = await readBtcPrice(provider);
+    console.log(`  Stored: $${after.priceUsd} (last update: ${new Date(after.lastUpdateTime * 1000).toISOString()})`);
+    console.log("\nDone!");
+}
+// Run if executed directly
+const isMain = process.argv[1]?.includes("price-feed");
+if (isMain) {
+    main().catch((err) => {
+        console.error("Fatal:", err);
+        process.exit(1);
+    });
+}

package/dist/scan-safes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scan for SAFEs owned by this account and display balances.
+ * Run: npx tsx src/scan-safes.ts
+ */
+export {};

package/dist/scan-safes.js

@@ -0,0 +1,87 @@
+/**
+ * Scan for SAFEs owned by this account and display balances.
+ * Run: npx tsx src/scan-safes.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 { RpcProvider, Account, Contract } from "starknet";
+import { CONFIG, GRINTA } from "./config.js";
+import { GrintaClient } from "./grinta.js";
+import { formatAmount } from "./utils.js";
+async function main() {
+    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);
+    // Check balances
+    console.log("--- Wallet Balances ---");
+    const [wbtcBal, gritBal] = await Promise.all([
+        grinta.getWbtcBalance(CONFIG.ACCOUNT_ADDRESS),
+        grinta.getGritBalance(CONFIG.ACCOUNT_ADDRESS),
+    ]);
+    console.log(`  WBTC: ${formatAmount(wbtcBal, 8)} WBTC`);
+    console.log(`  GRIT: ${formatAmount(gritBal, 18)} GRIT`);
+    // Get total safe count
+    const safeEngineAbi = [
+        {
+            type: "interface",
+            name: "I",
+            items: [
+                {
+                    type: "function",
+                    name: "get_safe_count",
+                    inputs: [],
+                    outputs: [{ type: "core::integer::u64" }],
+                    state_mutability: "view",
+                },
+            ],
+        },
+    ];
+    const safeEngine = new Contract({
+        abi: safeEngineAbi,
+        address: GRINTA.SAFE_ENGINE,
+        providerOrAccount: provider,
+    });
+    const safeCount = Number(await safeEngine.get_safe_count());
+    console.log(`\nTotal SAFEs in system: ${safeCount}`);
+    const myHex = BigInt(CONFIG.ACCOUNT_ADDRESS).toString(16);
+    console.log(`Scanning for SAFEs owned by ${CONFIG.ACCOUNT_ADDRESS}...\n`);
+    let found = 0;
+    for (let i = 1; i <= safeCount; i++) {
+        try {
+            const ownerRaw = await grinta.getSafeOwner(i);
+            const ownerHex = BigInt(ownerRaw).toString(16);
+            if (ownerHex === myHex) {
+                found++;
+                const safe = await grinta.getSafe(i);
+                console.log(`SAFE #${i} (YOURS)`);
+                console.log(`  Collateral: ${formatAmount(safe.collateral, 18)} WBTC (WAD)`);
+                console.log(`  Debt: ${formatAmount(safe.debt, 18)} GRIT`);
+                if (safe.debt > 0n) {
+                    const health = await grinta.getPositionHealth(i);
+                    console.log(grinta.formatHealth(health));
+                }
+                console.log("");
+            }
+        }
+        catch {
+            // skip invalid safe IDs
+        }
+    }
+    if (found === 0) {
+        console.log("No SAFEs found for this account.");
+    }
+    else {
+        console.log(`Found ${found} SAFE(s).`);
+    }
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/swap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Ekubo DEX Swap — direct on-chain swaps via Ekubo Router V3
+ *
+ * Replaces AVNU for GRIT/USDC swaps on Starknet Sepolia.
+ *
+ * Run: npx tsx src/swap.ts <sell_token> <buy_token> <amount>
+ * Examples:
+ *   npx tsx src/swap.ts USDC GRIT 100
+ *   npx tsx src/swap.ts GRIT USDC 50
+ */
+import { Account, RpcProvider } from "starknet";
+export declare const EKUBO: {
+    ROUTER: string;
+    CORE: string;
+};
+export declare const TOKEN_INFO: Record<string, {
+    address: string;
+    decimals: number;
+}>;
+export declare function ekuboSwap(account: Account, provider: RpcProvider, sellTokenId: string, buyTokenId: string, humanAmount: string): Promise<{
+    txHash: string;
+    sellName: string;
+    buyName: string;
+    sellAmount: bigint;
+}>;

package/dist/swap.js

@@ -0,0 +1,271 @@
+/**
+ * Ekubo DEX Swap — direct on-chain swaps via Ekubo Router V3
+ *
+ * Replaces AVNU for GRIT/USDC swaps on Starknet Sepolia.
+ *
+ * Run: npx tsx src/swap.ts <sell_token> <buy_token> <amount>
+ * Examples:
+ *   npx tsx src/swap.ts USDC GRIT 100
+ *   npx tsx src/swap.ts GRIT USDC 50
+ */
+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, GRINTA } from "./config.js";
+import { formatAmount, parseAmount } from "./utils.js";
+// --- Ekubo Contracts (Sepolia) ---
+export const EKUBO = {
+    ROUTER: "0x0045f933adf0607292468ad1c1dedaa74d5ad166392590e72676a34d01d7b763",
+    CORE: "0x0444a09d96389aa7148f1aada508e30b71299ffe650d9c97fdaae38cb9a23384",
+};
+// --- Token Registry ---
+export const TOKEN_INFO = {
+    ETH: { address: TOKENS.ETH, decimals: 18 },
+    STRK: { address: TOKENS.STRK, decimals: 18 },
+    WBTC: { address: TOKENS.WBTC, decimals: 8 },
+    USDC: { address: TOKENS.USDC, decimals: 6 },
+    GRIT: { address: GRINTA.GRIT, decimals: 18 },
+};
+// token0 must have the smaller address
+const POOLS = [
+    {
+        token0: TOKENS.USDC, // 0x0728...
+        token1: GRINTA.GRIT, // 0x0788...
+        fee: 0n,
+        tickSpacing: 1000n,
+        extension: GRINTA.GRINTA_HOOK,
+    },
+];
+// Ekubo sqrt_ratio bounds (max slippage — fine for testnet)
+const MIN_SQRT_RATIO = 18446748437148339061n;
+const MAX_SQRT_RATIO = 6277100250585753475930931601400621808602321654880405518632n;
+// --- ABIs ---
+const ERC20_ABI = [
+    {
+        type: "interface",
+        name: "IERC20",
+        items: [
+            {
+                type: "function",
+                name: "transfer",
+                inputs: [
+                    { name: "recipient", 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",
+            },
+        ],
+    },
+];
+const ROUTER_ABI = [
+    {
+        type: "struct",
+        name: "ekubo::types::i129",
+        members: [
+            { name: "mag", type: "core::integer::u128" },
+            { name: "sign", type: "core::bool" },
+        ],
+    },
+    {
+        type: "struct",
+        name: "ekubo::types::keys::PoolKey",
+        members: [
+            { name: "token0", type: "core::starknet::contract_address::ContractAddress" },
+            { name: "token1", type: "core::starknet::contract_address::ContractAddress" },
+            { name: "fee", type: "core::integer::u128" },
+            { name: "tick_spacing", type: "core::integer::u128" },
+            { name: "extension", type: "core::starknet::contract_address::ContractAddress" },
+        ],
+    },
+    {
+        type: "struct",
+        name: "ekubo::router::RouteNode",
+        members: [
+            { name: "pool_key", type: "ekubo::types::keys::PoolKey" },
+            { name: "sqrt_ratio_limit", type: "core::integer::u256" },
+            { name: "skip_ahead", type: "core::integer::u128" },
+        ],
+    },
+    {
+        type: "struct",
+        name: "ekubo::router::TokenAmount",
+        members: [
+            { name: "token", type: "core::starknet::contract_address::ContractAddress" },
+            { name: "amount", type: "ekubo::types::i129" },
+        ],
+    },
+    {
+        type: "struct",
+        name: "ekubo::types::Delta",
+        members: [
+            { name: "amount0", type: "ekubo::types::i129" },
+            { name: "amount1", type: "ekubo::types::i129" },
+        ],
+    },
+    {
+        type: "interface",
+        name: "ekubo::interfaces::router::IRouter",
+        items: [
+            {
+                type: "function",
+                name: "swap",
+                inputs: [
+                    { name: "node", type: "ekubo::router::RouteNode" },
+                    { name: "token_amount", type: "ekubo::router::TokenAmount" },
+                ],
+                outputs: [{ type: "ekubo::types::Delta" }],
+                state_mutability: "external",
+            },
+            {
+                type: "function",
+                name: "clear",
+                inputs: [
+                    { name: "token", type: "core::starknet::contract_address::ContractAddress" },
+                ],
+                outputs: [{ type: "core::integer::u256" }],
+                state_mutability: "external",
+            },
+        ],
+    },
+];
+// --- Helpers ---
+function resolveToken(nameOrAddress) {
+    const upper = nameOrAddress.toUpperCase();
+    const info = TOKEN_INFO[upper];
+    if (info)
+        return { ...info, name: upper };
+    throw new Error(`Unknown token: ${nameOrAddress}. Supported: ${Object.keys(TOKEN_INFO).join(", ")}`);
+}
+function findPool(tokenA, tokenB) {
+    const pool = POOLS.find((p) => (p.token0 === tokenA && p.token1 === tokenB) ||
+        (p.token0 === tokenB && p.token1 === tokenA));
+    if (!pool)
+        throw new Error(`No Ekubo pool for ${tokenA} / ${tokenB}`);
+    return pool;
+}
+async function getBalance(provider, tokenAddress, ownerAddress) {
+    const token = new Contract({ abi: ERC20_ABI, address: tokenAddress, providerOrAccount: provider });
+    const result = await token.balance_of(ownerAddress);
+    return BigInt(result);
+}
+// --- Core Swap ---
+export async function ekuboSwap(account, provider, sellTokenId, buyTokenId, humanAmount) {
+    const sell = resolveToken(sellTokenId);
+    const buy = resolveToken(buyTokenId);
+    const sellAmount = parseAmount(humanAmount, sell.decimals);
+    const pool = findPool(sell.address, buy.address);
+    // Direction: selling token0 pushes price down → MIN, selling token1 pushes price up → MAX
+    const sellingToken0 = sell.address.toLowerCase() === pool.token0.toLowerCase();
+    const sqrtRatioLimit = sellingToken0 ? MIN_SQRT_RATIO : MAX_SQRT_RATIO;
+    const router = new Contract({
+        abi: ROUTER_ABI,
+        address: EKUBO.ROUTER,
+        providerOrAccount: account,
+    });
+    const sellTokenContract = new Contract({
+        abi: ERC20_ABI,
+        address: sell.address,
+        providerOrAccount: account,
+    });
+    console.log(`  Swapping ${humanAmount} ${sell.name} → ${buy.name}`);
+    console.log(`  Direction: selling ${sellingToken0 ? "token0" : "token1"}`);
+    // Ekubo Router flow: transfer input → swap → clear output
+    const calls = [
+        // 1. Send sell tokens to the Router
+        sellTokenContract.populate("transfer", [EKUBO.ROUTER, sellAmount]),
+        // 2. Execute swap through Ekubo Core
+        router.populate("swap", [
+            {
+                pool_key: {
+                    token0: pool.token0,
+                    token1: pool.token1,
+                    fee: pool.fee,
+                    tick_spacing: pool.tickSpacing,
+                    extension: pool.extension,
+                },
+                sqrt_ratio_limit: sqrtRatioLimit,
+                skip_ahead: 0n,
+            },
+            {
+                token: sell.address,
+                amount: { mag: sellAmount, sign: false },
+            },
+        ]),
+        // 3. Clear output tokens from Router back to caller
+        router.populate("clear", [buy.address]),
+    ];
+    const result = await account.execute(calls);
+    console.log(`  tx: ${result.transaction_hash}`);
+    await account.waitForTransaction(result.transaction_hash);
+    console.log(`  confirmed`);
+    return {
+        txHash: result.transaction_hash,
+        sellName: sell.name,
+        buyName: buy.name,
+        sellAmount,
+    };
+}
+// --- CLI (only runs when executed directly) ---
+const isDirectRun = process.argv[1]?.replace(/\\/g, "/").endsWith("src/swap.ts");
+if (isDirectRun) {
+    const [, , sellName, buyName, amount] = process.argv;
+    if (!sellName || !buyName || !amount) {
+        console.log("Usage: npx tsx src/swap.ts <sell_token> <buy_token> <amount>");
+        console.log("Example: npx tsx src/swap.ts USDC GRIT 100");
+        console.log(`Supported tokens: ${Object.keys(TOKEN_INFO).join(", ")}`);
+        process.exit(1);
+    }
+    if (!CONFIG.ACCOUNT_ADDRESS || !CONFIG.PRIVATE_KEY) {
+        console.error("Missing STARKNET_ACCOUNT_ADDRESS or STARKNET_PRIVATE_KEY in .env");
+        process.exit(1);
+    }
+    const provider = new RpcProvider({ nodeUrl: CONFIG.RPC_URL });
+    const account = new Account({
+        provider,
+        address: CONFIG.ACCOUNT_ADDRESS,
+        signer: CONFIG.PRIVATE_KEY,
+    });
+    const sell = resolveToken(sellName);
+    const buy = resolveToken(buyName);
+    console.log("--- Ekubo Swap ---");
+    console.log(`Account: ${CONFIG.ACCOUNT_ADDRESS}`);
+    // Balances before
+    const [sellBefore, buyBefore] = await Promise.all([
+        getBalance(provider, sell.address, CONFIG.ACCOUNT_ADDRESS),
+        getBalance(provider, buy.address, CONFIG.ACCOUNT_ADDRESS),
+    ]);
+    console.log(`\nBefore:`);
+    console.log(`  ${sell.name}: ${formatAmount(sellBefore, sell.decimals)}`);
+    console.log(`  ${buy.name}: ${formatAmount(buyBefore, buy.decimals)}`);
+    // Execute swap
+    console.log("");
+    const { txHash } = await ekuboSwap(account, provider, sellName, buyName, amount);
+    // Balances after
+    const [sellAfter, buyAfter] = await Promise.all([
+        getBalance(provider, sell.address, CONFIG.ACCOUNT_ADDRESS),
+        getBalance(provider, buy.address, CONFIG.ACCOUNT_ADDRESS),
+    ]);
+    console.log(`\nAfter:`);
+    console.log(`  ${sell.name}: ${formatAmount(sellAfter, sell.decimals)}`);
+    console.log(`  ${buy.name}: ${formatAmount(buyAfter, buy.decimals)}`);
+    // Delta
+    const sellDelta = sellBefore - sellAfter;
+    const buyDelta = buyAfter - buyBefore;
+    console.log(`\nResult:`);
+    console.log(`  Sold:     ${formatAmount(sellDelta, sell.decimals)} ${sell.name}`);
+    console.log(`  Received: ${formatAmount(buyDelta, buy.decimals)} ${buy.name}`);
+    console.log(`  tx: ${txHash}`);
+}

package/dist/test-swap.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Test AVNU swap on Sepolia
+ * Run: npx tsx src/test-swap.ts
+ */
+export {};

package/dist/test-swap.js

@@ -0,0 +1,93 @@
+/**
+ * Test AVNU swap on Sepolia
+ * Run: npx tsx src/test-swap.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 { Account, RpcProvider } from "starknet";
+import { getQuotes } from "@avnu/avnu-sdk";
+import { CONFIG, TOKENS } from "./config.js";
+async function main() {
+    const provider = new RpcProvider({ nodeUrl: CONFIG.RPC_URL });
+    const account = new Account({
+        provider,
+        address: CONFIG.ACCOUNT_ADDRESS,
+        signer: CONFIG.PRIVATE_KEY,
+    });
+    console.log("--- AVNU Swap Test (Sepolia) ---");
+    console.log(`Account: ${CONFIG.ACCOUNT_ADDRESS}`);
+    console.log(`AVNU URL: ${CONFIG.AVNU_BASE_URL}\n`);
+    // Try ETH -> STRK quote first (most liquid pair)
+    console.log("1) Fetching ETH -> STRK quote (0.001 ETH)...");
+    try {
+        const ethQuote = {
+            sellTokenAddress: TOKENS.ETH,
+            buyTokenAddress: TOKENS.STRK,
+            sellAmount: BigInt(10 ** 15), // 0.001 ETH
+            takerAddress: CONFIG.ACCOUNT_ADDRESS,
+        };
+        const quotes = await getQuotes(ethQuote, { baseUrl: CONFIG.AVNU_BASE_URL });
+        if (quotes.length > 0) {
+            const buyAmount = BigInt(quotes[0].buyAmount);
+            console.log(`   Got ${quotes.length} quote(s). Best: 0.001 ETH -> ${Number(buyAmount) / 1e18} STRK`);
+        }
+        else {
+            console.log("   No quotes available.");
+        }
+    }
+    catch (err) {
+        console.log("   Error:", err.message);
+    }
+    // Try WBTC -> GRIT quote (Grinta-specific, likely via Ekubo pool)
+    console.log("\n2) Fetching WBTC -> GRIT quote (0.01 WBTC)...");
+    try {
+        const wbtcGritQuote = {
+            sellTokenAddress: TOKENS.WBTC,
+            buyTokenAddress: CONFIG.ACCOUNT_ADDRESS, // wrong, let me use GRIT
+            sellAmount: BigInt(10 ** 6), // 0.01 WBTC (8 decimals)
+            takerAddress: CONFIG.ACCOUNT_ADDRESS,
+        };
+        // Fix: use GRIT (SAFEEngine) address
+        wbtcGritQuote.buyTokenAddress = "0x078802abe86444d116c73821c7b6aff8175bd558bf335b28247b825d49490ef2";
+        const quotes = await getQuotes(wbtcGritQuote, { baseUrl: CONFIG.AVNU_BASE_URL });
+        if (quotes.length > 0) {
+            const buyAmount = BigInt(quotes[0].buyAmount);
+            console.log(`   Got ${quotes.length} quote(s). Best: 0.01 WBTC -> ${Number(buyAmount) / 1e18} GRIT`);
+        }
+        else {
+            console.log("   No quotes available.");
+        }
+    }
+    catch (err) {
+        console.log("   Error:", err.message);
+    }
+    // Try GRIT -> USDC quote (the Ekubo pool pair)
+    console.log("\n3) Fetching GRIT -> USDC quote (100 GRIT)...");
+    try {
+        const gritUsdcQuote = {
+            sellTokenAddress: "0x078802abe86444d116c73821c7b6aff8175bd558bf335b28247b825d49490ef2",
+            buyTokenAddress: TOKENS.USDC,
+            sellAmount: BigInt(100) * BigInt(10 ** 18), // 100 GRIT
+            takerAddress: CONFIG.ACCOUNT_ADDRESS,
+        };
+        const quotes = await getQuotes(gritUsdcQuote, { baseUrl: CONFIG.AVNU_BASE_URL });
+        if (quotes.length > 0) {
+            const buyAmount = BigInt(quotes[0].buyAmount);
+            console.log(`   Got ${quotes.length} quote(s). Best: 100 GRIT -> ${Number(buyAmount) / 1e6} USDC`);
+        }
+        else {
+            console.log("   No quotes available.");
+        }
+    }
+    catch (err) {
+        console.log("   Error:", err.message);
+    }
+    console.log("\nDone.");
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared utilities for Starknet Agent
+ */
+/**
+ * Format a token amount from raw units to human-readable
+ */
+export declare function formatAmount(raw: bigint, decimals: number): string;
+/**
+ * Parse a human-readable amount to raw units
+ */
+export declare function parseAmount(amount: string, decimals: number): bigint;
+/**
+ * Sleep for the specified milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Validate a Starknet address format
+ */
+export declare function isValidAddress(address: string): boolean;