mint-day 0.3.2 → 0.4.1

package/.env.example

@@ -0,0 +1,5 @@
+BASE_RPC_URL=
+MINT_FACTORY_ADDRESS=
+ANTHROPIC_API_KEY=
+CHAIN_ID=84532
+DEFAULT_RECIPIENT=

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

@@ -0,0 +1,99 @@
+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";
+const GROQ_URL = "https://api.groq.com/openai/v1/chat/completions";
+
+const SYSTEM_PROMPT = `You are a token type classifier for mint.day. Given a natural language minting request, return JSON with:
+- tokenType: one of "Identity", "Attestation", "Credential", "Receipt", "Pass"
+- soulbound: boolean
+- name: short descriptive name for the token
+- extractedFields: object with any additional fields you can extract (addresses, amounts, descriptions)
+- missingFields: array of field names that are required but not provided (empty if all present)
+
+Defaults:
+- Attestation and Credential are soulbound: true
+- Identity, Receipt, and Pass are soulbound: false
+- If the user explicitly says "soulbound" or "non-transferable", override the default
+- If the user explicitly says "transferable", set soulbound: false
+
+ERC-8004 Identity tokens REQUIRE these fields. Extract them if present, or add to missingFields:
+- did: decentralized identifier (e.g. "did:pkh:eip155:8453:0x...")
+- capabilities: array of strings describing what the agent can do
+- endpoints: array of strings with agent contact URIs (MCP, HTTP, etc.)
+
+Return ONLY valid JSON. No explanation.`;
+
+// Simple in-memory rate limiter: 60 requests per minute per IP
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
+const RATE_LIMIT = 60;
+const RATE_WINDOW_MS = 60 * 1000;
+
+function checkRateLimit(ip: string): boolean {
+  const now = Date.now();
+  const entry = rateLimitMap.get(ip);
+  if (!entry || now > entry.resetAt) {
+    rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_WINDOW_MS });
+    return true;
+  }
+  if (entry.count >= RATE_LIMIT) return false;
+  entry.count++;
+  return true;
+}
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  if (req.method !== "POST") {
+    return res.status(405).json({ error: "POST only" });
+  }
+
+  const ip = (req.headers["x-forwarded-for"] as string) || (req.headers["x-real-ip"] as string) || "unknown";
+  if (!checkRateLimit(ip)) {
+    return res.status(429).json({ error: "Rate limited. Try again in a minute." });
+  }
+
+  if (!GROQ_API_KEY) {
+    return res.status(500).json({ error: "Server misconfigured" });
+  }
+
+  const { text } = req.body || {};
+  if (!text || typeof text !== "string" || text.length > 1000) {
+    return res.status(400).json({ error: "text field required (max 1000 chars)" });
+  }
+
+  try {
+    const response = await fetch(GROQ_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${GROQ_API_KEY}`,
+      },
+      body: JSON.stringify({
+        model: GROQ_MODEL,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: `Mint request: "${text}"` },
+        ],
+        max_tokens: 200,
+        temperature: 0,
+      }),
+    });
+
+    if (!response.ok) {
+      return res.status(502).json({ error: "Classification failed" });
+    }
+
+    const data = await response.json() as { choices: Array<{ message: { content: string } }> };
+    let content = data.choices[0].message.content;
+
+    // Strip markdown code fences if present
+    content = content.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+
+    // Validate it's valid JSON before passing through
+    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

@@ -0,0 +1,73 @@
+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";
+const DEPLOY_BLOCK = 43461700;
+const CHUNK_SIZE = 9999;
+
+const TOKEN_TYPES = ["Identity", "Attestation", "Credential", "Receipt", "Pass"];
+
+const ABI = [
+  "event Minted(uint256 indexed tokenId, address indexed to, uint8 tokenType, bool soulbound, string tokenURI)",
+];
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Cache-Control", "s-maxage=30, stale-while-revalidate=60");
+
+  try {
+    const provider = new ethers.JsonRpcProvider(RPC_URL);
+    const contract = new ethers.Contract(CONTRACT, ABI, provider);
+
+    const latestBlock = await provider.getBlockNumber();
+
+    const filter = contract.filters.Minted();
+    const events: ethers.EventLog[] = [];
+    for (let start = DEPLOY_BLOCK; start <= latestBlock; start += CHUNK_SIZE + 1) {
+      const end = Math.min(start + CHUNK_SIZE, latestBlock);
+      const chunk = await contract.queryFilter(filter, start, end);
+      events.push(...(chunk as ethers.EventLog[]));
+    }
+
+    const tokens = events.map((event) => {
+      const tokenId = event.args[0].toString();
+      const to = event.args[1];
+      const tokenType = Number(event.args[2]);
+      const soulbound = event.args[3];
+      const tokenURI = event.args[4];
+
+      let name = null;
+      if (tokenURI.startsWith("data:application/json;base64,")) {
+        try {
+          const meta = JSON.parse(
+            Buffer.from(tokenURI.replace("data:application/json;base64,", ""), "base64").toString()
+          );
+          name = meta.name || null;
+        } catch {}
+      }
+
+      return {
+        tokenId: Number(tokenId),
+        recipient: to,
+        tokenType: TOKEN_TYPES[tokenType] || `Unknown(${tokenType})`,
+        soulbound,
+        name,
+        block: event.blockNumber,
+        txHash: event.transactionHash,
+      };
+    });
+
+    res.status(200).json({
+      totalMinted: tokens.length,
+      contract: CONTRACT,
+      chain: "Base",
+      chainId: 8453,
+      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

@@ -0,0 +1,108 @@
+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";
+const CONTRACT = process.env.MINT_FACTORY_ADDRESS || "0x12a1c11a0b2860f64e7d8df20989f97d40de7f2c";
+
+// Rate limiting: per-address and global
+const addrLimits = new Map<string, { count: number; resetAt: number }>();
+const globalState = { count: 0, resetAt: 0 };
+const ADDR_LIMIT = 10;       // 10 mints per address per hour
+const GLOBAL_HOUR_LIMIT = 50; // 50 mints per hour
+const GLOBAL_DAY_LIMIT = 500; // 500 mints per day
+const HOUR_MS = 60 * 60 * 1000;
+
+const dailyState = { count: 0, resetAt: 0 };
+
+function checkRateLimit(recipient: string): string | null {
+  const now = Date.now();
+
+  // Per-address hourly limit
+  const addr = addrLimits.get(recipient);
+  if (!addr || now > addr.resetAt) {
+    addrLimits.set(recipient, { count: 1, resetAt: now + HOUR_MS });
+  } else if (addr.count >= ADDR_LIMIT) {
+    return `Address rate limited (${ADDR_LIMIT}/hour). Try again later.`;
+  } else {
+    addr.count++;
+  }
+
+  // Global hourly limit
+  if (now > globalState.resetAt) {
+    globalState.count = 1;
+    globalState.resetAt = now + HOUR_MS;
+  } else if (globalState.count >= GLOBAL_HOUR_LIMIT) {
+    return `Global hourly limit reached (${GLOBAL_HOUR_LIMIT}/hour). Try again later.`;
+  } else {
+    globalState.count++;
+  }
+
+  // Global daily limit
+  if (now > dailyState.resetAt) {
+    dailyState.count = 1;
+    dailyState.resetAt = now + 24 * HOUR_MS;
+  } else if (dailyState.count >= GLOBAL_DAY_LIMIT) {
+    return `Global daily limit reached (${GLOBAL_DAY_LIMIT}/day). Try again tomorrow.`;
+  } else {
+    dailyState.count++;
+  }
+
+  return null;
+}
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  if (req.method !== "POST") {
+    return res.status(405).json({ error: "POST only" });
+  }
+
+  if (!PRIVATE_KEY) {
+    return res.status(503).json({ error: "Sponsored minting not configured" });
+  }
+
+  const { to, calldata, value, estimatedGas, recipient } = req.body || {};
+
+  if (!to || !calldata || !recipient) {
+    return res.status(400).json({ error: "Missing required fields: to, calldata, recipient" });
+  }
+
+  if (!ethers.isAddress(to) || !ethers.isAddress(recipient)) {
+    return res.status(400).json({ error: "Invalid address" });
+  }
+
+  // Verify the target is our contract
+  if (to.toLowerCase() !== CONTRACT.toLowerCase()) {
+    return res.status(400).json({ error: "Invalid contract target" });
+  }
+
+  const rateLimitError = checkRateLimit(recipient.toLowerCase());
+  if (rateLimitError) {
+    return res.status(429).json({ error: rateLimitError });
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(RPC_URL);
+    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+
+    const tx = await wallet.sendTransaction({
+      to,
+      data: calldata,
+      value: BigInt(value || "0"),
+      gasLimit: estimatedGas || 600000,
+    });
+
+    const receipt = await tx.wait();
+
+    return res.status(200).json({
+      txHash: receipt!.hash,
+      blockNumber: receipt!.blockNumber,
+      gasUsed: receipt!.gasUsed.toString(),
+      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

@@ -0,0 +1,95 @@
+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";
+const DEPLOY_BLOCK = 43461700;
+const CHUNK_SIZE = 9999;
+
+const TOKEN_TYPES = ["Identity", "Attestation", "Credential", "Receipt", "Pass"];
+
+const ABI = [
+  "event Minted(uint256 indexed tokenId, address indexed to, uint8 tokenType, bool soulbound, string tokenURI)",
+  "function tokenData(uint256 tokenId) view returns (uint8 tokenType, bool soulbound, uint256 mintedAt)",
+  "function ownerOf(uint256 tokenId) view returns (address)",
+];
+
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Cache-Control", "s-maxage=15, stale-while-revalidate=30");
+
+  const address = (req.query.address as string) || "";
+
+  if (!address || !ethers.isAddress(address)) {
+    res.status(400).json({ error: "Valid Ethereum address required. Usage: /api/verify?address=0x..." });
+    return;
+  }
+
+  try {
+    const provider = new ethers.JsonRpcProvider(RPC_URL);
+    const contract = new ethers.Contract(CONTRACT, ABI, provider);
+    const latestBlock = await provider.getBlockNumber();
+
+    const filter = contract.filters.Minted(null, address);
+    const events: ethers.EventLog[] = [];
+    for (let start = DEPLOY_BLOCK; start <= latestBlock; start += CHUNK_SIZE + 1) {
+      const end = Math.min(start + CHUNK_SIZE, latestBlock);
+      const chunk = await contract.queryFilter(filter, start, end);
+      events.push(...(chunk as ethers.EventLog[]));
+    }
+
+    const tokens = await Promise.all(
+      events.map(async (event) => {
+        const tokenId = event.args[0].toString();
+        const tokenType = Number(event.args[2]);
+        const soulbound = event.args[3];
+        const tokenURI = event.args[4];
+
+        let name = null;
+        let metadata: Record<string, unknown> = {};
+        if (tokenURI.startsWith("data:application/json;base64,")) {
+          try {
+            metadata = JSON.parse(
+              Buffer.from(tokenURI.replace("data:application/json;base64,", ""), "base64").toString()
+            );
+            name = (metadata.name as string) || null;
+          } catch {}
+        }
+
+        let currentOwner: string | null = null;
+        try {
+          currentOwner = await contract.ownerOf(tokenId);
+        } catch {}
+
+        return {
+          tokenId: Number(tokenId),
+          tokenType: TOKEN_TYPES[tokenType] || `Unknown(${tokenType})`,
+          soulbound,
+          name,
+          currentOwner,
+          did: metadata.did || null,
+          capabilities: metadata.capabilities || null,
+          txHash: event.transactionHash,
+        };
+      })
+    );
+
+    const hasIdentity = tokens.some((t) => t.tokenType === "Identity");
+    const credentials = tokens.filter((t) => t.tokenType === "Credential");
+    const attestations = tokens.filter((t) => t.tokenType === "Attestation");
+
+    res.status(200).json({
+      address,
+      verified: tokens.length > 0,
+      hasIdentity,
+      credentialCount: credentials.length,
+      attestationCount: attestations.length,
+      totalTokens: tokens.length,
+      tokens,
+    });
+  } catch (err: any) {
+    captureError(err, { route: "verify", address });
+    res.status(500).json({ error: err.message || "Failed to verify" });
+  }
+}

package/contracts/.env.example

@@ -0,0 +1,4 @@
+BASE_SEPOLIA_RPC_URL=
+BASE_RPC_URL=
+BASESCAN_API_KEY=
+DEPLOYER_PRIVATE_KEY=

package/contracts/.github/workflows/test.yml

@@ -0,0 +1,38 @@
+name: CI
+
+permissions: {}
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+env:
+  FOUNDRY_PROFILE: ci
+
+jobs:
+  check:
+    name: Foundry project
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Show Forge version
+        run: forge --version
+
+      - name: Run Forge fmt
+        run: forge fmt --check
+
+      - name: Run Forge build
+        run: forge build --sizes
+
+      - name: Run Forge tests
+        run: forge test -vvv

package/contracts/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts

package/contracts/README.md

@@ -0,0 +1,66 @@
+## Foundry
+
+**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+
+Foundry consists of:
+
+- **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
+- **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
+- **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
+- **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```
+
+### Cast
+
+```shell
+$ cast <subcommand>
+```
+
+### Help
+
+```shell
+$ forge --help
+$ anvil --help
+$ cast --help
+```