mint-day 0.3.3 → 0.4.2

package/.github/workflows/sentry-triage.yml

@@ -0,0 +1,69 @@
+name: Sentry Auto-Triage
+
+on:
+  repository_dispatch:
+    types: [sentry_issue]
+
+permissions:
+  contents: write
+  pull-requests: write
+  issues: write
+  id-token: write
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    env:
+      SENTRY_TITLE: ${{ github.event.client_payload.title }}
+      SENTRY_CULPRIT: ${{ github.event.client_payload.culprit }}
+      SENTRY_LEVEL: ${{ github.event.client_payload.level }}
+      SENTRY_FIRST_SEEN: ${{ github.event.client_payload.first_seen }}
+      SENTRY_COUNT: ${{ github.event.client_payload.count }}
+      SENTRY_URL: ${{ github.event.client_payload.url }}
+      SENTRY_SHORT_ID: ${{ github.event.client_payload.short_id }}
+      SENTRY_TAGS: ${{ toJSON(github.event.client_payload.tags) }}
+      SENTRY_METADATA: ${{ toJSON(github.event.client_payload.metadata) }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Triage with Claude Code
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          prompt: |
+            A Sentry error was detected in the mint.day codebase. Triage it.
+
+            ## Error Details
+            - **Title**: ${SENTRY_TITLE}
+            - **Culprit**: ${SENTRY_CULPRIT}
+            - **Level**: ${SENTRY_LEVEL}
+            - **First seen**: ${SENTRY_FIRST_SEEN}
+            - **Count**: ${SENTRY_COUNT}
+            - **Sentry URL**: ${SENTRY_URL}
+            - **Tags**: ${SENTRY_TAGS}
+            - **Metadata**: ${SENTRY_METADATA}
+
+            ## Your job
+
+            1. Read the relevant source files in `api/` and `src/` to understand the error.
+            2. Determine: is this a real bug, or noise (transient network error, user input, rate limit)?
+
+            **If real bug:**
+            - Create a new branch `fix/sentry-${SENTRY_SHORT_ID}`
+            - Write the fix
+            - Commit and push
+            - Open a PR with the Sentry link in the description
+
+            **If noise:**
+            - Create an issue titled "Noise" with label "noise" and explain why it's not actionable
+            - Reference the Sentry short ID in the issue body
+
+            ## Context
+            - This is a Vercel serverless project (api/ directory has the functions)
+            - The MCP server is in src/
+            - Contract ABIs and addresses are in the source files
+            - Base mainnet RPC can be flaky — transient RPC errors are noise

package/api/classify.ts

@@ -1,4 +1,5 @@
 import type { VercelRequest, VercelResponse } from "@vercel/node";
+import { captureError } from "./lib/sentry.js";
 
 const GROQ_API_KEY = process.env.GROQ_API_KEY;
 const GROQ_MODEL = "llama-3.3-70b-versatile";
@@ -92,6 +93,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
     const parsed = JSON.parse(content);
     return res.status(200).json(parsed);
   } catch (err) {
+    captureError(err, { route: "classify" });
     return res.status(500).json({ error: "Classification failed", detail: String(err) });
   }
 }

package/api/feed.ts

@@ -1,5 +1,6 @@
 import type { VercelRequest, VercelResponse } from "@vercel/node";
 import { ethers } from "ethers";
+import { captureError } from "./lib/sentry.js";
 
 const RPC_URL = process.env.BASE_RPC_URL || "https://base-mainnet.public.blastapi.io";
 const CONTRACT = process.env.MINT_FACTORY_ADDRESS || "0x12a1c11a0b2860f64e7d8df20989f97d40de7f2c";
@@ -66,6 +67,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
       tokens: tokens.reverse(),
     });
   } catch (err: any) {
+    captureError(err, { route: "feed" });
     res.status(500).json({ error: err.message || "Failed to fetch feed" });
   }
 }

package/api/lib/sentry.ts

