mint-day 0.3.2 → 0.3.3

package/dist/tools/mint.js

@@ -5,7 +5,6 @@ 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";
-import { resolveEns, looksLikeEns } from "../services/ens.js";
 // Intent cache: preview mintId -> frozen intent
 const intentCache = new Map();
 const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
@@ -27,54 +26,6 @@ function getCachedIntent(mintId) {
     }
     return entry.intent;
 }
-// --- Rate limiter (in-memory, resets on process restart) ---
-const LIMITS = {
-    perAddress: 10,
-    perHour: 50,
-    perDay: 500,
-};
-const addressMints = new Map();
-const hourlyWindow = { count: 0, resetAt: Date.now() + 60 * 60 * 1000 };
-const dailyWindow = { count: 0, resetAt: Date.now() + 24 * 60 * 60 * 1000 };
-function checkRateLimit(address) {
-    const now = Date.now();
-    const addr = address.toLowerCase();
-    // Reset windows if expired
-    if (now >= hourlyWindow.resetAt) {
-        hourlyWindow.count = 0;
-        hourlyWindow.resetAt = now + 60 * 60 * 1000;
-    }
-    if (now >= dailyWindow.resetAt) {
-        dailyWindow.count = 0;
-        dailyWindow.resetAt = now + 24 * 60 * 60 * 1000;
-        addressMints.clear(); // reset per-address counts daily
-    }
-    const addrCount = addressMints.get(addr) || 0;
-    if (addrCount >= LIMITS.perAddress) {
-        return { allowed: false, reason: `Address limit reached (${LIMITS.perAddress} sponsored mints per address per day)` };
-    }
-    if (hourlyWindow.count >= LIMITS.perHour) {
-        return { allowed: false, reason: `Hourly limit reached (${LIMITS.perHour} sponsored mints per hour)` };
-    }
-    if (dailyWindow.count >= LIMITS.perDay) {
-        return { allowed: false, reason: `Daily limit reached (${LIMITS.perDay} sponsored mints per day)` };
-    }
-    return {
-        allowed: true,
-        remaining: {
-            address: LIMITS.perAddress - addrCount - 1,
-            hourly: LIMITS.perHour - hourlyWindow.count - 1,
-            daily: LIMITS.perDay - dailyWindow.count - 1,
-        },
-    };
-}
-function recordMint(address) {
-    const addr = address.toLowerCase();
-    addressMints.set(addr, (addressMints.get(addr) || 0) + 1);
-    hourlyWindow.count++;
-    dailyWindow.count++;
-}
-// --- Schema + Handler ---
 export const mintSchema = {
     description: z
         .string()
@@ -87,7 +38,7 @@ export const mintSchema = {
     recipient: z
         .string()
         .optional()
-        .describe("Ethereum address or ENS name to receive the token. Required unless DEFAULT_RECIPIENT is set in server config."),
+        .describe("Ethereum address to receive the token. Required unless DEFAULT_RECIPIENT is set in server config."),
     soulbound: z
         .boolean()
         .optional()
@@ -109,12 +60,50 @@ export const mintSchema = {
         .optional()
         .describe("Additional key-value metadata. Supports strings, arrays, and objects (e.g. capabilities: ['mint'])."),
 };
-export async function handleMint(params, calldataService, defaultRecipient, userKey = "", sponsored = {
-    sponsoredKey: "", sponsoredContract: "", sponsoredRpc: "", sponsoredChain: 8453,
-    fallbackContract: "", fallbackRpc: "", fallbackChain: 84532,
-}) {
+const SPONSOR_URL = process.env.SPONSOR_URL || "https://agent-mint-nine.vercel.app/api/sponsor";
+async function sponsoredMint(result, recipient) {
+    try {
+        const response = await fetch(SPONSOR_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                to: result.to,
+                calldata: result.calldata,
+                value: result.value,
+                estimatedGas: result.estimatedGas,
+                recipient,
+            }),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            return { error: err.error || `Sponsored mint failed (${response.status})` };
+        }
+        const data = await response.json();
+        return {
+            status: "minted",
+            txHash: data.txHash,
+            blockNumber: data.blockNumber,
+            gasUsed: data.gasUsed,
+            tokenType: result.tokenType,
+            soulbound: result.soulbound,
+            recipient,
+            chain: "Base",
+            explorer: data.explorer,
+            sponsored: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+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 sponsoredGas = !userKey;
+    const isTestnet = !userKey && !hasRecipient;
+    const privateKey = userKey || (isTestnet ? tryit.tryitKey : "");
     // Confirmation path: replay cached intent
     if (params.mintId) {
         const cached = getCachedIntent(params.mintId);
@@ -127,93 +116,17 @@ export async function handleMint(params, calldataService, defaultRecipient, user
             };
         }
         intentCache.delete(params.mintId);
-        // Sponsored mode: check rate limits before submitting
-        if (sponsoredGas) {
-            const limit = checkRateLimit(cached.recipient);
-            if (limit.allowed) {
-                // Sponsored mainnet mint
-                const sponsoredService = new CalldataService(sponsored.sponsoredRpc, sponsored.sponsoredContract, sponsored.sponsoredChain);
-                const result = await sponsoredService.buildMintCalldata(cached);
-                try {
-                    const wallet = new ethers.Wallet(sponsored.sponsoredKey, sponsoredService.provider);
-                    const tx = await wallet.sendTransaction({
-                        to: result.to,
-                        data: result.calldata,
-                        value: BigInt(result.value),
-                        gasLimit: result.estimatedGas,
-                    });
-                    const receipt = await tx.wait();
-                    recordMint(cached.recipient);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    status: "minted",
-                                    txHash: receipt.hash,
-                                    blockNumber: receipt.blockNumber,
-                                    gasUsed: receipt.gasUsed.toString(),
-                                    tokenType: result.tokenType,
-                                    soulbound: result.soulbound,
-                                    recipient: cached.recipient,
-                                    chain: "Base",
-                                    explorer: `https://basescan.org/tx/${receipt.hash}`,
-                                }, null, 2),
-                            }],
-                    };
-                }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    // On tx failure (e.g. sponsored wallet out of gas), fall back to calldata
-                    const fallbackService = new CalldataService(sponsored.sponsoredRpc, sponsored.sponsoredContract, sponsored.sponsoredChain);
-                    const fallbackResult = await fallbackService.buildMintCalldata(cached);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    status: "calldata",
-                                    reason: `Sponsored mint failed (${message}). Returning calldata for you to submit.`,
-                                    to: fallbackResult.to,
-                                    calldata: fallbackResult.calldata,
-                                    value: fallbackResult.value,
-                                    estimatedGas: fallbackResult.estimatedGas,
-                                    chainId: fallbackResult.chainId,
-                                    tokenType: fallbackResult.tokenType,
-                                    soulbound: fallbackResult.soulbound,
-                                }, null, 2),
-                            }],
-                    };
-                }
-            }
-            else {
-                // Rate limit exceeded: return calldata on mainnet (user pays gas)
-                const mainnetService = new CalldataService(sponsored.sponsoredRpc, sponsored.sponsoredContract, sponsored.sponsoredChain);
-                const result = await mainnetService.buildMintCalldata(cached);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                status: "calldata",
-                                reason: limit.reason,
-                                message: "Sponsored gas limit reached. Here's the calldata to submit with your own wallet.",
-                                to: result.to,
-                                calldata: result.calldata,
-                                value: result.value,
-                                estimatedGas: result.estimatedGas,
-                                chainId: result.chainId,
-                                tokenType: result.tokenType,
-                                soulbound: result.soulbound,
-                                chain: "Base",
-                                setup: "Save a private key to ~/.mint-day/credentials for unlimited self-funded mints.",
-                            }, null, 2),
-                        }],
-                };
-            }
+        // Use testnet calldataService if in try-it mode
+        let activeCalldataService = calldataService;
+        if (isTestnet) {
+            activeCalldataService = new CalldataService(tryit.tryitRpc, tryit.tryitContract, tryit.tryitChain);
         }
