@darksol/terminal 0.1.0

package/src/services/builders.js

@@ -0,0 +1,70 @@
+import fetch from 'node-fetch';
+import { getServiceURL } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, table, kvDisplay, error } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+const getURL = () => getServiceURL('builders') || 'https://builders.darksol.net';
+
+export async function buildersLeaderboard(opts = {}) {
+  const spin = spinner('Loading builder leaderboard...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/leaderboard?limit=${opts.limit || 20}`);
+    const data = await resp.json();
+    spin.succeed('Leaderboard loaded');
+
+    showSection('ERC-8021 BUILDER LEADERBOARD');
+    const builders = data.builders || data;
+    if (Array.isArray(builders)) {
+      const rows = builders.map((b, i) => [
+        `#${i + 1}`,
+        theme.gold(b.code || b.builderCode || '?'),
+        b.name || 'Unknown',
+        b.transactions?.toString() || '0',
+        b.volume ? `$${b.volume}` : 'N/A',
+      ]);
+      table(['Rank', 'Code', 'Name', 'TXs', 'Volume'], rows);
+    }
+  } catch (err) {
+    spin.fail('Leaderboard failed');
+    error(err.message);
+  }
+}
+
+export async function buildersLookup(code) {
+  const spin = spinner(`Looking up builder: ${code}...`).start();
+  try {
+    const resp = await fetch(`${getURL()}/api/builders/${code}`);
+    const data = await resp.json();
+    spin.succeed('Builder found');
+
+    showSection(`BUILDER — ${code}`);
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, typeof v === 'object' ? JSON.stringify(v) : String(v)]));
+  } catch (err) {
+    spin.fail('Builder not found');
+    error(err.message);
+  }
+}
+
+export async function buildersFeed(opts = {}) {
+  const spin = spinner('Loading builder feed...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/feed?limit=${opts.limit || 20}`);
+    const data = await resp.json();
+    spin.succeed('Feed loaded');
+
+    showSection('BUILDER FEED');
+    const txs = data.transactions || data;
+    if (Array.isArray(txs)) {
+      const rows = txs.map(tx => [
+        tx.builderCode || '?',
+        tx.hash ? `${tx.hash.slice(0, 10)}...` : 'N/A',
+        tx.timestamp ? new Date(tx.timestamp).toLocaleString() : 'N/A',
+      ]);
+      table(['Builder', 'TX Hash', 'Time'], rows);
+    }
+  } catch (err) {
+    spin.fail('Feed failed');
+    error(err.message);
+  }
+}

package/src/services/cards.js

@@ -0,0 +1,67 @@
+import fetch from 'node-fetch';
+import { getServiceURL } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, error, table } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+const getURL = () => getServiceURL('cards') || 'https://acp.darksol.net/cards';
+
+export async function cardsCatalog() {
+  const spin = spinner('Loading card catalog...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/cards/catalog`);
+    const data = await resp.json();
+    spin.succeed('Catalog loaded');
+
+    showSection('PREPAID CARDS');
+    const cards = data.providers || data;
+    if (Array.isArray(cards)) {
+      const rows = cards.map(c => [
+        theme.gold(c.name),
+        c.network || 'Visa/MC',
+        c.denominations?.join(', ') || 'Various',
+        c.region || 'Global',
+      ]);
+      table(['Provider', 'Network', 'Amounts', 'Region'], rows);
+    } else {
+      kvDisplay(Object.entries(cards).map(([k, v]) => [k, String(v)]));
+    }
+  } catch (err) {
+    spin.fail('Catalog failed');
+    error(err.message);
+  }
+}
+
+export async function cardsOrder(provider, amount) {
+  const spin = spinner('Processing card order...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/cards/order`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ provider, amount }),
+    });
+    const data = await resp.json();
+    spin.succeed('Order placed');
+
+    showSection('CARD ORDER');
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    spin.fail('Order failed');
+    error(err.message);
+  }
+}
+
+export async function cardsStatus(orderId) {
+  const spin = spinner('Checking order...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/cards/status?orderId=${orderId}`);
+    const data = await resp.json();
+    spin.succeed('Status loaded');
+
+    showSection(`CARD ORDER — ${orderId}`);
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    spin.fail('Status check failed');
+    error(err.message);
+  }
+}

package/src/services/casino.js