@@ -0,0 +1,28 @@
+// Lightweight Sentry error reporting for Vercel serverless functions
+// No framework SDK needed — just the Node SDK
+
+import * as Sentry from "@sentry/node";
+
+const SENTRY_DSN = process.env.SENTRY_DSN;
+
+if (SENTRY_DSN) {
+  Sentry.init({
+    dsn: SENTRY_DSN,
+    environment: process.env.VERCEL_ENV || "development",
+    release: process.env.VERCEL_GIT_COMMIT_SHA,
+    tracesSampleRate: 1.0,
+  });
+}
+
+export { Sentry };
+
+export function captureError(err: unknown, context?: Record<string, string>) {
+  if (!SENTRY_DSN) {
+    console.error("[sentry-disabled]", err);
+    return;
+  }
+  if (context) {
+    Sentry.setContext("mint.day", context);
+  }
+  Sentry.captureException(err);
+}

package/api/sentry-webhook.ts

@@ -0,0 +1,91 @@
+import type { VercelRequest, VercelResponse } from "@vercel/node";
+import { createHmac } from "crypto";
+
+// Sentry sends webhooks when new issues are created.
+// This endpoint validates the signature and dispatches a
+// repository_dispatch event to GitHub so the Claude Code Action
+// can triage + fix.
+
+const SENTRY_CLIENT_SECRET = process.env.SENTRY_CLIENT_SECRET;
+const GITHUB_TOKEN = process.env.GH_DISPATCH_TOKEN;
+const GITHUB_REPO = "jordanlyall/mintday";
+
+function verifySentrySignature(
+  body: string,
+  signature: string | undefined,
+  secret: string
+): boolean {
+  if (!signature) return false;
+  const hmac = createHmac("sha256", secret);
+  hmac.update(body, "utf8");
+  const digest = hmac.digest("hex");
+  return signature === digest;
+}
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  if (req.method !== "POST") {
+    return res.status(405).json({ error: "POST only" });
+  }
+
+  if (!SENTRY_CLIENT_SECRET || !GITHUB_TOKEN) {
+    return res.status(500).json({ error: "Missing env vars" });
+  }
+
+  // Verify Sentry webhook signature
+  const rawBody = JSON.stringify(req.body);
+  const signature = req.headers["sentry-hook-signature"] as string | undefined;
+
+  if (!verifySentrySignature(rawBody, signature, SENTRY_CLIENT_SECRET)) {
+    return res.status(401).json({ error: "Invalid signature" });
+  }
+
+  const resource = req.headers["sentry-hook-resource"] as string;
+
+  // Only act on new issues (not updates/resolves)
+  if (resource !== "issue" || req.body?.action !== "created") {
+    return res.status(200).json({ status: "ignored", resource, action: req.body?.action });
+  }
+
+  const issue = req.body.data?.issue;
+  if (!issue) {
+    return res.status(200).json({ status: "no issue data" });
+  }
+
+  // Extract useful context for the agent
+  const payload = {
+    title: issue.title,
+    culprit: issue.culprit,
+    level: issue.level,
+    first_seen: issue.firstSeen,
+    count: issue.count,
+    url: issue.permalink,
+    short_id: issue.shortId,
+    metadata: issue.metadata,
+    tags: issue.tags?.map((t: { key: string; value: string }) => `${t.key}:${t.value}`),
+  };
+
+  // Dispatch to GitHub Actions
+  const ghRes = await fetch(
+    `https://api.github.com/repos/${GITHUB_REPO}/dispatches`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${GITHUB_TOKEN}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+      body: JSON.stringify({
+        event_type: "sentry_issue",
+        client_payload: payload,
+      }),
+    }
+  );
+
+  if (!ghRes.ok) {
+    const err = await ghRes.text();
+    console.error("GitHub dispatch failed:", err);
+    return res.status(502).json({ error: "GitHub dispatch failed" });
+  }
+
+  return res.status(200).json({ status: "dispatched", issue: payload.short_id });
+}

package/api/sponsor.ts

