@morebetterclaw/forge-swap 0.1.1

package/src/parser.js

@@ -0,0 +1,90 @@
+/**
+ * Natural language parser for swap commands
+ * Converts e.g. "swap quote 0.1 BTC to ETH" into structured params
+ */
+
+// Asset normalisation map — common names → SwapKit format
+const ASSET_MAP = {
+  'BTC': 'BTC.BTC',
+  'ETH': 'ETH.ETH',
+  'RUNE': 'THOR.RUNE',
+  'USDC': 'ETH.USDC-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+  'USDT': 'ETH.USDT-0xdAC17F958D2ee523a2206206994597C13D831ec7',
+  'SOL': 'SOL.SOL',
+  'AVAX': 'AVAX.AVAX',
+  'BNB': 'BSC.BNB',
+  'DOT': 'DOT.DOT',
+  'ATOM': 'GAIA.ATOM',
+  'DOGE': 'DOGE.DOGE',
+  'LTC': 'LTC.LTC',
+  'BCH': 'BCH.BCH',
+};
+
+function normaliseAsset(raw) {
+  const upper = raw.toUpperCase();
+  return ASSET_MAP[upper] || upper;
+}
+
+/**
+ * Parse a swap command string into a structured action object
+ * Supported patterns:
+ *   swap quote <amount> <from> to <to>
+ *   swap execute <amount> <from> to <to> address <addr>
+ *   swap status <txhash>
+ *   swap assets
+ */
+export function parseSwapCommand(command) {
+  const lower = command.toLowerCase().trim();
+
+  // Remove leading "swap " if present
+  const clean = lower.startsWith('swap ') ? command.slice(5).trim() : command.trim();
+  const parts = clean.split(/\s+/);
+
+  const action = parts[0]?.toLowerCase();
+
+  switch (action) {
+    case 'quote': {
+      // quote <amount> <from> to <to>
+      const amount = parseFloat(parts[1]);
+      const fromRaw = parts[2];
+      // find "to" keyword
+      const toIdx = parts.findIndex((p, i) => i > 2 && p.toLowerCase() === 'to');
+      const toRaw = toIdx > 0 ? parts[toIdx + 1] : parts[4];
+      return {
+        action: 'quote',
+        amount,
+        fromAsset: normaliseAsset(fromRaw),
+        toAsset: normaliseAsset(toRaw)
+      };
+    }
+
+    case 'execute': {
+      // execute <amount> <from> to <to> address <addr>
+      const amount = parseFloat(parts[1]);
+      const fromRaw = parts[2];
+      const toIdx = parts.findIndex((p, i) => i > 2 && p.toLowerCase() === 'to');
+      const toRaw = toIdx > 0 ? parts[toIdx + 1] : parts[4];
+      const addrIdx = parts.findIndex(p => p.toLowerCase() === 'address');
+      const destAddress = addrIdx > 0 ? parts[addrIdx + 1] : null;
+      return {
+        action: 'execute',
+        amount,
+        fromAsset: normaliseAsset(fromRaw),
+        toAsset: normaliseAsset(toRaw),
+        destAddress
+      };
+    }
+
+    case 'status': {
+      return { action: 'status', txHash: parts[1] };
+    }
+
+    case 'assets':
+    case 'list': {
+      return { action: 'assets' };
+    }
+
+    default:
+      return { action: 'unknown', raw: command };
+  }
+}

package/src/server.js