@@ -0,0 +1,94 @@
+import fetch from 'node-fetch';
+import { getServiceURL } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, table } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+const getURL = () => getServiceURL('casino') || 'https://casino.darksol.net';
+
+export async function casinoBet(game, opts = {}) {
+  const spin = spinner(`Placing ${game} bet...`).start();
+  try {
+    const resp = await fetch(`${getURL()}/api/bet`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        game,
+        choice: opts.choice,
+        number: opts.number,
+        wallet: opts.wallet,
+      }),
+    });
+    const data = await resp.json();
+    spin.succeed('Bet placed');
+
+    showSection(`CASINO — ${game.toUpperCase()}`);
+    kvDisplay([
+      ['Game', game],
+      ['Your Call', opts.choice || opts.number || 'N/A'],
+      ['Result', data.result ? theme.gold.bold(data.result) : 'N/A'],
+      ['Won', data.won ? theme.success.bold('YES!') : theme.error('No')],
+      ['Payout', data.payout ? `$${data.payout}` : '$0'],
+      ['TX', data.txHash || 'N/A'],
+    ]);
+  } catch (err) {
+    spin.fail('Bet failed');
+    error(err.message);
+  }
+}
+
+export async function casinoTables() {
+  const spin = spinner('Loading tables...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/tables`);
+    const data = await resp.json();
+    spin.succeed('Tables loaded');
+
+    showSection('CASINO TABLES');
+    const tables = data.tables || data;
+    if (Array.isArray(tables)) {
+      const rows = tables.map(t => [
+        theme.gold(t.name || t.game),
+        t.multiplier || 'N/A',
+        t.minBet || '$1',
+        t.status || 'Open',
+      ]);
+      table(['Game', 'Multiplier', 'Min Bet', 'Status'], rows);
+    } else {
+      kvDisplay(Object.entries(tables).map(([k, v]) => [k, String(v)]));
+    }
+  } catch (err) {
+    spin.fail('Failed to load tables');
+    error(err.message);
+  }
+}
+
+export async function casinoStats() {
+  const spin = spinner('Loading stats...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/stats`);
+    const data = await resp.json();
+    spin.succeed('Stats loaded');
+
+    showSection('CASINO STATS');
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, typeof v === 'object' ? JSON.stringify(v) : String(v)]));
+  } catch (err) {
+    spin.fail('Failed to load stats');
+    error(err.message);
+  }
+}
+
+export async function casinoReceipt(id) {
+  const spin = spinner(`Loading receipt ${id}...`).start();
+  try {
+    const resp = await fetch(`${getURL()}/api/receipt/${id}`);
+    const data = await resp.json();
+    spin.succeed('Receipt loaded');
+
+    showSection(`CASINO RECEIPT — ${id}`);
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    spin.fail('Receipt not found');
+    error(err.message);
+  }
+}

package/src/services/facilitator.js

@@ -0,0 +1,60 @@
+import fetch from 'node-fetch';
+import { getServiceURL } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, error } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+const getURL = () => getServiceURL('facilitator') || 'https://facilitator.darksol.net';
+
+export async function facilitatorHealth() {
+  const spin = spinner('Checking facilitator...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/health`);
+    const data = await resp.json();
+    spin.succeed('Facilitator online');
+
+    showSection('FACILITATOR STATUS');
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, typeof v === 'object' ? JSON.stringify(v) : String(v)]));
+  } catch (err) {
+    spin.fail('Facilitator unreachable');
+    error(err.message);
+  }
+}
+
+export async function facilitatorVerify(payment) {
+  const spin = spinner('Verifying payment...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/verify`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(typeof payment === 'string' ? JSON.parse(payment) : payment),
+    });
+    const data = await resp.json();
+    spin.succeed(data.valid ? 'Payment valid' : 'Payment invalid');
+
+    showSection('PAYMENT VERIFICATION');
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    spin.fail('Verification failed');
+    error(err.message);
+  }
+}
+
+export async function facilitatorSettle(payment) {
+  const spin = spinner('Settling on-chain...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/settle`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(typeof payment === 'string' ? JSON.parse(payment) : payment),
+    });
+    const data = await resp.json();
+    spin.succeed('Settlement complete');
+
+    showSection('SETTLEMENT');
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    spin.fail('Settlement failed');
+    error(err.message);
+  }
+}

package/src/services/market.js