@@ -1,5 +1,6 @@
 import type { VercelRequest, VercelResponse } from "@vercel/node";
 import { ethers } from "ethers";
+import { captureError } from "./lib/sentry.js";
 
 const PRIVATE_KEY = process.env.SPONSORED_KEY;
 const RPC_URL = process.env.BASE_RPC_URL || "https://mainnet.base.org";
@@ -100,6 +101,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
       explorer: `https://basescan.org/tx/${receipt!.hash}`,
     });
   } catch (err) {
+    captureError(err, { route: "sponsor", recipient: recipient || "unknown" });
     const message = err instanceof Error ? err.message : String(err);
     return res.status(500).json({ error: `Transaction failed: ${message}` });
   }

package/api/verify.ts

@@ -1,5 +1,6 @@
 import type { VercelRequest, VercelResponse } from "@vercel/node";
 import { ethers } from "ethers";
+import { captureError } from "./lib/sentry.js";
 
 const RPC_URL = process.env.BASE_RPC_URL || "https://base-mainnet.public.blastapi.io";
 const CONTRACT = process.env.MINT_FACTORY_ADDRESS || "0x12a1c11a0b2860f64e7d8df20989f97d40de7f2c";
@@ -88,6 +89,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
       tokens,
     });
   } catch (err: any) {
+    captureError(err, { route: "verify", address });
     res.status(500).json({ error: err.message || "Failed to verify" });
   }
 }

package/dist/index.js

@@ -12,11 +12,11 @@ import { mintCheckSchema, handleMintCheck } from "./tools/mint-check.js";
 import { mintResolveSchema, handleMintResolve } from "./tools/mint-resolve.js";
 dotenv.config();
 // Testnet try-it wallet (Base Sepolia, pre-funded)
-const TRYIT_KEY = "REDACTED_RETIRED_KEY";
+const TRYIT_KEY = "";
 const TRYIT_CONTRACT = "0xa52450397f312c256Bd68B202C0CF90387Ea0E67";
 const TRYIT_RPC = "https://sepolia.base.org";
 const TRYIT_CHAIN = 84532;
-const MAINNET_CONTRACT = "0xbf12d372444dcf69df9316d961439f6b5919e8d0";
+const MAINNET_CONTRACT = "0x12a1c11a0b2860f64e7d8df20989f97d40de7f2c";
 const MAINNET_RPC = "https://mainnet.base.org";
 const MAINNET_CHAIN = 8453;
 // Load private key: env var > ~/.mint-day/credentials file