-        // User-key mode: sign and submit with user's key
-        if (userKey) {
-            const result = await calldataService.buildMintCalldata(cached);
+        const result = await activeCalldataService.buildMintCalldata(cached);
+        // If we have a private key, sign and submit directly
+        if (privateKey) {
             try {
-                const wallet = new ethers.Wallet(userKey, calldataService.provider);
+                const provider = isTestnet ? activeCalldataService.provider : calldataService.provider;
+                const wallet = new ethers.Wallet(privateKey, provider);
                 const tx = await wallet.sendTransaction({
                     to: result.to,
                     data: result.calldata,
@@ -221,20 +134,24 @@ export async function handleMint(params, calldataService, defaultRecipient, user
                     gasLimit: result.estimatedGas,
                 });
                 const receipt = await tx.wait();
+                const response = {
+                    status: "minted",
+                    txHash: receipt.hash,
+                    blockNumber: receipt.blockNumber,
+                    gasUsed: receipt.gasUsed.toString(),
+                    tokenType: result.tokenType,
+                    soulbound: result.soulbound,
+                    recipient: cached.recipient,
+                    chain: isTestnet ? "Base Sepolia (testnet)" : "Base",
+                    explorer: `https://${result.chainId === 8453 ? "" : "sepolia."}basescan.org/tx/${receipt.hash}`,
+                };
+                if (isTestnet) {
+                    response.note = "This token was minted on Base Sepolia (testnet). To mint on Base mainnet, save a private key to ~/.mint-day/credentials and restart the MCP server.";
+                }
                 return {
                     content: [{
                             type: "text",
-                            text: JSON.stringify({
-                                status: "minted",
-                                txHash: receipt.hash,
-                                blockNumber: receipt.blockNumber,
-                                gasUsed: receipt.gasUsed.toString(),
-                                tokenType: result.tokenType,
-                                soulbound: result.soulbound,
-                                recipient: cached.recipient,
-                                chain: "Base",
-                                explorer: `https://basescan.org/tx/${receipt.hash}`,
-                            }, null, 2),
+                            text: JSON.stringify(response, null, 2),
                         }],
                 };
             }
@@ -248,8 +165,37 @@ export async function handleMint(params, calldataService, defaultRecipient, user
                 };
             }
         }
-        // Calldata-only mode (recipient provided, no key)
-        const result = await calldataService.buildMintCalldata(cached);
+        // No user key but has recipient: try sponsored gas
+        if (hasRecipient) {
+            const sponsored = await sponsoredMint(result, cached.recipient);
+            if (sponsored && !sponsored.error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(sponsored, null, 2),
+                        }],
+                };
+            }
+            // Sponsored failed: fall through to calldata
+            if (sponsored?.error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: "calldata",
+                                note: `Sponsored gas unavailable: ${sponsored.error}. Use this calldata with your own signer.`,
+                                to: result.to,
+                                calldata: result.calldata,
+                                value: result.value,
+                                estimatedGas: result.estimatedGas,
+                                chainId: result.chainId,
+                                tokenType: result.tokenType,
+                                soulbound: result.soulbound,
+                            }, null, 2),
+                        }],
+                };
+            }
+        }
         return {
             content: [{
                     type: "text",
@@ -274,23 +220,7 @@ export async function handleMint(params, calldataService, defaultRecipient, user
                 }],
         };
     }