@@ -0,0 +1,179 @@
+import fetch from 'node-fetch';
+import { theme } from '../ui/theme.js';
+import { spinner, table, kvDisplay, formatPrice, formatChange } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import { getConfig } from '../config/store.js';
+
+const COINGECKO_API = 'https://api.coingecko.com/api/v3';
+const DEXSCREENER_API = 'https://api.dexscreener.com/latest';
+
+// Top movers on a chain
+export async function topMovers(chain, opts = {}) {
+  const spin = spinner('Fetching market data...').start();
+
+  try {
+    // DexScreener for Base/chain-specific data
+    const chainMap = { base: 'base', ethereum: 'ethereum', arbitrum: 'arbitrum', polygon: 'polygon' };
+    const dexChain = chainMap[chain || getConfig('chain')] || 'base';
+
+    const resp = await fetch(`${DEXSCREENER_API}/dex/tokens/trending/${dexChain}`, {
+      headers: { 'Accept': 'application/json' },
+    });
+
+    // Fallback to search if trending endpoint doesn't exist
+    const searchResp = await fetch(`${DEXSCREENER_API}/dex/search?q=top%20${dexChain}`, {
+      headers: { 'Accept': 'application/json' },
+    });
+
+    let pairs = [];
+    if (searchResp.ok) {
+      const data = await searchResp.json();
+      pairs = (data.pairs || [])
+        .filter(p => p.chainId === dexChain)
+        .slice(0, opts.limit || 15);
+    }
+
+    spin.succeed('Market data loaded');
+
+    if (pairs.length === 0) {
+      console.log(theme.dim('  No pairs found for this chain'));
+      return;
+    }
+
+    showSection(`TOP MOVERS — ${dexChain.toUpperCase()}`);
+
+    const rows = pairs.map(p => [
+      theme.gold(p.baseToken?.symbol || '?'),
+      formatPrice(p.priceUsd),
+      formatChange(p.priceChange?.h24),
+      `$${formatCompact(p.volume?.h24)}`,
+      `$${formatCompact(p.liquidity?.usd)}`,
+      p.dexId || '?',
+    ]);
+
+    table(['Token', 'Price', '24h %', 'Volume', 'Liquidity', 'DEX'], rows);
+
+  } catch (err) {
+    spin.fail('Failed to fetch market data');
+    console.log(theme.error(`  ${err.message}`));
+  }
+}
+
+// Token detail
+export async function tokenDetail(query, opts = {}) {
+  const spin = spinner(`Looking up ${query}...`).start();
+
+  try {
+    // Try DexScreener first
+    const resp = await fetch(`${DEXSCREENER_API}/dex/search?q=${encodeURIComponent(query)}`);
+    const data = await resp.json();
+    const pairs = data.pairs || [];
+
+    if (pairs.length === 0) {
+      spin.fail('Token not found');
+      return;
+    }
+
+    // Get the most liquid pair
+    const pair = pairs.sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+
+    spin.succeed('Token found');
+
+    showSection(`${pair.baseToken.symbol} / ${pair.quoteToken.symbol}`);
+    kvDisplay([
+      ['Name', pair.baseToken.name],
+      ['Contract', pair.baseToken.address],
+      ['Price', formatPrice(pair.priceUsd)],
+      ['24h Change', formatChange(pair.priceChange?.h24)],
+      ['6h Change', formatChange(pair.priceChange?.h6)],
+      ['1h Change', formatChange(pair.priceChange?.h1)],
+      ['Volume 24h', `$${formatCompact(pair.volume?.h24)}`],
+      ['Liquidity', `$${formatCompact(pair.liquidity?.usd)}`],
+      ['FDV', pair.fdv ? `$${formatCompact(pair.fdv)}` : 'N/A'],
+      ['DEX', pair.dexId],
+      ['Chain', pair.chainId],
+      ['Pair', pair.pairAddress],
+    ]);
+
+    // Show additional pairs
+    if (pairs.length > 1) {
+      console.log('');
+      console.log(theme.dim(`  ${pairs.length - 1} more pairs found across DEXes`));
+    }
+
+    // Also get CoinGecko data if available
+    try {
+      const cgResp = await fetch(`${COINGECKO_API}/search?query=${encodeURIComponent(query)}`);
+      const cgData = await cgResp.json();
+      if (cgData.coins?.length > 0) {
+        const coin = cgData.coins[0];
+        console.log('');
+        console.log(theme.dim(`  CoinGecko: ${coin.name} (${coin.symbol}) — Rank #${coin.market_cap_rank || 'N/A'}`));
+      }
+    } catch { }
+
+  } catch (err) {
+    spin.fail('Lookup failed');
+    console.log(theme.error(`  ${err.message}`));
+  }
+}
+
+// Compare tokens
+export async function compareTokens(tokens, opts = {}) {
+  const spin = spinner('Fetching comparison data...').start();
+
+  try {
+    const results = [];
+
+    for (const token of tokens) {
+      const resp = await fetch(`${DEXSCREENER_API}/dex/search?q=${encodeURIComponent(token)}`);
+      const data = await resp.json();
+      const pair = (data.pairs || [])
+        .sort((a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0))[0];
+
+      results.push(pair ? {
+        symbol: pair.baseToken.symbol,
+        price: pair.priceUsd,
+        change24h: pair.priceChange?.h24,
+        volume: pair.volume?.h24,
+        liquidity: pair.liquidity?.usd,
+        chain: pair.chainId,
+      } : {
+        symbol: token,
+        price: null,
+        change24h: null,
+        volume: null,
+        liquidity: null,
+        chain: 'N/A',
+      });
+    }
+
+    spin.succeed('Comparison ready');
+
+    showSection('TOKEN COMPARISON');
+
+    const rows = results.map(r => [
+      theme.gold(r.symbol),
+      r.price ? formatPrice(r.price) : theme.dim('N/A'),
+      r.change24h !== null ? formatChange(r.change24h) : theme.dim('N/A'),
+      r.volume ? `$${formatCompact(r.volume)}` : theme.dim('N/A'),
+      r.liquidity ? `$${formatCompact(r.liquidity)}` : theme.dim('N/A'),
+      r.chain,
+    ]);
+
+    table(['Token', 'Price', '24h %', 'Volume', 'Liquidity', 'Chain'], rows);
+
+  } catch (err) {
+    spin.fail('Comparison failed');
+    console.log(theme.error(`  ${err.message}`));
+  }
+}
+
+function formatCompact(num) {
+  if (!num) return '0';
+  num = parseFloat(num);
+  if (num >= 1e9) return (num / 1e9).toFixed(2) + 'B';
+  if (num >= 1e6) return (num / 1e6).toFixed(2) + 'M';
+  if (num >= 1e3) return (num / 1e3).toFixed(1) + 'K';
+  return num.toFixed(2);
+}