@@ -52,9 +52,9 @@ const defaultRecipient = process.env.DEFAULT_RECIPIENT || signerAddress || "";
 const calldataService = new CalldataService(rpcUrl, contractAddress, chainId);
 const server = new McpServer({
     name: "mint-day",
-    version: "0.3.3",
+    version: "0.4.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, {
+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). Supports two protocols: 'mintday' (default, gas-sponsored) and 'superrare' (Rare Protocol, requires PRIVATE_KEY). Set platform: 'superrare' to mint on Rare Protocol contracts. The token is immutable and publicly verifiable. Provide an image URL, local file path, or base64 for visual tokens. Returns a preview with mintId first; call again with mintId to confirm.", mintSchema, async (params) => handleMint(params, calldataService, defaultRecipient, userKey, {
     tryitKey: TRYIT_KEY,
     tryitContract: TRYIT_CONTRACT,
     tryitRpc: TRYIT_RPC,

package/dist/services/rare-protocol.d.ts

@@ -0,0 +1,19 @@
+import { MintIntent } from "../types.js";
+export interface RareMintResult {
+    status: string;
+    txHash: string;
+    tokenId: string;
+    contract: string;
+    platform: string;
+    tokenType: string;
+    soulbound: boolean;
+    recipient: string;
+    chain: string;
+    explorer: string;
+    tokenUri: string;
+}
+export declare function mintOnRareProtocol(intent: MintIntent, privateKey: string, isTestnet?: boolean): Promise<RareMintResult>;
+export declare function deployRareCollection(privateKey: string, name: string, symbol: string, isTestnet?: boolean): Promise<{
+    contract: string;
+    txHash: string;
+}>;

package/dist/services/rare-protocol.js

@@ -0,0 +1,77 @@
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { createRareClient } from "@rareprotocol/rare-cli/client";
+import { encodeMetadata } from "./metadata.js";
+import { TOKEN_TYPE_NAMES } from "../types.js";
+// Default mint.day collection on Rare Protocol (Base mainnet)
+// Set via RARE_CONTRACT env var, or deploy one with scripts/deploy-rare-collection.ts
+const DEFAULT_RARE_CONTRACT = process.env.RARE_CONTRACT || "";
+export async function mintOnRareProtocol(intent, privateKey, isTestnet = false) {
+    const chain = isTestnet ? baseSepolia : base;
+    const contractAddress = DEFAULT_RARE_CONTRACT;
+    if (!contractAddress) {
+        throw new Error("RARE_CONTRACT not set. Deploy a collection first: node scripts/deploy-rare-collection.mjs");
+    }
+    const account = privateKeyToAccount(privateKey);
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: http(),
+    });
+    // Cast clients to satisfy rare-cli's bundled viem types (runtime-compatible)
+    const rare = createRareClient({
+        publicClient: publicClient,
+        walletClient: walletClient,
+        account: account.address,
+    });
+    // Build metadata URI (same format as MintFactory path)
+    const tokenUri = encodeMetadata(intent.metadata);
+    // Mint via Rare Protocol
+    const result = await rare.mint.mintTo({
+        contract: contractAddress,
+        tokenUri,
+        to: intent.recipient,
+    });
+    const explorerBase = isTestnet ? "sepolia.basescan.org" : "basescan.org";
+    return {
+        status: "minted",
+        txHash: result.txHash,
+        tokenId: result.tokenId?.toString() || "unknown",
+        contract: contractAddress,
+        platform: "superrare",
+        tokenType: TOKEN_TYPE_NAMES[intent.tokenType],
+        soulbound: intent.soulbound,
+        recipient: intent.recipient,
+        chain: isTestnet ? "Base Sepolia (testnet)" : "Base",
+        explorer: `https://${explorerBase}/tx/${result.txHash}`,
+        tokenUri,
+    };
+}
+export async function deployRareCollection(privateKey, name, symbol, isTestnet = false) {
+    const chain = isTestnet ? baseSepolia : base;
+    const account = privateKeyToAccount(privateKey);
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: http(),
+    });
+    const rare = createRareClient({
+        publicClient: publicClient,
+        walletClient: walletClient,
+        account: account.address,
+    });
+    const result = await rare.deploy.erc721({ name, symbol });
+    return {
+        contract: result.contract || "unknown",
+        txHash: result.txHash,
+    };
+}

package/dist/tools/mint.d.ts