-    let recipient = params.recipient || defaultRecipient;
-    // Resolve ENS names to addresses
-    if (recipient && looksLikeEns(recipient)) {
-        try {
-            const resolved = await resolveEns(recipient);
-            recipient = resolved;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({ error: message }, null, 2),
-                    }],
-            };
-        }
-    }
+    const recipient = params.recipient || defaultRecipient;
     if (!recipient) {
         return {
             content: [{
@@ -363,7 +293,7 @@ export async function handleMint(params, calldataService, defaultRecipient, user
             creator: recipient,
             recipient,
             timestamp: new Date().toISOString(),
-            chainId: 8453,
+            chainId: parseInt(process.env.CHAIN_ID || "84532"),
             mintday_version: "1",
             ...(resolvedImage ? { image: resolvedImage } : {}),
             ...(params.animation_url ? { animation_url: params.animation_url } : {}),
@@ -372,7 +302,7 @@ export async function handleMint(params, calldataService, defaultRecipient, user
         // ERC-8004 defaults for Identity tokens
         if (tokenType === TokenType.Identity) {
             if (!meta.did)
-                meta.did = `did:pkh:eip155:8453:${recipient}`;
+                meta.did = `did:pkh:eip155:${parseInt(process.env.CHAIN_ID || "84532")}:${recipient}`;
             if (!meta.capabilities)
                 meta.capabilities = [];
             if (!meta.endpoints)
@@ -417,7 +347,12 @@ export async function handleMint(params, calldataService, defaultRecipient, user
         preview.missingFields = intent.missingFields;
         preview.hint = "Identity tokens (ERC-8004) should include capabilities[], endpoints[], and did. Provide these in metadata for full compliance.";
     }
-    preview.chain = "Base";
+    if (isTestnet) {
+        preview.chain = "Base Sepolia (testnet)";
+    }
+    else {
+        preview.chain = "Base";
+    }
     preview.instruction = "Call mint with mintId to confirm.";
     return {
         content: [{ type: "text", text: JSON.stringify(preview, null, 2) }],