package/src/services/oracle.js

@@ -0,0 +1,92 @@
+import fetch from 'node-fetch';
+import { getServiceURL } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+const getURL = () => getServiceURL('oracle') || 'https://acp.darksol.net/oracle';
+
+export async function oracleFlip() {
+  const spin = spinner('Flipping coin...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/coin`);
+    const data = await resp.json();
+    spin.succeed('Coin flipped');
+    showSection('ORACLE — COIN FLIP');
+    kvDisplay([
+      ['Result', theme.gold.bold(data.result || data.value)],
+      ['Proof', data.proof || data.txHash || 'N/A'],
+    ]);
+  } catch (err) {
+    spin.fail('Oracle failed');
+    error(err.message);
+  }
+}
+
+export async function oracleDice(sides = 6) {
+  const spin = spinner(`Rolling d${sides}...`).start();
+  try {
+    const resp = await fetch(`${getURL()}/api/dice?sides=${sides}`);
+    const data = await resp.json();
+    spin.succeed('Dice rolled');
+    showSection(`ORACLE — D${sides}`);
+    kvDisplay([
+      ['Result', theme.gold.bold(data.result || data.value)],
+      ['Sides', sides.toString()],
+      ['Proof', data.proof || data.txHash || 'N/A'],
+    ]);
+  } catch (err) {
+    spin.fail('Oracle failed');
+    error(err.message);
+  }
+}
+
+export async function oracleNumber(min = 1, max = 100) {
+  const spin = spinner(`Generating number ${min}-${max}...`).start();
+  try {
+    const resp = await fetch(`${getURL()}/api/number?min=${min}&max=${max}`);
+    const data = await resp.json();
+    spin.succeed('Number generated');
+    showSection('ORACLE — RANDOM NUMBER');
+    kvDisplay([
+      ['Result', theme.gold.bold(data.result || data.value)],
+      ['Range', `${min} — ${max}`],
+      ['Proof', data.proof || data.txHash || 'N/A'],
+    ]);
+  } catch (err) {
+    spin.fail('Oracle failed');
+    error(err.message);
+  }
+}
+
+export async function oracleShuffle(items) {
+  const spin = spinner('Shuffling...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/shuffle`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ items }),
+    });
+    const data = await resp.json();
+    spin.succeed('Shuffled');
+    showSection('ORACLE — SHUFFLE');
+    console.log(theme.gold('  Result: ') + (data.result || data.value || []).join(', '));
+  } catch (err) {
+    spin.fail('Oracle failed');
+    error(err.message);
+  }
+}
+
+export async function oracleHealth() {
+  const spin = spinner('Checking oracle...').start();
+  try {
+    const resp = await fetch(`${getURL()}/api/health`);
+    const data = await resp.json();
+    spin.succeed('Oracle online');
+    showSection('ORACLE STATUS');
+    kvDisplay(Object.entries(data).map(([k, v]) => [k, String(v)]));
+  } catch (err) {
+    spin.fail('Oracle unreachable');
+    error(err.message);
+  }
+}