@@ -0,0 +1,177 @@
+/**
+ * server.js — HTTP server for Crypto Swap Agent
+ * Exposes swap agent as a REST API for agent-to-agent and web clients.
+ */
+
+import 'dotenv/config';
+import express from 'express';
+import rateLimit from 'express-rate-limit';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { SwapKitApi } from './swapkit.js';
+import { createMcpRouter } from './mcp.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+const VERSION = process.env.npm_package_version || '0.1.0';
+
+const FEE_BPS = parseInt(process.env.SWAP_FEE_BPS || '50');
+const FEE_ADDRESS = process.env.FEE_RECIPIENT_ADDRESS || '';
+
+const api = new SwapKitApi({ feeBps: FEE_BPS, feeAddress: FEE_ADDRESS });
+
+// ── Middleware ────────────────────────────────────────────────────────────────
+
+app.use(express.json());
+
+// CORS
+app.use((req, res, next) => {
+  const origins = process.env.ALLOWED_ORIGINS || '*';
+  res.header('Access-Control-Allow-Origin', origins);
+  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+  res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  if (req.method === 'OPTIONS') return res.sendStatus(200);
+  next();
+});
+
+// Rate limiting
+const limiter = rateLimit({
+  windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || '60000'),
+  max: parseInt(process.env.RATE_LIMIT_MAX || '100'),
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+app.use(limiter);
+
+// Request logging
+app.use((req, res, next) => {
+  const start = Date.now();
+  res.on('finish', () => {
+    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path} ${res.statusCode} ${Date.now() - start}ms`);
+  });
+  next();
+});
+
+// ── Routes ────────────────────────────────────────────────────────────────────
+
+// GET /health
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    version: VERSION,
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// POST /swap/quote
+app.post('/swap/quote', async (req, res, next) => {
+  try {
+    const { fromAsset, toAsset, amount } = req.body;
+    if (!fromAsset || !toAsset || !amount) {
+      return res.status(400).json({ error: 'fromAsset, toAsset, and amount are required' });
+    }
+
+    const quote = await api.getQuote(fromAsset, toAsset, parseFloat(amount));
+    const best = quote.routes?.[0];
+
+    if (!best) {
+      return res.status(422).json({ error: 'No route found for this pair' });
+    }
+
+    res.json({
+      fromAsset,
+      toAsset,
+      amount,
+      expectedOutput: best.expectedOutput,
+      expectedOutputMinusFees: best.expectedOutputMaxSlippage,
+      affiliateFee: `${FEE_BPS / 100}%`,
+      route: best.providers || ['THORChain'],
+      slippage: `${((quote.raw?.slippage_bps || 0) / 100).toFixed(2)}%`,
+      expiresAt: new Date(Date.now() + 30000).toISOString(),
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /swap/execute
+app.post('/swap/execute', async (req, res, next) => {
+  try {
+    const { fromAsset, toAsset, amount, destinationAddress } = req.body;
+    if (!fromAsset || !toAsset || !amount || !destinationAddress) {
+      return res.status(400).json({
+        error: 'fromAsset, toAsset, amount, and destinationAddress are required',
+      });
+    }
+
+    const swapData = await api.executeSwap(
+      fromAsset, toAsset, parseFloat(amount), destinationAddress
+    );
+    res.json(swapData);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /swap/status?txHash=<hash>
+app.get('/swap/status', async (req, res, next) => {
+  try {
+    const { txHash } = req.query;
+    if (!txHash) {
+      return res.status(400).json({ error: 'txHash query parameter required' });
+    }
+    const status = await api.getStatus(txHash);
+    res.json(status);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /swap/assets
+app.get('/swap/assets', async (req, res, next) => {
+  try {
+    const assets = await api.getSupportedAssets();
+    res.json(assets);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// ── MCP server ────────────────────────────────────────────────────────────────
+
+app.use('/mcp', createMcpRouter(api));
+
+app.get('/.well-known/mcp.json', (req, res) => {
+  res.json(JSON.parse(readFileSync(join(__dirname, '../public/mcp.json'), 'utf8')));
+});
+
+// ── Error handler ─────────────────────────────────────────────────────────────
+
+app.use((err, req, res, next) => {
+  console.error(`[error] ${err.message}`);
+  const status = err.status || 500;
+  res.status(status).json({ error: err.message || 'Internal server error' });
+});
+
+// ── Server start ──────────────────────────────────────────────────────────────
+
+export function startServer(port = PORT) {
+  const server = app.listen(port, () => {
+    console.log(`[server] Crypto Swap Agent running on port ${port}`);
+  });
+
+  process.on('SIGTERM', () => {
+    console.log('[server] SIGTERM received, shutting down...');
+    server.close(() => {
+      console.log('[server] Server closed');
+      process.exit(0);
+    });
+  });
+
+  return server;
+}
+
+export default app;

package/src/swapkit.js

@@ -0,0 +1,135 @@
+/**
+ * SwapKit API wrapper — MoreBetter Crypto Swap Agent
+ * Direct THORNode/Midgard integration with MoreBetter fee injection
+ */
+
+const THORNODE_BASE = 'https://thornode.ninerealms.com';
+const MIDGARD_BASE = 'https://midgard.ninerealms.com';
+
+export class SwapKitApi {
+  constructor({ feeBps, feeAddress }) {
+    this.feeBps = feeBps;
+    this.feeAddress = feeAddress;
+  }
+
+  /**
+   * Get a swap quote with MoreBetter affiliate fee injected
+   * @param {string} fromAsset - e.g. "ETH.ETH"
+   * @param {string} toAsset - e.g. "BTC.BTC"
+   * @param {number} amount - amount in human-readable units
+   * @param {string} [destAddress] - optional destination address
+   * @returns {object} quote with routes, expected output, fee breakdown
+   */
+  async getQuote(fromAsset, toAsset, amount, destAddress = '') {
+    const amountBaseUnits = Math.round(parseFloat(amount) * 1e8);
+    const params = new URLSearchParams({
+      from_asset: fromAsset,
+      to_asset: toAsset,
+      amount: amountBaseUnits.toString(),
+      affiliate: this.feeAddress || '',
+      affiliate_bps: this.feeBps.toString(),
+    });
+    if (destAddress) params.set('destination', destAddress);
+
+    const res = await fetch(
+      `${THORNODE_BASE}/thorchain/quote/swap?${params}`
+    );
+
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`THORNode quote failed: ${res.status} ${err}`);
+    }
+
+    const data = await res.json();
+
+    // Normalize to routes format for internal compatibility
+    const expectedOut = parseInt(data.expected_amount_out || '0') / 1e8;
+    const slippageBps = data.slippage_bps || 0;
+    const expectedOutMinusSlip = expectedOut * (1 - slippageBps / 10000);
+
+    return {
+      routes: [{
+        inboundAddress: data.inbound_address,
+        expectedOutput: expectedOut.toString(),
+        expectedOutputMaxSlippage: expectedOutMinusSlip.toFixed(8),
+        providers: ['THORChain'],
+        streamingSwap: false,
+        memo: data.memo,
+      }],
+      raw: data,
+    };
+  }
+
+  /**
+   * Build swap transaction memo + return unsigned tx for signing
+   * For agent use: returns the memo + tx data, not the signed tx
+   */
+  async executeSwap(fromAsset, toAsset, amount, destAddress) {
+    const quote = await this.getQuote(fromAsset, toAsset, amount, destAddress);
+    const bestRoute = quote.routes?.[0];
+
+    if (!bestRoute) {
+      throw new Error('No route found for this swap pair');
+    }
+
+    // Use memo from THORNode quote if available, otherwise build it
+    const memo = bestRoute.memo || this._buildMemo(toAsset, destAddress, bestRoute.streamingSwap);
+
+    return {
+      status: 'pending_signature',
+      memo,
+      depositAsset: fromAsset,
+      depositAmount: amount,
+      depositAddress: bestRoute.inboundAddress,
+      expectedOutput: bestRoute.expectedOutputMaxSlippage,
+      route: bestRoute.providers,
+      affiliateFee: `${this.feeBps / 100}%`,
+      warning: 'Wallet signing required — call wallet.sign(swapData) to execute'
+    };
+  }
+
+  /**
+   * Check swap status by tx hash
+   */
+  async getStatus(txHash) {
+    const res = await fetch(
+      `${MIDGARD_BASE}/v2/actions?txid=${txHash}`
+    );
+
+    if (!res.ok) throw new Error(`Status check failed: ${res.status}`);
+    return await res.json();
+  }
+
+  /**
+   * Get list of all supported assets (from Midgard pools)
+   */
+  async getSupportedAssets() {
+    const res = await fetch(`${MIDGARD_BASE}/v2/pools`);
+
+    if (!res.ok) throw new Error(`Assets fetch failed: ${res.status}`);
+    const pools = await res.json();
+
+    return Array.isArray(pools) ? pools.map(p => ({
+      identifier: p.asset,
+      asset: p.asset,
+      chain: p.asset.split('.')[0],
+      ticker: p.asset.split('.')[1]?.split('-')[0],
+      symbol: p.asset.split('.')[1],
+    })) : [];
+  }
+
+  /**
+   * Get inbound addresses for all chains
+   */
+  async getInboundAddresses() {
+    const res = await fetch(`${THORNODE_BASE}/thorchain/inbound_addresses`);
+    if (!res.ok) throw new Error(`Inbound addresses fetch failed: ${res.status}`);
+    return await res.json();
+  }
+
+  // Build THORChain swap memo with affiliate fee
+  _buildMemo(toAsset, destAddress, streamingSwap) {
+    const affiliateShort = this.feeAddress ? this.feeAddress.slice(0, 8) : 'mb';
+    return `=:${toAsset}:${destAddress}:0/3/0:${affiliateShort}:${this.feeBps}`;
+  }
+}

package/src/telegram.js

@@ -0,0 +1,239 @@
+/**
+ * Telegram Bot — MoreBetter Crypto Swap Agent
+ * Commands: /start /quote /assets /help /about
+ * Uses: node-telegram-bot-api + SwapKit REST API
+ */
+
+import 'dotenv/config';
+import TelegramBot from 'node-telegram-bot-api';
+import { SwapKitApi } from './swapkit.js';
+import { formatQuote, formatAssetList } from './formatter.js';
+
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
+if (!BOT_TOKEN) {
+  console.error('[Telegram] TELEGRAM_BOT_TOKEN not set in environment. Get one from @BotFather.');
+  process.exit(1);
+}
+
+const swapkit = new SwapKitApi({
+  apiKey: process.env.SWAPKIT_API_KEY || '',
+  feeBps: parseInt(process.env.SWAP_FEE_BPS || '50', 10),
+  feeAddress: process.env.SWAP_FEE_ADDRESS || 'thor1morebetter'
+});
+
+const bot = new TelegramBot(BOT_TOKEN, { polling: true });
+
+console.log('[Telegram] Bot starting in polling mode...');
+
+// ── /start ───────────────────────────────────────────────────────────────────
+bot.onText(/\/start/, (msg) => {
+  const name = msg.from?.first_name || 'there';
+  bot.sendMessage(msg.chat.id, [
+    `👋 Hey ${name}! I'm the **MoreBetter Crypto Swap Agent**.`,
+    '',
+    'I find the best cross-chain swap routes via THORChain — covering BTC, ETH, SOL, AVAX, BNB and more.',
+    '',
+    '**Commands:**',
+    '`/quote BTC ETH 0.1` — Get a swap quote',
+    '`/assets` — List supported assets',
+    '`/help` — Usage guide & examples',
+    '`/about` — About this service',
+    '',
+    'Try: `/quote BTC ETH 0.1`'
+  ].join('\n'), { parse_mode: 'Markdown' });
+});
+
+// ── /quote [from] [to] [amount] ──────────────────────────────────────────────
+bot.onText(/\/quote(?:\s+(.+))?/, async (msg, match) => {
+  const chatId = msg.chat.id;
+  const args = match?.[1]?.trim().split(/\s+/) || [];
+
+  if (args.length < 3) {
+    return bot.sendMessage(chatId, [
+      '⚠️ Usage: `/quote [FROM] [TO] [AMOUNT]`',
+      '',
+      'Examples:',
+      '`/quote BTC ETH 0.1`',
+      '`/quote ETH BTC 1.5`',
+      '`/quote RUNE BTC 500`'
+    ].join('\n'), { parse_mode: 'Markdown' });
+  }
+
+  const [fromSymbol, toSymbol, amountStr] = args;
+  const amount = parseFloat(amountStr);
+
+  if (isNaN(amount) || amount <= 0) {
+    return bot.sendMessage(chatId, '⚠️ Amount must be a positive number. Example: `/quote BTC ETH 0.1`', { parse_mode: 'Markdown' });
+  }
+
+  // Normalise to chain.SYMBOL format (basic mapping)
+  const fromAsset = normaliseAsset(fromSymbol.toUpperCase());
+  const toAsset = normaliseAsset(toSymbol.toUpperCase());
+
+  const thinking = await bot.sendMessage(chatId, `🔍 Getting quote for ${amount} ${fromSymbol.toUpperCase()} → ${toSymbol.toUpperCase()}...`);
+
+  try {
+    const quoteData = await swapkit.getQuote(fromAsset, toAsset, amount);
+    const parsed = { fromAsset, toAsset, amount };
+    const result = formatQuote(quoteData, parsed);
+
+    if (!result.success) {
+      await bot.editMessageText(`❌ No route found for this pair.\n\nTry: \`/assets\` to see supported tokens.`, {
+        chat_id: chatId,
+        message_id: thinking.message_id,
+        parse_mode: 'Markdown'
+      });
+      return;
+    }
+
+    const text = [
+      `💱 **Swap Quote**`,
+      `**${amount} ${fromSymbol.toUpperCase()} → ${toSymbol.toUpperCase()}**`,
+      '',
+      `📤 You send: \`${amount} ${fromSymbol.toUpperCase()}\``,
+      `📥 You receive: \`${result.expectedOutput || 'calculating...'}\``,
+      `🛣️ Route: ${result.route}`,
+      `⏱️ Est. time: ${result.estimatedTimeSeconds ? Math.ceil(result.estimatedTimeSeconds / 60) + ' mins' : 'varies'}`,
+      `📉 Price impact: ${result.priceImpact || 'n/a'}%`,
+      `💰 Service fee: ${result.affiliateFee}`,
+      result.warning ? `\n⚠️ ${result.warning}` : '',
+      '',
+      `_Quote valid for ~60 seconds_`
+    ].filter(Boolean).join('\n');
+
+    await bot.editMessageText(text, {
+      chat_id: chatId,
+      message_id: thinking.message_id,
+      parse_mode: 'Markdown'
+    });
+
+  } catch (err) {
+    console.error('[Quote Error]', err.message);
+    await bot.editMessageText(
+      `❌ Failed to get quote: ${sanitiseError(err.message)}\n\nPlease try again or check \`/assets\` for supported tokens.`,
+      { chat_id: chatId, message_id: thinking.message_id, parse_mode: 'Markdown' }
+    );
+  }
+});
+
+// ── /assets ──────────────────────────────────────────────────────────────────
+bot.onText(/\/assets/, async (msg) => {
+  const chatId = msg.chat.id;
+  const thinking = await bot.sendMessage(chatId, '📋 Fetching supported assets...');
+
+  try {
+    const assets = await swapkit.getSupportedAssets();
+    const result = formatAssetList(assets);
+
+    // Group by chain for readability
+    const byChain = {};
+    result.assets.forEach(a => {
+      const chain = a.chain || a.identifier?.split('.')[0] || 'OTHER';
+      if (!byChain[chain]) byChain[chain] = [];
+      byChain[chain].push(a.symbol || a.identifier);
+    });
+
+    const lines = [`✅ **${result.count} assets supported** (showing top 50)`, ''];
+    for (const [chain, symbols] of Object.entries(byChain).slice(0, 8)) {
+      lines.push(`**${chain}:** ${symbols.slice(0, 5).join(', ')}${symbols.length > 5 ? '...' : ''}`);
+    }
+    lines.push('', '_Full list at api.swapkit.dev/tokens_');
+
+    await bot.editMessageText(lines.join('\n'), {
+      chat_id: chatId,
+      message_id: thinking.message_id,
+      parse_mode: 'Markdown'
+    });
+
+  } catch (err) {
+    console.error('[Assets Error]', err.message);
+    await bot.editMessageText(
+      `❌ Could not fetch asset list: ${sanitiseError(err.message)}`,
+      { chat_id: chatId, message_id: thinking.message_id }
+    );
+  }
+});
+
+// ── /help ────────────────────────────────────────────────────────────────────
+bot.onText(/\/help/, (msg) => {
+  bot.sendMessage(msg.chat.id, [
+    '📖 **MoreBetter Swap Agent — Help**',
+    '',
+    '**Get a quote:**',
+    '`/quote [FROM] [TO] [AMOUNT]`',
+    'Example: `/quote BTC ETH 0.5`',
+    'Example: `/quote RUNE BTC 100`',
+    'Example: `/quote ETH SOL 2`',
+    '',
+    '**List assets:**',
+    '`/assets` — shows all supported tokens',
+    '',
+    '**Asset format:**',
+    'Use the token symbol (BTC, ETH, SOL, RUNE, AVAX, BNB, etc.).',
+    'The bot auto-resolves to the native chain.',
+    '',
+    '**Fees:**',
+    '0.5% service fee on all swaps, embedded in the route.',
+    'No hidden charges. You always see the output before confirming.',
+    '',
+    '**Questions?** DM @MoreBetterStudios on X.'
+  ].join('\n'), { parse_mode: 'Markdown' });
+});
+
+// ── /about ───────────────────────────────────────────────────────────────────
+bot.onText(/\/about/, (msg) => {
+  bot.sendMessage(msg.chat.id, [
+    '⚡ **MoreBetter Crypto Swap Agent**',
+    '',
+    'Built by **MoreBetter Studios** — autonomous AI agents generating value 24/7.',
+    '',
+    'Powered by **THORChain + SwapKit SDK**: the leading non-custodial cross-chain DEX.',
+    '• 9 blockchains: BTC, ETH, SOL, AVAX, BNB, RUNE, BASE, DOGE, GAIA',
+    '• Best prices via aggregated routing',
+    '• No wrapping, no bridges, no custodial risk',
+    '• Streaming swaps for large volumes',
+    '',
+    '**Version:** 0.2.0 (Week 2)',
+    '**Website:** https://morebetter.studio',
+    '**X:** @MoreBetterStudios'
+  ].join('\n'), { parse_mode: 'Markdown' });
+});
+
+// ── Error handling ───────────────────────────────────────────────────────────
+bot.on('polling_error', (error) => {
+  console.error('[Polling Error]', error.code, error.message);
+});
+
+bot.on('error', (error) => {
+  console.error('[Bot Error]', error.message);
+});
+
+console.log('[Telegram] Bot ready. Listening for commands...');
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Normalise symbol (BTC) to chain.SYMBOL format (BTC.BTC) */
+function normaliseAsset(symbol) {
+  const CHAIN_MAP = {
+    BTC: 'BTC.BTC',
+    ETH: 'ETH.ETH',
+    SOL: 'SOL.SOL',
+    RUNE: 'THOR.RUNE',
+    AVAX: 'AVAX.AVAX',
+    BNB: 'BSC.BNB',
+    DOGE: 'DOGE.DOGE',
+    ATOM: 'GAIA.ATOM',
+    USDC: 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48',
+    USDT: 'ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7'
+  };
+  // If already in X.Y format, return as-is
+  if (symbol.includes('.')) return symbol;
+  return CHAIN_MAP[symbol] || `${symbol}.${symbol}`;
+}
+
+/** Strip internal details from error messages before showing to users */
+function sanitiseError(msg) {
+  if (!msg) return 'unknown error';
+  // Don't expose API keys, URLs, stack traces
+  return msg.replace(/https?:\/\/\S+/g, '[API]').slice(0, 100);
+}