@@ -15,6 +15,10 @@ export declare const mintSchema: {
     animation_url: z.ZodOptional<z.ZodString>;
     mintId: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    platform: z.ZodOptional<z.ZodEnum<{
+        superrare: "superrare";
+        mintday: "mintday";
+    }>>;
 };
 interface TryitConfig {
     tryitKey: string;
@@ -31,6 +35,7 @@ export declare function handleMint(params: {
     animation_url?: string;
     mintId?: string;
     metadata?: Record<string, unknown>;
+    platform?: string;
 }, calldataService: CalldataService, defaultRecipient: string, userKey?: string, tryit?: TryitConfig): Promise<{
     content: {
         type: "text";

package/dist/tools/mint.js

@@ -5,18 +5,19 @@ import { TokenType, TOKEN_TYPE_NAMES } from "../types.js";
 import { classifyIntent } from "../services/classifier.js";
 import { CalldataService } from "../services/calldata.js";
 import { resolveImage } from "../services/image-upload.js";
-// Intent cache: preview mintId -> frozen intent
+import { mintOnRareProtocol } from "../services/rare-protocol.js";
+// Intent cache: preview mintId -> frozen intent + platform
 const intentCache = new Map();
 const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-function cacheMintId(intent) {
+function cacheMintId(intent, platform = "mintday") {
     const hash = createHash("sha256")
         .update(JSON.stringify(intent))
         .digest("hex")
         .slice(0, 12);
-    intentCache.set(hash, { intent, expiresAt: Date.now() + CACHE_TTL_MS });
+    intentCache.set(hash, { intent, platform, expiresAt: Date.now() + CACHE_TTL_MS });
     return hash;
 }
-function getCachedIntent(mintId) {
+function getCachedEntry(mintId) {
     const entry = intentCache.get(mintId);
     if (!entry)
         return null;
@@ -24,7 +25,7 @@ function getCachedIntent(mintId) {
         intentCache.delete(mintId);
         return null;
     }
-    return entry.intent;
+    return { intent: entry.intent, platform: entry.platform };
 }
 export const mintSchema = {
     description: z
@@ -59,8 +60,12 @@ export const mintSchema = {
         .record(z.string(), z.unknown())
         .optional()
         .describe("Additional key-value metadata. Supports strings, arrays, and objects (e.g. capabilities: ['mint'])."),
+    platform: z
+        .enum(["mintday", "superrare"])
+        .optional()
+        .describe("Which protocol to mint on. 'mintday' uses the MintFactory contract (default). 'superrare' mints via Rare Protocol on Base."),
 };
-const SPONSOR_URL = process.env.SPONSOR_URL || "https://agent-mint-nine.vercel.app/api/sponsor";
+const SPONSOR_URL = process.env.SPONSOR_URL || "https://www.mint.day/api/sponsor";
 async function sponsoredMint(result, recipient) {
     try {
         const response = await fetch(SPONSOR_URL, {
@@ -92,22 +97,17 @@ async function sponsoredMint(result, recipient) {
             sponsored: true,
         };
     }
-    catch {
-        return null;
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { error: `Sponsor request failed: ${message}` };
     }
 }
 export async function handleMint(params, calldataService, defaultRecipient, userKey = "", tryit = { tryitKey: "", tryitContract: "", tryitRpc: "", tryitChain: 84532 }) {
-    // Determine mode:
-    // 1. User has private key: mainnet, sign + submit locally
-    // 2. No key but recipient provided: mainnet, sponsored gas via server
-    // 3. No key, no recipient: testnet try-it mode
-    const hasRecipient = !!params.recipient;
-    const isTestnet = !userKey && !hasRecipient;
-    const privateKey = userKey || (isTestnet ? tryit.tryitKey : "");
     // Confirmation path: replay cached intent
+    // Check cache first so we can use cached recipient for mode detection
     if (params.mintId) {
-        const cached = getCachedIntent(params.mintId);
-        if (!cached) {
+        const entry = getCachedEntry(params.mintId);
+        if (!entry) {
             return {
                 content: [{
                         type: "text",
@@ -115,7 +115,42 @@ export async function handleMint(params, calldataService, defaultRecipient, user
                     }],
             };
         }
+        const cached = entry.intent;
+        const cachedPlatform = entry.platform;
         intentCache.delete(params.mintId);
+        // Mode detection using cached recipient
+        const hasRecipient = !!cached.recipient;
+        const isTestnet = !userKey && !hasRecipient;
+        const privateKey = userKey || (isTestnet ? tryit.tryitKey : "");
+        // Rare Protocol path: mint via SuperRare contracts on Base
+        if (cachedPlatform === "superrare") {
+            if (!privateKey) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ error: "SuperRare minting requires a private key. Save one to ~/.mint-day/credentials." }, null, 2),
+                        }],
+                };
+            }
+            try {
+                const rareResult = await mintOnRareProtocol(cached, privateKey, isTestnet);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(rareResult, null, 2),
+                        }],
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ error: `SuperRare mint failed: ${message}` }, null, 2),
+                        }],
+                };
+            }
+        }
         // Use testnet calldataService if in try-it mode
         let activeCalldataService = calldataService;
         if (isTestnet) {
@@ -221,6 +256,8 @@ export async function handleMint(params, calldataService, defaultRecipient, user
         };
     }
     const recipient = params.recipient || defaultRecipient;
