@mint.club/v2-eliza-plugin 2.0.0

package/README.md

@@ -0,0 +1,88 @@
+# Mint Club V2 — ElizaOS Plugin
+
+ElizaOS actions for protocol-native [Mint Club V2](https://mint.club) operations and bounded local Uniswap ZapV2 routing across ten mainnets and two testnets.
+
+[npm package](https://www.npmjs.com/package/@mint.club/v2-eliza-plugin) · [repository](https://github.com/Steemhunt/mint.club-v2-ai) · [CLI reference](../cli) · [MCP server](../mcp)
+
+The plugin invokes [`@mint.club/v2-cli`](../cli) with argv arrays and does not interpolate user input into shell commands. Chain keys and aliases come from the CLI package's published `chain-registry.json`.
+
+## Actions
+
+The plugin exposes nine protocol-specific actions:
+
+| Action | Description |
+|---|---|
+| `TOKEN_INFO` | Token supply, reserve, price, and curve |
+| `TOKEN_PRICE` | Token price in reserve and USD |
+| `BUY_TOKEN` | Mint with the configured reserve ERC-20 via `MCV2_Bond` |
+| `SELL_TOKEN` | Burn for the configured reserve ERC-20 via `MCV2_Bond` |
+| `ZAP_BUY` | Exact routed input asset → `MCV2_ZapV2.zapMint` |
+| `ZAP_SELL` | `MCV2_ZapV2.zapBurn` → routed output asset |
+| `WALLET_BALANCE` | Show chain-local wallet balances |
+| `SEND_TOKEN` | Send native currency or an ERC-20 token |
+| `CREATE_TOKEN` | Create an ERC-20 bonding curve token |
+
+There is no general-purpose DEX swap action. Zap routing checks only direct and one-intermediary homogeneous V2/V3/V4 paths by RPC.
+
+## Setup
+
+```bash
+npm install @mint.club/v2-eliza-plugin
+```
+
+Requires Node.js 18 or later and an ElizaOS project compatible with `@elizaos/core ^1.7.2`. The plugin installs a compatible `@mint.club/v2-cli` 2.x runtime dependency automatically.
+
+Add the plugin to an ElizaOS character configuration:
+
+```json
+{
+  "plugins": ["@mint.club/v2-eliza-plugin"]
+}
+```
+
+See the official [ElizaOS plugin management guide](https://docs.elizaos.ai/cli-reference/plugins) for project and character configuration details.
+
+Read-only actions work without a wallet. Write actions and wallet balances require `PRIVATE_KEY` through the ElizaOS secret/environment configuration, or a key in `~/.mintclub/.env`. To generate a dedicated local wallet, install the CLI and run `mc wallet --generate` in a trusted terminal.
+
+> Never store a key in a character file, commit it, or paste it into an agent conversation. Use a dedicated wallet with limited funds.
+
+## Example prompts
+
+- “Get info about SIGNET.”
+- “What is the price of TOKEN on Robinhood?”
+- “Buy 25 SIGNET.”
+- “Sell 5 SIGNET.”
+- “Buy TOKEN with 10 USDT on Arbitrum with 0.5% slippage.”
+- “Sell 5 TOKEN for USDC on Unichain.”
+- “Show my wallet balance on Polygon.”
+- “Send 10 USDG to `0x1111111111111111111111111111111111111111` on Robinhood.”
+- “Create token \"My Token\" (MYT) backed by USDG with max supply 1000000 using a linear curve from 0.01 to 1 on Robinhood.”
+
+The Zap parser deliberately rejects the ambiguous target-amount form “Buy 10 TOKEN with ETH.” Use “Buy TOKEN with 0.1 ETH” so the exact routed input amount is explicit. Zap slippage defaults to 1% when omitted.
+
+The target Mint Club token may be ERC-20 or ERC-1155; ERC-1155 amounts must be whole numbers. Routed input/output and `SEND_TOKEN` assets must be native currency or ERC-20 tokens.
+
+The text parser fails closed on explicit max/min or royalty constraints it cannot map without ambiguity. `CREATE_TOKEN` creates ERC-20 tokens with the CLI defaults of 100 basis points (1%) for both mint and burn royalties. Use the CLI when different royalties are required; use the CLI or MCP server for explicit trade limits.
+
+Supported canonical chain keys:
+
+`ethereum` · `optimism` · `arbitrum` · `avalanche` · `base` · `polygon` · `bsc` · `zora` · `unichain` · `robinhood` · `sepolia` · `base-sepolia`
+
+Natural-language aliases such as “Ethereum mainnet,” “Ethereum Sepolia,” “Base Sepolia,” “Arbitrum One,” “BNB Chain,” and “Robinhood Chain” are loaded from the central registry. Base is the default. Contradictory or multiple positive chain instructions are rejected rather than guessed.
+
+ZapV2 is deployed on every supported chain listed above. Blast is unsupported by this integration.
+
+## Development
+
+From the repository root:
+
+```bash
+npm ci
+npm --prefix eliza-plugin run check
+npm --prefix eliza-plugin test
+npm --prefix eliza-plugin run build
+```
+
+## License
+
+MIT

package/dist/commands.d.ts

@@ -0,0 +1,3 @@
+export type MintClubActionName = 'TOKEN_INFO' | 'TOKEN_PRICE' | 'BUY_TOKEN' | 'SELL_TOKEN' | 'ZAP_BUY' | 'ZAP_SELL' | 'WALLET_BALANCE' | 'SEND_TOKEN' | 'CREATE_TOKEN';
+export declare const SUPPORTED_CHAINS: readonly string[];
+export declare function buildActionArgs(action: MintClubActionName, text: string): string[];

package/dist/commands.js

@@ -0,0 +1,273 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const chainRegistry = require('@mint.club/v2-cli/chain-registry.json');
+export const SUPPORTED_CHAINS = Object.freeze(chainRegistry.chains.map(({ key }) => key));
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function normalizeChainAlias(value) {
+    return value.toLowerCase().replace(/[\s_-]+/g, '');
+}
+function aliasPattern(alias) {
+    return alias
+        .split(/[\s_-]+/)
+        .map(escapeRegExp)
+        .join('[\\s_-]*');
+}
+const chainByAlias = new Map();
+const nativeSymbolByChain = new Map();
+const nativeSymbols = new Set();
+const legacyNativeChainBySymbol = new Map([
+    ['MATIC', 'polygon'],
+]);
+const aliases = [];
+for (const { key, nativeSymbol, aliases: configuredAliases, } of chainRegistry.chains) {
+    const normalizedNativeSymbol = nativeSymbol.toUpperCase();
+    nativeSymbolByChain.set(key, normalizedNativeSymbol);
+    nativeSymbols.add(normalizedNativeSymbol);
+    for (const alias of new Set([key, ...configuredAliases])) {
+        const normalized = normalizeChainAlias(alias);
+        const existing = chainByAlias.get(normalized);
+        if (existing && existing !== key) {
+            throw new Error(`Duplicate chain alias "${alias}" for ${existing} and ${key}`);
+        }
+        chainByAlias.set(normalized, key);
+        aliases.push(alias);
+    }
+}
+for (const symbol of legacyNativeChainBySymbol.keys()) {
+    nativeSymbols.add(symbol);
+}
+const CHAIN_ALIAS_PATTERN = [...new Set(aliases)]
+    .sort((left, right) => right.length - left.length)
+    .map(aliasPattern)
+    .join('|');
+function resolveChainAlias(alias) {
+    const chain = chainByAlias.get(normalizeChainAlias(alias));
+    if (!chain)
+        throw new Error(`Unknown chain alias: ${alias}`);
+    return chain;
+}
+function chainArgs(text) {
+    const negated = new Set();
+    const negation = new RegExp(`\\b(?:not|without|except)\\s+(?:on\\s+)?(?:the\\s+)?(${CHAIN_ALIAS_PATTERN})(?:\\s+chain)?\\b`, 'gi');
+    const positiveText = text.replace(negation, (_match, alias) => {
+        negated.add(resolveChainAlias(alias));
+        return ' ';
+    });
+    const mentioned = new Set();
+    const positive = new RegExp(`(?:\\bon\\s+(?:the\\s+)?(${CHAIN_ALIAS_PATTERN})(?:\\s+chain)?\\b|\\b(${CHAIN_ALIAS_PATTERN})\\s+(?:chain|mainnet|wallet|balance|holdings)\\b)`, 'gi');
+    for (const match of positiveText.matchAll(positive)) {
+        mentioned.add(resolveChainAlias(match[1] ?? match[2]));
+    }
+    const hasConflict = [...mentioned].some((chain) => negated.has(chain));
+    if (mentioned.size > 1 ||
+        hasConflict ||
+        (mentioned.size === 0 && negated.has('base'))) {
+        throw new Error(`Specify exactly one chain: ${SUPPORTED_CHAINS.join(', ')}`);
+    }
+    const selected = mentioned.values().next().value ?? 'base';
+    return ['--chain', selected];
+}
+const TOKEN_PATTERN = '(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)';
+const ASSET_PATTERN = '(native(?:\\s+currency)?|0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)';
+const AMOUNT_PATTERN = '([0-9]+(?:\\.[0-9]+)?)';
+function normalizeAsset(value) {
+    return /^native(?:\s+currency)?$/i.test(value) ? 'NATIVE' : value;
+}
+function rejectUnsupportedIntent(text, pattern, description) {
+    if (pattern.test(text)) {
+        throw new Error(`${description} is not supported by this text parser`);
+    }
+}
+function tradeParts(text, action) {
+    rejectUnsupportedIntent(text, action === 'buy'
+        ? /\bmax(?:imum)?\s+cost\b/i
+        : /\bmin(?:imum)?\s+refund\b/i, action === 'buy' ? 'Maximum cost' : 'Minimum refund');
+    const verbs = action === 'buy' ? '(?:buy|mint)' : '(?:sell|burn)';
+    const match = text.match(new RegExp(`\\b${verbs}\\s+${AMOUNT_PATTERN}\\s+(?:of\\s+)?${TOKEN_PATTERN}\\b`, 'i'));
+    if (!match) {
+        throw new Error('Specify an amount and token, for example: "buy 10 SIGNET"');
+    }
+    const trailingText = text.slice((match.index ?? 0) + match[0].length);
+    const routedIntent = action === 'buy'
+        ? /\b(?:with|using|from)\b/i
+        : /\b(?:for|to|into)\b/i;
+    if (routedIntent.test(trailingText)) {
+        throw new Error(action === 'buy'
+            ? 'Use the exact-input form: Buy TOKEN with AMOUNT INPUT_TOKEN'
+            : 'Use the routed-output form: Sell AMOUNT TOKEN for OUTPUT_TOKEN');
+    }
+    return { amount: match[1], token: match[2] };
+}
+function zapBuyParts(text) {
+    rejectUnsupportedIntent(text, /\bmin(?:imum)?\s+tokens?\b/i, 'Minimum token output');
+    const match = text.match(new RegExp(`\\b(?:zap\\s+)?(?:buy|mint)\\s+(?:token\\s+)?${TOKEN_PATTERN}\\s+(?:with|using|from)\\s+${AMOUNT_PATTERN}\\s+(?:of\\s+)?${ASSET_PATTERN}\\b`, 'i'));
+    if (!match) {
+        throw new Error('Use: Buy TOKEN with AMOUNT INPUT_TOKEN, for example: "Buy SIGNET with 10 USDC"');
+    }
+    return {
+        token: match[1],
+        inputAmount: match[2],
+        inputToken: normalizeAsset(match[3]),
+    };
+}
+function zapSellParts(text) {
+    rejectUnsupportedIntent(text, /\bmin(?:imum)?\s+output\b/i, 'Minimum routed output');
+    const match = text.match(new RegExp(`\\b(?:zap\\s+)?(?:sell|burn)\\s+${AMOUNT_PATTERN}\\s+(?:of\\s+)?${TOKEN_PATTERN}\\s+(?:for|to|into)\\s+${ASSET_PATTERN}\\b`, 'i'));
+    if (!match) {
+        throw new Error('Use: Sell AMOUNT TOKEN for OUTPUT_TOKEN, for example: "Sell 5 SIGNET for USDC"');
+    }
+    return {
+        amount: match[1],
+        token: match[2],
+        outputToken: normalizeAsset(match[3]),
+    };
+}
+function slippageArgs(text) {
+    const match = text.match(/\b(?:with|at)?\s*([0-9]+(?:\.[0-9]+)?)\s*%\s+slippage\b/i);
+    return match ? ['--slippage', match[1]] : [];
+}
+function tokenFromText(text, action) {
+    const patterns = action === 'info'
+        ? [
+            /\b(?:info|details)\s+(?:about|for|of)?\s*(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\b/i,
+            /\babout\s+(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\b/i,
+        ]
+        : [
+            /\bprice\s+(?:of|for)?\s*(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\b/i,
+            /\bworth\s+(?:of\s+)?(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\b/i,
+            /\bwhat\s+is\s+(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\s+worth\b/i,
+            /\b(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\s+(?:price|worth)\b/i,
+        ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match)
+            return match[1];
+    }
+    throw new Error(`Specify a token for ${action}`);
+}
+function sendParts(text, chain) {
+    const match = text.match(new RegExp(`\\b(?:send|transfer)\\s+${AMOUNT_PATTERN}\\s+(?:${ASSET_PATTERN}\\s+)?to\\s+(0x[a-fA-F0-9]{40})\\b`, 'i'));
+    if (!match) {
+        throw new Error('Specify amount, optional token, and recipient, for example: "send 10 USDC to 0x..."');
+    }
+    const token = match[2];
+    const normalizedToken = token
+        ? normalizeAsset(token).toUpperCase()
+        : undefined;
+    const nativeSymbol = nativeSymbolByChain.get(chain);
+    if (!nativeSymbol)
+        throw new Error(`Missing native symbol for ${chain}`);
+    const isSelectedNativeSymbol = normalizedToken === nativeSymbol ||
+        legacyNativeChainBySymbol.get(normalizedToken ?? '') === chain;
+    if (normalizedToken &&
+        normalizedToken !== 'NATIVE' &&
+        nativeSymbols.has(normalizedToken) &&
+        !isSelectedNativeSymbol) {
+        throw new Error(`${normalizedToken} is not the native currency on ${chain}; use ${nativeSymbol} or NATIVE`);
+    }
+    return {
+        amount: match[1],
+        token: normalizedToken === undefined ||
+            normalizedToken === 'NATIVE' ||
+            isSelectedNativeSymbol
+            ? undefined
+            : token,
+        recipient: match[3],
+    };
+}
+function createParts(text) {
+    rejectUnsupportedIntent(text, /\b(?:(?:mint|burn)\s+)?royalt(?:y|ies)\b/i, 'Explicit royalty configuration');
+    const match = text.match(/\b(?:create|launch)\s+(?:a\s+)?token\s+"([^"]{1,64})"\s+\(([a-zA-Z][a-zA-Z0-9_-]*)\)\s+backed\s+by\s+(0x[a-fA-F0-9]{40}|[a-zA-Z][a-zA-Z0-9_-]*)\s+with\s+max(?:imum)?\s+supply\s+([0-9]+(?:\.[0-9]+)?)\s+using\s+(?:a\s+)?(linear|exponential|logarithmic|flat)\s+curve\s+from\s+([0-9]+(?:\.[0-9]+)?)\s+to\s+([0-9]+(?:\.[0-9]+)?)\b/i);
+    if (!match) {
+        throw new Error('Use: create token "Name" (SYMBOL) backed by RESERVE with max supply N using a CURVE curve from START to END');
+    }
+    return {
+        name: match[1],
+        symbol: match[2],
+        reserve: match[3],
+        maxSupply: match[4],
+        curve: match[5].toLowerCase(),
+        initialPrice: match[6],
+        finalPrice: match[7],
+    };
+}
+export function buildActionArgs(action, text) {
+    const prefix = chainArgs(text);
+    switch (action) {
+        case 'TOKEN_INFO':
+            return [...prefix, 'info', tokenFromText(text, 'info')];
+        case 'TOKEN_PRICE':
+            return [...prefix, 'price', tokenFromText(text, 'price')];
+        case 'WALLET_BALANCE':
+            return [...prefix, 'wallet'];
+        case 'BUY_TOKEN': {
+            const { token, amount } = tradeParts(text, 'buy');
+            return [...prefix, 'buy', token, '--amount', amount];
+        }
+        case 'SELL_TOKEN': {
+            const { token, amount } = tradeParts(text, 'sell');
+            return [...prefix, 'sell', token, '--amount', amount];
+        }
+        case 'ZAP_BUY': {
+            const { token, inputAmount, inputToken } = zapBuyParts(text);
+            return [
+                ...prefix,
+                'zap-buy',
+                token,
+                '--input-token',
+                inputToken,
+                '--input-amount',
+                inputAmount,
+                ...slippageArgs(text),
+            ];
+        }
+        case 'ZAP_SELL': {
+            const { token, amount, outputToken } = zapSellParts(text);
+            return [
+                ...prefix,
+                'zap-sell',
+                token,
+                '--amount',
+                amount,
+                '--output-token',
+                outputToken,
+                ...slippageArgs(text),
+            ];
+        }
+        case 'SEND_TOKEN': {
+            const { amount, token, recipient } = sendParts(text, prefix[1]);
+            return [
+                ...prefix,
+                'send',
+                recipient,
+                '--amount',
+                amount,
+                ...(token ? ['--token', token] : []),
+            ];
+        }
+        case 'CREATE_TOKEN': {
+            const parts = createParts(text);
+            return [
+                ...prefix,
+                'create',
+                '--name',
+                parts.name,
+                '--symbol',
+                parts.symbol,
+                '--reserve',
+                parts.reserve,
+                '--max-supply',
+                parts.maxSupply,
+                '--curve',
+                parts.curve,
+                '--initial-price',
+                parts.initialPrice,
+                '--final-price',
+                parts.finalPrice,
+                '--yes',
+            ];
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { mintclubPlugin } from './plugin.js';
+export { mintclubPlugin } from './plugin.js';
+export default mintclubPlugin;

package/dist/index.js

@@ -0,0 +1,3 @@
+import { mintclubPlugin } from './plugin.js';
+export { mintclubPlugin } from './plugin.js';
+export default mintclubPlugin;

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from '@elizaos/core';
+export declare function resolveCliInvocation(argv: string[]): {
+    command: string;
+    args: string[];
+};
+export declare const mintclubPlugin: Plugin;
+export default mintclubPlugin;

package/dist/plugin.js

@@ -0,0 +1,218 @@
+import { logger } from '@elizaos/core';
+import { z } from 'zod';
+import { execFileSync } from 'child_process';
+import { createRequire } from 'module';
+import { SUPPORTED_CHAINS, buildActionArgs, } from './commands.js';
+const configSchema = z.object({
+    PRIVATE_KEY: z.string().min(1).optional(),
+});
+const require = createRequire(import.meta.url);
+export function resolveCliInvocation(argv) {
+    const override = process.env.MINTCLUB_CLI;
+    if (override)
+        return { command: override, args: argv };
+    try {
+        const cliEntrypoint = require.resolve('@mint.club/v2-cli');
+        return { command: process.execPath, args: [cliEntrypoint, ...argv] };
+    }
+    catch {
+        throw new Error('@mint.club/v2-cli 2.x is not installed; reinstall @mint.club/v2-eliza-plugin with production dependencies');
+    }
+}
+function runMcCommand(argv) {
+    try {
+        const invocation = resolveCliInvocation(argv);
+        return execFileSync(invocation.command, invocation.args, {
+            encoding: 'utf8',
+            timeout: 300_000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch (error) {
+        const failure = error;
+        const stderr = failure.stderr?.toString().trim();
+        throw new Error(`mc command failed: ${stderr || failure.message || 'unknown error'}`);
+    }
+}
+function createAction(spec) {
+    return {
+        name: spec.name,
+        similes: spec.similes,
+        description: spec.description,
+        validate: async (_runtime, message, _state) => spec.validateText(message.content.text || ''),
+        handler: async (_runtime, message, _state, _options, callback) => {
+            try {
+                const result = runMcCommand(buildActionArgs(spec.name, message.content.text || ''));
+                if (callback) {
+                    await callback({
+                        text: result,
+                        actions: [spec.name],
+                        source: message.content.source,
+                    });
+                }
+                return { text: result, success: true };
+            }
+            catch (error) {
+                logger.error({ error }, `Error in ${spec.name} action`);
+                return {
+                    success: false,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                };
+            }
+        },
+        examples: [
+            [
+                {
+                    name: '{{userName}}',
+                    content: { text: spec.examplePrompt, actions: [] },
+                },
+                {
+                    name: '{{agentName}}',
+                    content: { text: spec.exampleResult, actions: [spec.name] },
+                },
+            ],
+        ],
+    };
+}
+function canBuildActionArgs(name, text) {
+    try {
+        buildActionArgs(name, text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const tokenInfoAction = createAction({
+    name: 'TOKEN_INFO',
+    similes: ['GET_TOKEN_INFO', 'MINT_CLUB_INFO', 'MC_INFO'],
+    description: 'Get information about a Mint Club V2 token',
+    validateText: (text) => /\b(info|details|about)\b/i.test(text),
+    examplePrompt: 'Get info about SIGNET',
+    exampleResult: 'Here is the token information for SIGNET.',
+});
+const tokenPriceAction = createAction({
+    name: 'TOKEN_PRICE',
+    similes: ['GET_TOKEN_PRICE', 'MINT_CLUB_PRICE', 'MC_PRICE'],
+    description: 'Get a Mint Club V2 token price in reserve and USD',
+    validateText: (text) => canBuildActionArgs('TOKEN_PRICE', text),
+    examplePrompt: 'What is the price of SIGNET?',
+    exampleResult: 'Here is the current SIGNET price.',
+});
+const buyTokenAction = createAction({
+    name: 'BUY_TOKEN',
+    similes: ['MINT_TOKEN', 'BOND_BUY'],
+    description: 'Mint a token with its Bond reserve ERC-20',
+    validateText: (text) => canBuildActionArgs('BUY_TOKEN', text) &&
+        !canBuildActionArgs('ZAP_BUY', text),
+    examplePrompt: 'Buy 10 SIGNET',
+    exampleResult: 'Minted 10 SIGNET through MCV2_Bond.',
+});
+const sellTokenAction = createAction({
+    name: 'SELL_TOKEN',
+    similes: ['BURN_TOKEN', 'BOND_SELL'],
+    description: 'Burn a token for its Bond reserve ERC-20',
+    validateText: (text) => canBuildActionArgs('SELL_TOKEN', text) &&
+        !canBuildActionArgs('ZAP_SELL', text),
+    examplePrompt: 'Sell 5 SIGNET',
+    exampleResult: 'Burned 5 SIGNET through MCV2_Bond.',
+});
+const zapBuyAction = createAction({
+    name: 'ZAP_BUY',
+    similes: ['BUY_WITH_ASSET', 'MINT_WITH_ASSET', 'ROUTED_MINT'],
+    description: 'Mint a Mint Club token from an exact amount of a routed native/ERC-20 asset via MCV2_ZapV2',
+    validateText: (text) => canBuildActionArgs('ZAP_BUY', text),
+    examplePrompt: 'Buy TOKEN with 10 USDC on Arbitrum',
+    exampleResult: 'Minted TOKEN from 10 USDC through MCV2_ZapV2.',
+});
+const zapSellAction = createAction({
+    name: 'ZAP_SELL',
+    similes: ['SELL_FOR_ASSET', 'BURN_TO_ASSET', 'ROUTED_BURN'],
+    description: 'Burn a Mint Club token into a routed native/ERC-20 output asset via MCV2_ZapV2',
+    validateText: (text) => canBuildActionArgs('ZAP_SELL', text),
+    examplePrompt: 'Sell 5 TOKEN for USDC on Unichain',
+    exampleResult: 'Burned 5 TOKEN into USDC through MCV2_ZapV2.',
+});
+const walletBalanceAction = createAction({
+    name: 'WALLET_BALANCE',
+    similes: ['CHECK_BALANCE', 'MY_WALLET', 'MC_WALLET'],
+    description: 'Show chain-local balances for the configured wallet',
+    validateText: (text) => /\b(wallet|balance|holdings)\b/i.test(text),
+    examplePrompt: 'Show my wallet balance on Robinhood',
+    exampleResult: 'Here are your Robinhood Chain balances.',
+});
+const sendTokenAction = createAction({
+    name: 'SEND_TOKEN',
+    similes: ['TRANSFER_TOKEN', 'SEND_ASSET'],
+    description: 'Send native currency or an ERC-20 token to an address',
+    validateText: (text) => canBuildActionArgs('SEND_TOKEN', text),
+    examplePrompt: 'Send 10 USDG to 0x1111111111111111111111111111111111111111 on Robinhood',
+    exampleResult: 'Sent 10 USDG on Robinhood Chain.',
+});
+const createTokenAction = createAction({
+    name: 'CREATE_TOKEN',
+    similes: ['LAUNCH_TOKEN', 'CREATE_BONDING_CURVE'],
+    description: 'Create an ERC-20 Mint Club V2 bonding curve token',
+    validateText: (text) => canBuildActionArgs('CREATE_TOKEN', text),
+    examplePrompt: 'Create token "My Token" (MYT) backed by USDG with max supply 1000000 using a linear curve from 0.01 to 1 on Robinhood',
+    exampleResult: 'Created the MYT bonding curve token on Robinhood Chain.',
+});
+const mintclubProvider = {
+    name: 'MINTCLUB_PROVIDER',
+    description: 'Provides context about Mint Club V2 protocol operations across supported Uniswap chains',
+    get: async (_runtime, _message, _state) => ({
+        text: [
+            'Mint Club V2 bonding curve actions:',
+            '- TOKEN_INFO / TOKEN_PRICE: read token data',
+            '- BUY_TOKEN / SELL_TOKEN: MCV2_Bond mint and burn of ERC-20/1155 targets with reserve ERC-20',
+            '- ZAP_BUY / ZAP_SELL: MCV2_ZapV2 exact-input local Uniswap routing for native/ERC-20 assets',
+            '- WALLET_BALANCE: show chain-local wallet balances',
+            '- SEND_TOKEN: send native currency or ERC-20 tokens',
+            '- CREATE_TOKEN: create an ERC-20 bonding curve token',
+            '',
+            `Supported chains: ${SUPPORTED_CHAINS.join(', ')}. Base is the default.`,
+            'Zap routing enumerates direct and one-intermediary V2/V3/V4 candidates and uses the configured per-chain ZapV2 deployment.',
+            'The compatible mc CLI is installed as a plugin dependency; write actions require PRIVATE_KEY or the CLI wallet file.',
+        ].join('\n'),
+        values: {
+            platform: 'Mint Club V2',
+            cli: '@mint.club/v2-cli',
+            chains: SUPPORTED_CHAINS.join(','),
+        },
+        data: {},
+    }),
+};
+export const mintclubPlugin = {
+    name: 'plugin-mintclub',
+    description: 'Mint Club V2 plugin for bonding curves and bounded local Uniswap ZapV2 routing across supported chains',
+    config: { PRIVATE_KEY: process.env.PRIVATE_KEY },
+    async init(config) {
+        logger.info('Initializing Mint Club V2 plugin');
+        try {
+            const validatedConfig = await configSchema.parseAsync(config);
+            if (validatedConfig.PRIVATE_KEY) {
+                process.env.PRIVATE_KEY = validatedConfig.PRIVATE_KEY;
+            }
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                const messages = error.issues.map((issue) => issue.message).join(', ');
+                throw new Error(`Invalid plugin configuration: ${messages}`);
+            }
+            throw error;
+        }
+    },
+    actions: [
+        tokenInfoAction,
+        tokenPriceAction,
+        buyTokenAction,
+        sellTokenAction,
+        zapBuyAction,
+        zapSellAction,
+        walletBalanceAction,
+        sendTokenAction,
+        createTokenAction,
+    ],
+    providers: [mintclubProvider],
+};
+export default mintclubPlugin;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@mint.club/v2-eliza-plugin",
+  "version": "2.0.0",
+  "description": "ElizaOS plugin for Mint Club V2 Bond operations and bounded local Uniswap ZapV2 routing across supported chains",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "check": "tsc --noEmit",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@mint.club/v2-cli": "^2.0.0",
+    "zod": "^4.3.5"
+  },
+  "peerDependencies": {
+    "@elizaos/core": "^1.7.2"
+  },
+  "keywords": [
+    "elizaos",
+    "mint-club",
+    "bonding-curve",
+    "uniswap",
+    "zap-v2",
+    "multi-chain",
+    "defi",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Steemhunt/mint.club-v2-ai.git",
+    "directory": "eliza-plugin"
+  },
+  "homepage": "https://github.com/Steemhunt/mint.club-v2-ai/tree/main/eliza-plugin",
+  "bugs": {
+    "url": "https://github.com/Steemhunt/mint.club-v2-ai/issues"
+  },
+  "devDependencies": {
+    "@elizaos/core": "^1.7.2",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.9"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}