mint-day 0.3.0

package/dist/tools/mint-check.js

@@ -0,0 +1,177 @@
+import { z } from "zod";
+import { ethers } from "ethers";
+import { resolveEns, looksLikeEns } from "../services/ens.js";
+const TOKEN_TYPE_NAMES = ["Identity", "Attestation", "Credential", "Receipt", "Pass"];
+const MINT_FACTORY_ABI = [
+    "event Minted(uint256 indexed tokenId, address indexed to, uint8 tokenType, bool soulbound, string tokenURI)",
+    "function tokenURI(uint256 tokenId) view returns (string)",
+    "function tokenData(uint256 tokenId) view returns (uint8 tokenType, bool soulbound, uint256 mintedAt)",
+    "function ownerOf(uint256 tokenId) view returns (address)",
+];
+// Deploy blocks per chain to avoid scanning from genesis
+const DEPLOY_BLOCKS = {
+    8453: 28000000, // Base mainnet (approximate, update after deploy)
+    84532: 22000000, // Base Sepolia (approximate)
+};
+export const mintCheckSchema = {
+    address: z
+        .string()
+        .optional()
+        .describe("Ethereum address to check for mint.day tokens. If omitted, returns global stats."),
+    txHash: z
+        .string()
+        .optional()
+        .describe("Transaction hash to look up a specific mint. Returns token details from the tx receipt."),
+};
+export async function handleMintCheck(params, calldataService, provider, contractAddress, chainId) {
+    // Tx hash lookup: get token details from a specific transaction
+    if (params.txHash) {
+        const receipt = await provider.getTransactionReceipt(params.txHash);
+        if (!receipt) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ error: "Transaction not found." }, null, 2),
+                    }],
+            };
+        }
+        const contract = new ethers.Contract(contractAddress, MINT_FACTORY_ABI, provider);
+        const mintedLogs = receipt.logs
+            .filter(log => log.address.toLowerCase() === contractAddress.toLowerCase())
+            .map(log => {
+            try {
+                return contract.interface.parseLog({ topics: [...log.topics], data: log.data });
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(parsed => parsed?.name === "Minted");
+        if (mintedLogs.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ error: "No mint.day Minted event found in this transaction.", txHash: params.txHash }, null, 2),
+                    }],
+            };
+        }
+        const tokens = await Promise.all(mintedLogs.map(async (log) => {
+            const tokenId = log.args[0].toString();
+            const to = log.args[1];
+            const tokenType = Number(log.args[2]);
+            const soulbound = Boolean(log.args[3]);
+            const uri = await contract.tokenURI(tokenId);
+            let metadata = {};
+            if (uri.startsWith("data:application/json;base64,")) {
+                try {
+                    metadata = JSON.parse(Buffer.from(uri.replace("data:application/json;base64,", ""), "base64").toString());
+                }
+                catch {
+                    metadata = { raw: uri };
+                }
+            }
+            return {
+                tokenId,
+                to,
+                tokenType: TOKEN_TYPE_NAMES[tokenType] || "Unknown",
+                soulbound,
+                metadata,
+            };
+        }));
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        txHash: params.txHash,
+                        blockNumber: receipt.blockNumber,
+                        status: receipt.status === 1 ? "success" : "failed",
+                        tokens,
+                    }, null, 2),
+                }],
+        };
+    }
+    // No address: return global stats (replaces mint_status)
+    if (!params.address) {
+        const total = await calldataService.totalMinted();
+        const fee = await calldataService.mintFee();
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ totalMinted: total, mintFee: `${fee} ETH`, chainId }, null, 2),
+                }],
+        };
+    }
+    // Resolve ENS names
+    let address = params.address;
+    if (looksLikeEns(address)) {
+        try {
+            address = await resolveEns(address);
+        }
+        catch {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ error: `Could not resolve ENS name: ${params.address}` }, null, 2),
+                    }],
+            };
+        }
+    }
+    // Validate address
+    if (!ethers.isAddress(address)) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ error: `Invalid Ethereum address: ${address}` }, null, 2),
+                }],
+        };
+    }
+    const contract = new ethers.Contract(contractAddress, MINT_FACTORY_ABI, provider);
+    const fromBlock = DEPLOY_BLOCKS[chainId] || 0;
+    const filter = contract.filters.Minted(null, address);
+    const events = await contract.queryFilter(filter, fromBlock, "latest");
+    if (events.length === 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ address, tokens: [], count: 0 }, null, 2),
+                }],
+        };
+    }
+    const tokens = await Promise.all(events.map(async (event) => {
+        const log = event;
+        const tokenId = log.args[0].toString();
+        let currentOwner = null;
+        try {
+            currentOwner = await contract.ownerOf(tokenId);
+        }
+        catch {
+            currentOwner = null; // burned
+        }
+        const [tokenType, soulbound, mintedAt] = await contract.tokenData(tokenId);
+        const uri = await contract.tokenURI(tokenId);
+        let metadata = {};
+        if (uri.startsWith("data:application/json;base64,")) {
+            const base64 = uri.replace("data:application/json;base64,", "");
+            try {
+                metadata = JSON.parse(Buffer.from(base64, "base64").toString());
+            }
+            catch {
+                metadata = { raw: uri };
+            }
+        }
+        return {
+            tokenId,
+            tokenType: TOKEN_TYPE_NAMES[Number(tokenType)] || "Unknown",
+            soulbound: Boolean(soulbound),
+            mintedAt: new Date(Number(mintedAt) * 1000).toISOString(),
+            currentOwner,
+            metadata,
+        };
+    }));
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({ address, tokens, count: tokens.length }, null, 2),
+            }],
+    };
+}

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { ethers } from "ethers";
+export declare const mintResolveSchema: {
+    address: z.ZodString;
+};
+export declare function handleMintResolve(params: {
+    address: string;
+}, provider: ethers.JsonRpcProvider, contractAddress: string, chainId: number): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/mint-resolve.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { ethers } from "ethers";
+import { resolveEns, looksLikeEns } from "../services/ens.js";
+const TOKEN_TYPE_NAMES = ["Identity", "Attestation", "Credential", "Receipt", "Pass"];
+const MINT_FACTORY_ABI = [
+    "event Minted(uint256 indexed tokenId, address indexed to, uint8 tokenType, bool soulbound, string tokenURI)",
+    "function tokenURI(uint256 tokenId) view returns (string)",
+    "function tokenData(uint256 tokenId) view returns (uint8 tokenType, bool soulbound, uint256 mintedAt)",
+    "function ownerOf(uint256 tokenId) view returns (address)",
+];
+const DEPLOY_BLOCKS = {
+    8453: 28000000,
+    84532: 22000000,
+};
+export const mintResolveSchema = {
+    address: z
+        .string()
+        .describe("Ethereum address or ENS name to resolve. Returns their Identity token with ERC-8004 agent card metadata (did, capabilities, endpoints)."),
+};
+export async function handleMintResolve(params, provider, contractAddress, chainId) {
+    let address = params.address;
+    if (looksLikeEns(address)) {
+        try {
+            address = await resolveEns(address);
+        }
+        catch {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ error: `Could not resolve ENS name: ${params.address}` }, null, 2),
+                    }],
+            };
+        }
+    }
+    if (!ethers.isAddress(address)) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ error: `Invalid Ethereum address: ${address}` }, null, 2),
+                }],
+        };
+    }
+    const contract = new ethers.Contract(contractAddress, MINT_FACTORY_ABI, provider);
+    const fromBlock = DEPLOY_BLOCKS[chainId] || 0;
+    // Query all Minted events to this address
+    const filter = contract.filters.Minted(null, address);
+    const events = await contract.queryFilter(filter, fromBlock, "latest");
+    // Find Identity tokens (tokenType === 0)
+    let identityEvent = null;
+    for (const event of events) {
+        const log = event;
+        if (Number(log.args[2]) === 0) {
+            identityEvent = log; // take the latest Identity token
+        }
+    }
+    if (!identityEvent) {
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        address,
+                        identity: null,
+                        message: "No Identity token found for this address.",
+                    }, null, 2),
+                }],
+        };
+    }
+    const tokenId = identityEvent.args[0].toString();
+    let currentOwner = null;
+    try {
+        currentOwner = await contract.ownerOf(tokenId);
+    }
+    catch {
+        currentOwner = null;
+    }
+    const [, soulbound, mintedAt] = await contract.tokenData(tokenId);
+    const uri = await contract.tokenURI(tokenId);
+    let metadata = {};
+    if (uri.startsWith("data:application/json;base64,")) {
+        const base64 = uri.replace("data:application/json;base64,", "");
+        try {
+            metadata = JSON.parse(Buffer.from(base64, "base64").toString());
+        }
+        catch {
+            metadata = { raw: uri };
+        }
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    address,
+                    identity: {
+                        tokenId,
+                        soulbound: Boolean(soulbound),
+                        mintedAt: new Date(Number(mintedAt) * 1000).toISOString(),
+                        currentOwner,
+                        did: metadata.did || null,
+                        capabilities: metadata.capabilities || [],
+                        endpoints: metadata.endpoints || [],
+                        name: metadata.name || null,
+                        description: metadata.description || null,
+                        image: metadata.image || null,
+                    },
+                }, null, 2),
+            }],
+    };
+}

package/dist/tools/mint.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { CalldataService } from "../services/calldata.js";
+export declare const mintSchema: {
+    description: z.ZodOptional<z.ZodString>;
+    tokenType: z.ZodOptional<z.ZodEnum<{
+        Identity: "Identity";
+        Attestation: "Attestation";
+        Credential: "Credential";
+        Receipt: "Receipt";
+        Pass: "Pass";
+    }>>;
+    recipient: z.ZodOptional<z.ZodString>;
+    soulbound: z.ZodOptional<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodString>;
+    animation_url: z.ZodOptional<z.ZodString>;
+    mintId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+interface SponsoredConfig {
+    sponsoredKey: string;
+    sponsoredContract: string;
+    sponsoredRpc: string;
+    sponsoredChain: number;
+    fallbackContract: string;
+    fallbackRpc: string;
+    fallbackChain: number;
+}
+export declare function handleMint(params: {
+    description?: string;
+    tokenType?: string;
+    recipient?: string;
+    soulbound?: boolean;
+    image?: string;
+    animation_url?: string;
+    mintId?: string;
+    metadata?: Record<string, unknown>;
+}, calldataService: CalldataService, defaultRecipient: string, userKey?: string, sponsored?: SponsoredConfig): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export {};