+    const hasRecipient = !!recipient;
+    const isTestnet = !userKey && !hasRecipient;
     if (!recipient) {
         return {
             content: [{
@@ -326,11 +363,13 @@ export async function handleMint(params, calldataService, defaultRecipient, user
         }
     }
     // Cache intent and return preview
-    const mintId = cacheMintId(intent);
+    const selectedPlatform = params.platform || "mintday";
+    const mintId = cacheMintId(intent, selectedPlatform);
     const preview = {
         status: "preview",
         mintId,
-        message: `I'll mint a ${TOKEN_TYPE_NAMES[intent.tokenType]} token${intent.soulbound ? " (soulbound)" : ""} to ${intent.recipient}.`,
+        platform: selectedPlatform,
+        message: `I'll mint a ${TOKEN_TYPE_NAMES[intent.tokenType]} token${intent.soulbound ? " (soulbound)" : ""} to ${intent.recipient} via ${selectedPlatform === "superrare" ? "Rare Protocol (SuperRare)" : "mint.day"}.`,
         tokenType: TOKEN_TYPE_NAMES[intent.tokenType],
         soulbound: intent.soulbound,
         recipient: intent.recipient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mint-day",
-  "version": "0.3.3",
+  "version": "0.4.2",
   "description": "Agent-native minting on Base. One tool call, any token type.",
   "main": "dist/index.js",
   "bin": {
@@ -24,8 +24,11 @@
   "type": "module",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "@rareprotocol/rare-cli": "^0.3.0",
+    "@sentry/node": "^10.45.0",
     "dotenv": "^17.3.1",
     "ethers": "^6.16.0",
+    "viem": "^2.47.6",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/scripts/deploy-rare-collection.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Deploy a mint.day collection on Rare Protocol (SuperRare).
+ *
+ * Usage:
+ *   node scripts/deploy-rare-collection.mjs [--testnet]
+ *
+ * Requires: PRIVATE_KEY env var or ~/.mint-day/credentials
+ * Output: prints the contract address to set as RARE_CONTRACT
+ */
+
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { createRareClient } from "@rareprotocol/rare-cli/client";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const isTestnet = process.argv.includes("--testnet");
+const chain = isTestnet ? baseSepolia : base;
+
+// Load private key
+let privateKey = process.env.PRIVATE_KEY || "";
+if (!privateKey) {
+  const credPath = join(homedir(), ".mint-day", "credentials");
+  if (existsSync(credPath)) {
+    privateKey = readFileSync(credPath, "utf-8").trim();
+  }
+}
+
+if (!privateKey) {
+  console.error("No private key found. Set PRIVATE_KEY env var or save to ~/.mint-day/credentials");
+  process.exit(1);
+}
+
+const account = privateKeyToAccount(privateKey);
+console.log(`Deploying mint.day collection on ${isTestnet ? "Base Sepolia" : "Base"}...`);
+console.log(`Deployer: ${account.address}`);
+
+const publicClient = createPublicClient({ chain, transport: http() });
+const walletClient = createWalletClient({ account, chain, transport: http() });
+
+const rare = createRareClient({
+  publicClient,
+  walletClient,
+  account: account.address,
+});
+
+try {
+  const result = await rare.deploy.erc721({
+    name: "mint.day",
+    symbol: "MINTDAY",
+  });
+
+  console.log(`\nCollection deployed!`);
+  console.log(`Contract: ${result.contract}`);
+  console.log(`TX: https://${isTestnet ? "sepolia." : ""}basescan.org/tx/${result.txHash}`);
+  console.log(`\nSet this in your environment:`);
+  console.log(`  export RARE_CONTRACT=${result.contract}`);
+} catch (err) {
+  console.error("Deploy failed:", err.message || err);
+  process.exit(1);
+}