mint-day 0.3.0

package/README.md

@@ -0,0 +1,166 @@
+# mint.day
+
+Agents mint NFTs now.
+
+## Quick start
+
+**1. Install** (zero config)
+
+```json
+{
+  "mcpServers": {
+    "mint-day": {
+      "command": "npx",
+      "args": ["-y", "mint-day"]
+    }
+  }
+}
+```
+
+Works with Claude Code, Cursor, Windsurf, OpenClaw, and any MCP client.
+
+**2. Mint**
+
+Tell your agent: "Proof I completed the security audit for 0xABC"
+
+**3. Verify**
+
+```
+mint_check({ address: "0xABC..." })
+```
+
+That's it. Your agent classifies the intent, builds the token, and returns a ready-to-sign transaction.
+
+## Signing transactions
+
+mint.day can sign and submit transactions directly, or return calldata for your own signer.
+
+### Option A: Built-in signing (recommended)
+
+Save a private key and mint.day handles everything:
+
+```bash
+mkdir -p ~/.mint-day
+node -e "const w = require('ethers').Wallet.createRandom(); console.log(w.privateKey); console.error('Address: ' + w.address)"  2>&1 | head -1 > ~/.mint-day/credentials
+chmod 600 ~/.mint-day/credentials
+```
+
+Fund the address with a small amount of ETH on Base (gas is < $0.01 per mint). Restart the MCP server.
+
+You can also set `PRIVATE_KEY` in your MCP env config instead of using the file.
+
+### Option B: Bring your own signer
+
+Don't set a private key. mint.day returns calldata. Submit it with Coinbase AgentKit, Lit Protocol, Privy, or any EVM wallet.
+
+## Tools
+
+### `mint`
+
+Create a permanent, verifiable on-chain record on Base.
+
+**Natural language:**
+
+```
+mint({ description: "Proof I completed the security audit for 0xABC" })
+```
+
+**Structured** (skips classification):
+
+```
+mint({
+  description: "Task completion attestation",
+  tokenType: "Attestation",
+  recipient: "0xABC...",
+  soulbound: true
+})
+```
+
+**With an image:**
+
+```
+mint({
+  description: "My agent identity",
+  tokenType: "Identity",
+  image: "data:image/png;base64,..."
+})
+```
+
+Every mint returns a preview first. Confirm with `mintId` to execute:
+
+```
+mint({ mintId: "a3f8c1e90b2d" })
+```
+
+With built-in signing, you get back a tx hash and explorer link. Without it, you get calldata.
+
+### `mint_check`
+
+Look up tokens by address, transaction hash, or get global stats.
+
+```
+mint_check({ address: "0xABC..." })
+mint_check({ txHash: "0x230b..." })
+mint_check({})  // global stats
+```
+
+### `mint_resolve`
+
+Resolve an agent's on-chain identity. Returns their Identity token with ERC-8004 agent card metadata.
+
+```
+mint_resolve({ address: "0xABC..." })
+```
+
+## Token types
+
+| Type | Default | Use for |
+|------|---------|---------|
+| Identity | transferable | Agent ID card, on-chain registration |
+| Attestation | soulbound | Proof of action, task completion |
+| Credential | soulbound | Reputation anchor, certification |
+| Receipt | transferable | Payment record between two parties |
+| Pass | transferable | API access, capability unlock |
+
+All types support `image` and `animation_url` for visual NFTs (PFPs, art, collectibles).
+
+## Architecture
+
+```
+Agent -> mint tool -> classifier (Groq Llama) -> metadata builder -> calldata
+                                                                        |
+                         [if PRIVATE_KEY] sign + submit -> tx hash <----|
+                         [if no key]      return calldata <-------------|
+                                                                        |
+                                                        MintFactory.sol (Base)
+```
+
+## Contracts
+
+- **Base Mainnet**: [`0xbf12d372444dcf69df9316d961439f6b5919e8d0`](https://basescan.org/address/0xbf12d372444dcf69df9316d961439f6b5919e8d0)
+- **Base Sepolia**: [`0xa52450397f312c256Bd68B202C0CF90387Ea0E67`](https://sepolia.basescan.org/address/0xa52450397f312c256Bd68B202C0CF90387Ea0E67)
+
+## Configuration
+
+All optional. mint.day works with zero config.
+
+| Env var | Default | Purpose |
+|---------|---------|---------|
+| `PRIVATE_KEY` | `~/.mint-day/credentials` | Signs and submits transactions |
+| `BASE_RPC_URL` | `https://mainnet.base.org` | RPC endpoint |
+| `CHAIN_ID` | `8453` | Base Mainnet |
+| `MINT_FACTORY_ADDRESS` | `0xbf12d3...` | Contract address |
+| `CLASSIFY_URL` | hosted endpoint | Intent classifier |
+
+## Development
+
+```bash
+npm install
+npm run dev     # run with tsx
+npm run build   # compile to dist/
+npm start       # run compiled
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ethers } from "ethers";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import dotenv from "dotenv";
+import { CalldataService } from "./services/calldata.js";
+import { mintSchema, handleMint } from "./tools/mint.js";
+import { mintCheckSchema, handleMintCheck } from "./tools/mint-check.js";
+import { mintResolveSchema, handleMintResolve } from "./tools/mint-resolve.js";
+dotenv.config();
+// Base mainnet
+const MAINNET_CONTRACT = "0x12a1c11a0b2860f64e7d8df20989f97d40de7f2c";
+const MAINNET_RPC = "https://mainnet.base.org";
+const MAINNET_CHAIN = 8453;
+// Sponsored gas wallet (Base mainnet, pre-funded with small ETH balance)
+// Used for zero-config mints when no PRIVATE_KEY is set
+const SPONSORED_KEY = process.env.SPONSORED_KEY || "0x1c9acdf008d822c2b0093d9194c6115b94e9c0003c2fd1a1ff03abff2c77a22e";
+const SPONSORED_CONTRACT = MAINNET_CONTRACT;
+const SPONSORED_RPC = MAINNET_RPC;
+const SPONSORED_CHAIN = MAINNET_CHAIN;
+// Sepolia fallback (when sponsored limits are exhausted)
+const FALLBACK_CONTRACT = "0x16e0072Eb4131106e266035E98Cfd07532B88EAa";
+const FALLBACK_RPC = "https://sepolia.base.org";
+const FALLBACK_CHAIN = 84532;
+// Load private key: env var > ~/.mint-day/credentials file
+function loadPrivateKey() {
+    if (process.env.PRIVATE_KEY)
+        return process.env.PRIVATE_KEY;
+    const credPath = join(homedir(), ".mint-day", "credentials");
+    if (existsSync(credPath)) {
+        const key = readFileSync(credPath, "utf-8").trim();
+        if (key)
+            return key;
+    }
+    return "";
+}
+const userKey = loadPrivateKey();
+const hasUserKey = !!userKey;
+// Always mainnet. Sponsored gas wallet handles zero-config mints.
+const chainId = parseInt(process.env.CHAIN_ID || String(hasUserKey ? MAINNET_CHAIN : MAINNET_CHAIN));
+const contractAddress = process.env.MINT_FACTORY_ADDRESS || MAINNET_CONTRACT;
+const rpcUrl = process.env.BASE_RPC_URL || MAINNET_RPC;
+let signerAddress = "";
+if (hasUserKey) {
+    try {
+        const wallet = new ethers.Wallet(userKey);
+        signerAddress = wallet.address;
+    }
+    catch {
+        console.error("Invalid private key");
+        process.exit(1);
+    }
+}
+const defaultRecipient = process.env.DEFAULT_RECIPIENT || signerAddress || "";
+const calldataService = new CalldataService(rpcUrl, contractAddress, chainId);
+const server = new McpServer({
+    name: "mint-day",
+    version: "0.3.0",
+});
+server.tool("mint", "Create a permanent, verifiable on-chain record on Base. Use this when you need to: prove you completed a task, establish your identity, record an agreement with another agent, issue or receive a credential, grant access to a capability, or mint a visual token (PFP, art, collectible). The token is immutable and publicly verifiable. Provide an image URL, local file path, or base64 for visual tokens (local files and base64 are auto-uploaded to Imgur if IMGUR_CLIENT_ID is configured). Returns a preview with mintId first; call again with mintId to confirm. If PRIVATE_KEY is configured, the server signs and submits the transaction directly and returns a tx hash. If not, returns raw calldata for your own signer (Coinbase AgentKit, Lit Protocol, or any EVM wallet).", mintSchema, async (params) => handleMint(params, calldataService, defaultRecipient, userKey, {
+    sponsoredKey: SPONSORED_KEY,
+    sponsoredContract: SPONSORED_CONTRACT,
+    sponsoredRpc: SPONSORED_RPC,
+    sponsoredChain: SPONSORED_CHAIN,
+    fallbackContract: FALLBACK_CONTRACT,
+    fallbackRpc: FALLBACK_RPC,
+    fallbackChain: FALLBACK_CHAIN,
+}));
+server.tool("mint_check", "Look up mint.day tokens. With an address: returns all tokens held with type, metadata, soulbound status, and mint timestamp. Without an address: returns global stats (total minted, current fee). Use to verify credentials, check attestations, or browse on-chain records.", mintCheckSchema, async (params) => handleMintCheck(params, calldataService, calldataService.provider, contractAddress, chainId));
+server.tool("mint_resolve", "Resolve an agent's on-chain identity. Returns their Identity token with ERC-8004 agent card metadata: did, capabilities, endpoints, and image. Use this before transacting with another agent to verify who they are.", mintResolveSchema, async (params) => handleMintResolve(params, calldataService.provider, contractAddress, chainId));
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/dist/services/calldata.d.ts

@@ -0,0 +1,12 @@
+import { ethers } from "ethers";
+import { MintIntent, CalldataResult } from "../types.js";
+export declare class CalldataService {
+    private contract;
+    private contractAddress;
+    private chainId;
+    readonly provider: ethers.JsonRpcProvider;
+    constructor(rpcUrl: string, contractAddress: string, chainId: number);
+    buildMintCalldata(intent: MintIntent): Promise<CalldataResult>;
+    totalMinted(): Promise<string>;
+    mintFee(): Promise<string>;
+}

package/dist/services/calldata.js

@@ -0,0 +1,61 @@
+import { ethers } from "ethers";
+import { TOKEN_TYPE_NAMES } from "../types.js";
+import { encodeMetadata } from "./metadata.js";
+const MINT_FACTORY_ABI = [
+    "function mint(address to, string uri, uint8 tokenType, bool soulbound) payable returns (uint256)",
+    "function mintFee() view returns (uint256)",
+    "function totalMinted() view returns (uint256)",
+];
+export class CalldataService {
+    contract;
+    contractAddress;
+    chainId;
+    provider;
+    constructor(rpcUrl, contractAddress, chainId) {
+        this.provider = new ethers.JsonRpcProvider(rpcUrl);
+        this.contract = new ethers.Contract(contractAddress, MINT_FACTORY_ABI, this.provider);
+        this.contractAddress = contractAddress;
+        this.chainId = chainId;
+    }
+    async buildMintCalldata(intent) {
+        const tokenURI = encodeMetadata(intent.metadata);
+        const calldata = this.contract.interface.encodeFunctionData("mint", [
+            intent.recipient,
+            tokenURI,
+            intent.tokenType,
+            intent.soulbound,
+        ]);
+        const mintFee = await this.contract.mintFee();
+        // Dynamic gas estimation with 20% buffer, fallback to safe static value
+        let estimatedGas = 600000;
+        try {
+            const estimate = await this.provider.estimateGas({
+                to: this.contractAddress,
+                data: calldata,
+                value: mintFee,
+            });
+            estimatedGas = Math.ceil(Number(estimate) * 1.2);
+        }
+        catch {
+            // Estimation can fail if caller has no funds; use safe default
+        }
+        return {
+            to: this.contractAddress,
+            calldata,
+            value: mintFee.toString(),
+            estimatedGas,
+            chainId: this.chainId,
+            metadata: intent.metadata,
+            tokenType: TOKEN_TYPE_NAMES[intent.tokenType],
+            soulbound: intent.soulbound,
+        };
+    }
+    async totalMinted() {
+        const total = await this.contract.totalMinted();
+        return total.toString();
+    }
+    async mintFee() {
+        const fee = await this.contract.mintFee();
+        return ethers.formatEther(fee);
+    }
+}

package/dist/services/classifier.d.ts

@@ -0,0 +1,2 @@
+import { MintIntent } from "../types.js";
+export declare function classifyIntent(text: string, fallbackRecipient: string): Promise<MintIntent>;

package/dist/services/classifier.js

@@ -0,0 +1,81 @@
+import { TokenType, TOKEN_TYPE_NAMES } from "../types.js";
+const CLASSIFY_URL = process.env.CLASSIFY_URL || "https://agent-mint-nine.vercel.app/api/classify";
+function extractAddress(text) {
+    const match = text.match(/0x[a-fA-F0-9]{40}/);
+    return match ? match[0] : null;
+}
+async function classify(text) {
+    const response = await fetch(CLASSIFY_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text }),
+    });
+    if (!response.ok) {
+        throw new Error(`Classify API error: ${response.status}`);
+    }
+    return await response.json();
+}
+export async function classifyIntent(text, fallbackRecipient) {
+    let parsed;
+    try {
+        parsed = await classify(text);
+    }
+    catch {
+        // If API fails, use keyword fallback
+        parsed = keywordFallback(text);
+    }
+    const typeName = String(parsed.tokenType || "Attestation");
+    const typeIndex = TOKEN_TYPE_NAMES.indexOf(typeName);
+    const tokenType = typeIndex >= 0 ? typeIndex : TokenType.Attestation;
+    const soulbound = parsed.soulbound ?? (tokenType === TokenType.Attestation || tokenType === TokenType.Credential);
+    const name = String(parsed.name || "mint.day token");
+    const recipient = extractAddress(text) || fallbackRecipient;
+    const extractedFields = parsed.extractedFields || {};
+    const missingFields = parsed.missingFields || [];
+    // For Identity tokens, auto-generate did if missing
+    if (tokenType === TokenType.Identity && !extractedFields.did) {
+        extractedFields.did = `did:pkh:eip155:${parseInt(process.env.CHAIN_ID || "8453")}:${recipient}`;
+    }
+    // Default empty arrays for Identity ERC-8004 fields
+    if (tokenType === TokenType.Identity) {
+        if (!extractedFields.capabilities)
+            extractedFields.capabilities = [];
+        if (!extractedFields.endpoints)
+            extractedFields.endpoints = [];
+    }
+    return {
+        tokenType,
+        soulbound,
+        recipient,
+        missingFields: tokenType === TokenType.Identity ? missingFields.filter((f) => f !== "did" && !extractedFields[f]?.length) : [],
+        metadata: {
+            name,
+            description: text,
+            tokenType: TOKEN_TYPE_NAMES[tokenType],
+            soulbound,
+            creator: fallbackRecipient,
+            recipient,
+            timestamp: new Date().toISOString(),
+            chainId: parseInt(process.env.CHAIN_ID || "8453"),
+            mintday_version: "1",
+            ...extractedFields,
+        },
+    };
+}
+function keywordFallback(text) {
+    const lower = text.toLowerCase();
+    if (/identity|who i am|register|agent card/.test(lower)) {
+        return { tokenType: "Identity", soulbound: false, name: "mint.day token", extractedFields: {}, missingFields: [] };
+    }
+    if (/credential|vetted|reputation|certified|qualified/.test(lower)) {
+        return { tokenType: "Credential", soulbound: true, name: "mint.day token", extractedFields: {}, missingFields: [] };
+    }
+    if (/receipt|payment|settled|paid|invoice/.test(lower)) {
+        return { tokenType: "Receipt", soulbound: false, name: "mint.day token", extractedFields: {}, missingFields: [] };
+    }
+    if (/pass|access|api|grant|permission|key/.test(lower)) {
+        return { tokenType: "Pass", soulbound: false, name: "mint.day token", extractedFields: {}, missingFields: [] };
+    }
+    // Default: Attestation (proof of action)
+    return { tokenType: "Attestation", soulbound: true, name: "mint.day token", extractedFields: {}, missingFields: [] };
+}

package/dist/services/ens.d.ts

@@ -0,0 +1,3 @@
+export declare function looksLikeEns(input: string): boolean;
+export declare function resolveEns(nameOrAddress: string): Promise<string>;
+export declare function reverseResolve(address: string): Promise<string | null>;

package/dist/services/ens.js

@@ -0,0 +1,32 @@
+import { ethers } from "ethers";
+// ENS lives on Ethereum mainnet, need an L1 provider for resolution
+const ENS_RPC = process.env.ENS_RPC_URL || "https://eth.llamarpc.com";
+let ensProvider = null;
+function getEnsProvider() {
+    if (!ensProvider) {
+        ensProvider = new ethers.JsonRpcProvider(ENS_RPC);
+    }
+    return ensProvider;
+}
+export function looksLikeEns(input) {
+    return /^[a-zA-Z0-9-]+\.[a-zA-Z]{2,}$/.test(input) && !input.startsWith("0x");
+}
+export async function resolveEns(nameOrAddress) {
+    if (!looksLikeEns(nameOrAddress))
+        return nameOrAddress;
+    const provider = getEnsProvider();
+    const resolved = await provider.resolveName(nameOrAddress);
+    if (!resolved) {
+        throw new Error(`Could not resolve ENS name: ${nameOrAddress}`);
+    }
+    return resolved;
+}
+export async function reverseResolve(address) {
+    try {
+        const provider = getEnsProvider();
+        return await provider.lookupAddress(address);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/services/image-upload.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve an image value to a URL suitable for on-chain metadata.
+ *
+ * - URLs pass through unchanged.
+ * - Local file paths and data URIs are uploaded to 0x0.st (no API key needed).
+ * - Falls back to base64 data URI if upload fails.
+ */
+export declare function resolveImage(image: string): Promise<{
+    url: string;
+    uploaded: boolean;
+}>;

package/dist/services/image-upload.js

@@ -0,0 +1,70 @@
+import { readFileSync, existsSync } from "fs";
+import { basename } from "path";
+function isLocalPath(value) {
+    return (value.startsWith("/") ||
+        value.startsWith("~/") ||
+        value.startsWith("./") ||
+        value.startsWith("../"));
+}
+function isDataUri(value) {
+    return value.startsWith("data:");
+}
+function isUrl(value) {
+    return value.startsWith("http://") || value.startsWith("https://");
+}
+function resolvePath(path) {
+    return path.startsWith("~/")
+        ? path.replace("~", process.env.HOME || "")
+        : path;
+}
+/**
+ * Resolve an image value to a URL suitable for on-chain metadata.
+ *
+ * - URLs pass through unchanged.
+ * - Local file paths and data URIs are uploaded to 0x0.st (no API key needed).
+ * - Falls back to base64 data URI if upload fails.
+ */
+export async function resolveImage(image) {
+    if (isUrl(image)) {
+        return { url: image, uploaded: false };
+    }
+    let fileBuffer;
+    let fileName = "image.png";
+    if (isLocalPath(image)) {
+        const resolved = resolvePath(image);
+        if (!existsSync(resolved)) {
+            throw new Error(`Image file not found: ${resolved}`);
+        }
+        fileBuffer = readFileSync(resolved);
+        fileName = basename(resolved);
+    }
+    else if (isDataUri(image)) {
+        const match = image.match(/^data:([^;]+);base64,(.+)$/);
+        if (!match) {
+            throw new Error("Invalid data URI format");
+        }
+        fileBuffer = Buffer.from(match[2], "base64");
+        const ext = match[1].split("/")[1] || "png";
+        fileName = `image.${ext}`;
+    }
+    else {
+        return { url: image, uploaded: false };
+    }
+    const url = await uploadTo0x0(fileBuffer, fileName);
+    return { url, uploaded: true };
+}
+async function uploadTo0x0(buffer, fileName) {
+    const uint8 = new Uint8Array(buffer);
+    const blob = new Blob([uint8]);
+    const formData = new FormData();
+    formData.append("file", blob, fileName);
+    const res = await fetch("https://0x0.st", {
+        method: "POST",
+        headers: { "User-Agent": "mint.day/0.2.0" },
+        body: formData,
+    });
+    if (!res.ok) {
+        throw new Error(`0x0.st upload failed (${res.status})`);
+    }
+    return (await res.text()).trim();
+}

package/dist/services/metadata.d.ts

@@ -0,0 +1,2 @@
+import { TokenMetadata } from "../types.js";
+export declare function encodeMetadata(metadata: TokenMetadata): string;

package/dist/services/metadata.js

@@ -0,0 +1,119 @@
+const TYPE_COLORS = {
+    Identity: { bg: "#0c1220", accent: "#60a5fa", text: "#93bbfc" },
+    Attestation: { bg: "#0a1510", accent: "#22c55e", text: "#6ee7a0" },
+    Credential: { bg: "#100c1e", accent: "#a78bfa", text: "#c4b5fd" },
+    Receipt: { bg: "#151008", accent: "#fb923c", text: "#fdba74" },
+    Pass: { bg: "#0a1518", accent: "#22d3ee", text: "#67e8f9" },
+};
+function generateDefaultImage(metadata) {
+    const colors = TYPE_COLORS[metadata.tokenType] || TYPE_COLORS.Attestation;
+    const name = metadata.name || "mint.day token";
+    const tokenType = metadata.tokenType || "Token";
+    const soulbound = metadata.soulbound;
+    // Truncate name for display
+    const displayName = name.length > 80 ? name.slice(0, 77) + "..." : name;
+    // Split into lines if long
+    const words = displayName.split(" ");
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        if ((current + " " + word).trim().length > 30) {
+            lines.push(current.trim());
+            current = word;
+        }
+        else {
+            current = (current + " " + word).trim();
+        }
+    }
+    if (current)
+        lines.push(current.trim());
+    const nameLines = lines.slice(0, 4).map((line, i) => `<text x="40" y="${185 + i * 28}" font-family="monospace" font-size="18" font-weight="600" fill="${colors.text}">${escapeXml(line)}</text>`).join("\n    ");
+    // Subtle pattern based on token type
+    const patternId = `p-${tokenType.toLowerCase()}`;
+    let pattern = "";
+    if (tokenType === "Identity") {
+        pattern = `<pattern id="${patternId}" width="40" height="40" patternUnits="userSpaceOnUse">
+      <circle cx="20" cy="20" r="1" fill="${colors.accent}" opacity="0.08"/>
+    </pattern>`;
+    }
+    else if (tokenType === "Attestation") {
+        pattern = `<pattern id="${patternId}" width="32" height="32" patternUnits="userSpaceOnUse">
+      <line x1="0" y1="32" x2="32" y2="0" stroke="${colors.accent}" stroke-width="0.5" opacity="0.06"/>
+    </pattern>`;
+    }
+    else if (tokenType === "Credential") {
+        pattern = `<pattern id="${patternId}" width="24" height="24" patternUnits="userSpaceOnUse">
+      <rect x="11" y="11" width="2" height="2" fill="${colors.accent}" opacity="0.08"/>
+    </pattern>`;
+    }
+    else if (tokenType === "Receipt") {
+        pattern = `<pattern id="${patternId}" width="36" height="36" patternUnits="userSpaceOnUse">
+      <line x1="0" y1="18" x2="36" y2="18" stroke="${colors.accent}" stroke-width="0.5" opacity="0.06"/>
+    </pattern>`;
+    }
+    else {
+        pattern = `<pattern id="${patternId}" width="28" height="28" patternUnits="userSpaceOnUse">
+      <circle cx="14" cy="14" r="0.8" fill="${colors.accent}" opacity="0.08"/>
+    </pattern>`;
+    }
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 400" width="400" height="400">
+  <defs>
+    ${pattern}
+  </defs>
+  <rect width="400" height="400" fill="${colors.bg}"/>
+  <rect width="400" height="400" fill="url(#${patternId})"/>
+
+  <!-- Top accent line -->
+  <rect x="40" y="40" width="48" height="3" rx="1.5" fill="${colors.accent}" opacity="0.8"/>
+
+  <!-- Token type label -->
+  <text x="40" y="80" font-family="monospace" font-size="12" fill="${colors.accent}" opacity="0.6" text-transform="uppercase" letter-spacing="2">${escapeXml(tokenType.toUpperCase())}</text>
+
+  <!-- Soulbound badge -->
+  ${soulbound ? `<text x="40" y="100" font-family="monospace" font-size="10" fill="${colors.accent}" opacity="0.35">SOULBOUND</text>` : ""}
+
+  <!-- Token name -->
+  ${nameLines}
+
+  <!-- Bottom branding -->
+  <text x="40" y="350" font-family="monospace" font-size="11" fill="${colors.accent}" opacity="0.2">mint.day</text>
+
+  <!-- Bottom accent line -->
+  <rect x="40" y="362" width="320" height="1" rx="0.5" fill="${colors.accent}" opacity="0.1"/>
+</svg>`;
+    return `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+}
+function escapeXml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+export function encodeMetadata(metadata) {
+    // Auto-generate image if none provided
+    if (!metadata.image) {
+        metadata.image = generateDefaultImage(metadata);
+    }
+    // Build OpenSea-compatible attributes array
+    const attributes = [
+        { trait_type: "Token Type", value: metadata.tokenType },
+        { trait_type: "Soulbound", value: metadata.soulbound ? "Yes" : "No" },
+    ];
+    if (metadata.creator && metadata.creator !== "0x0000000000000000000000000000000000000000") {
+        attributes.push({ trait_type: "Creator", value: metadata.creator });
+    }
+    if (metadata.recipient) {
+        attributes.push({ trait_type: "Recipient", value: metadata.recipient });
+    }
+    // Add any capabilities as traits
+    if (Array.isArray(metadata.capabilities)) {
+        for (const cap of metadata.capabilities) {
+            attributes.push({ trait_type: "Capability", value: cap });
+        }
+    }
+    const enriched = {
+        ...metadata,
+        attributes,
+        external_url: "https://agent-mint-nine.vercel.app",
+    };
+    const json = JSON.stringify(enriched);
+    const base64 = Buffer.from(json).toString("base64");
+    return `data:application/json;base64,${base64}`;
+}

package/dist/tools/mint-check.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { ethers } from "ethers";
+import { CalldataService } from "../services/calldata.js";
+export declare const mintCheckSchema: {
+    address: z.ZodOptional<z.ZodString>;
+    txHash: z.ZodOptional<z.ZodString>;
+};
+export declare function handleMintCheck(params: {
+    address?: string;
+    txHash?: string;
+}, calldataService: CalldataService, provider: ethers.JsonRpcProvider, contractAddress: string, chainId: number): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;