byreal-test 1.2.2 → 1.3.0

package/cli.js

@@ -15,7 +15,7 @@ const program = new Command();
 program
   .name('byreal-test')
   .description('Byreal CLI test suite — validates byreal-cli commands and generates reports')
-  .version('1.0.0');
+  .version(require('./package.json').version);
 
 program
   .command('run')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "byreal-test",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Byreal CLI test suite - runs byreal-cli commands and generates test reports",
   "main": "cli.js",
   "bin": {

package/src/swap-runner.js

@@ -5,7 +5,12 @@ const { parseJsonOutput } = require('./runner');
 const chalk = require('chalk');
 
 const USDC_MINT  = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
-const SWAP_AMOUNT = '0.01';
+const SWAP_AMOUNT = '1';
+
+const EXCLUDED_SYMBOLS = new Set([
+  'SOL', 'bbSOL', 'USDT', 'USD1', 'CRCLx', 'NVDAx',
+  'XAUt0', 'METAx', 'AMZNx', 'COINx', 'APPLx', 'MCDx',
+]);
 
 // ─── lark notify ─────────────────────────────────────────────────────────────
 
@@ -22,8 +27,11 @@ async function sendLark(webhookUrl, { token, ctx, results }) {
   const time     = utc8Label();
   const hasAlert = Object.values(results).some(r => r.alertLevel === 'alert');
   const hasWarn  = Object.values(results).some(r => r.alertLevel === 'warn');
+  const swapFailed = results.swap?.swapFailed;
 
-  const statusLine = hasAlert
+  const statusLine = swapFailed
+    ? '🚨  swap 连续5次失败，请立即检查'
+    : hasAlert
     ? '⚠️  swap 存在超时，请关注'
     : hasWarn
     ? '🐢  swap 数据延迟，但已到达'
@@ -31,6 +39,7 @@ async function sendLark(webhookUrl, { token, ctx, results }) {
 
   const fmtResult = (r) => {
     if (!r) return '—';
+    if (r?.swapFailed) return '🚨  连续5次swap失败';
     if (r.alertLevel === 'alert') return '⚠️  超时未出现（> 1分钟）';
     if (r.alertLevel === 'warn')  return `🐢  ${fmt(r.elapsed)}（第二窗口）`;
     return `${fmt(r.elapsed)}`;
@@ -98,7 +107,7 @@ function pickRandomToken() {
   const tokens = res?.data?.tokens;
   if (!Array.isArray(tokens) || tokens.length === 0)
     throw new Error('tokens list returned empty or invalid data');
-  const eligible = tokens.filter(t => t.mint !== USDC_MINT);
+  const eligible = tokens.filter(t => t.mint !== USDC_MINT && !EXCLUDED_SYMBOLS.has(t.symbol));
   if (eligible.length === 0) throw new Error('no eligible tokens (only USDC found)');
   const token = eligible[Math.floor(Math.random() * eligible.length)];
   console.log(
@@ -111,25 +120,25 @@ function pickRandomToken() {
 
 // ─── swap execution ──────────────────────────────────────────────────────────
 
-function executeSwap(outputMint, dryRun) {
+function executeSwap({ inputMint, outputMint, amount, dryRun, label }) {
   const mode = dryRun ? '--dry-run' : '--confirm';
   const cmd = [
     'byreal-cli swap execute',
-    `--input-mint ${USDC_MINT}`,
+    `--input-mint ${inputMint}`,
     `--output-mint ${outputMint}`,
-    `--amount ${SWAP_AMOUNT}`,
+    `--amount ${amount}`,
     mode,
     '-o json',
   ].join(' ');
 
-  console.log(chalk.dim(`  → ${dryRun ? '[DRY RUN] ' : ''}Executing swap: ${SWAP_AMOUNT} USDC → ...`));
+  console.log(chalk.dim(`  → ${dryRun ? '[DRY RUN] ' : ''}${label}`));
   const t0 = Date.now();
   const out = execSync(cmd, { encoding: 'utf8', timeout: 60000 });
   const elapsed = Date.now() - t0;
 
   const res = parseJsonOutput(out);
   if (!res?.success) throw new Error(`swap command failed: ${JSON.stringify(res)}`);
-  console.log(chalk.green(`  ✓ Swap ${dryRun ? 'previewed' : 'submitted'} in ${fmt(elapsed)}`));
+  console.log(chalk.green(`  ✓ Swap submitted in ${fmt(elapsed)}`));
   return res.data;
 }
 
@@ -190,40 +199,41 @@ async function pollOrderApi(baseUrl, ctx, pollOpts) {
 
 /**
  * Poll kline API.
- * URL is built as: baseUrl?tokenAddress={outputMint}&startTime={...}&endTime={...}&klineType=1m
- *
- * endTime  = Math.floor(swapAt / 1000) + 60   (swap time + 1 min, unix seconds)
- * startTime = endTime - 3600                   (1 hour window)
+ * URL: baseUrl?tokenAddress={outputMint}&startTime={swapAt-2min}&endTime={swapAt+2min}&klineType=1m
  *
- * Found when: result.success === true && result.data !== null
+ * Found when: result.success === true && at least one candle has v > 0
+ * Retry schedule: wait 10s → check, wait 30s → check, wait 60s → check, then alert
  */
-async function pollKlineApi(baseUrl, ctx, pollOpts) {
-  const { window1Ms, window2Ms, intervalMs } = pollOpts;
-  const startAt  = Date.now();
-  const deadline = startAt + window1Ms + window2Ms;
-  let phase = 1;
+async function pollKlineApi(baseUrl, ctx) {
+  const startAt   = Date.now();
+  const swapSec   = Math.floor(ctx.swapAt / 1000);
+  const startTime = swapSec - 300;   // swap time - 5 min
+  const endTime   = swapSec + 300;   // swap time + 5 min
+  const url = `${baseUrl}?tokenAddress=${ctx.outputMint}&startTime=${startTime}&endTime=${endTime}&klineType=1m`;
+
+  // Check at: +10s, +40s, +5min from polling start
+  // alertLevel: window1=ok, window2=warn, window3=warn(slow but acceptable), timeout=alert
+  const windows = [
+    { wait: 10_000,                          label: null,    phase: 1 },
+    { wait: 30_000,                          label: '(+30s)', phase: 2 },
+    { wait: 300_000 - 10_000 - 30_000,      label: '(+5min)', phase: 3 },
+  ];
 
   process.stdout.write(chalk.dim('  ⏳ Polling [kline]  '));
 
-  while (Date.now() < deadline) {
-    const now = Date.now();
-    if (now > startAt + window1Ms && phase === 1) {
-      process.stdout.write(chalk.yellow('(+30s) '));
-      phase = 2;
-    }
-
-    const endTime   = Math.floor(ctx.swapAt / 1000) + 60;
-    const startTime = endTime - 3600;
-    const url = `${baseUrl}?tokenAddress=${ctx.outputMint}&startTime=${startTime}&endTime=${endTime}&klineType=1m`;
+  for (const w of windows) {
+    await sleep(w.wait);
+    if (w.label) process.stdout.write(chalk.yellow(w.label + ' '));
 
     const data = await fetchJson(url);
-    if (data?.result?.success === true && data?.result?.data != null) {
-      return finish('kline', true, phase, Date.now() - startAt);
-    }
+    const candles = data?.result?.data;
 
-    await sleep(intervalMs);
+    if (Array.isArray(candles) && candles.some(c => parseFloat(c.v) > 0)) {
+      return finish('kline', true, w.phase, Date.now() - startAt);
+    }
   }
-  return finish('kline', false, phase, Date.now() - startAt);
+
+  return finish('kline', false, 3, Date.now() - startAt);
 }
 
 // ─── common finish ───────────────────────────────────────────────────────────
@@ -235,7 +245,8 @@ function finish(label, found, phase, elapsed) {
   if (found) {
     const level = phase === 1 ? 'ok' : 'warn';
     const tag   = phase === 1 ? chalk.green('✓') : chalk.yellow('⚠');
-    console.log(`  ${tag} [${label}] appeared in ${chalk.bold(fmt(elapsed))}`);
+    const note  = phase === 3 ? ' (5min内)' : '';
+    console.log(`  ${tag} [${label}] appeared in ${chalk.bold(fmt(elapsed))}${note}`);
     return { found: true, elapsed, alertLevel: level };
   }
   console.log(
@@ -261,23 +272,43 @@ async function runSwap(opts = {}) {
 
   console.log(chalk.bold('\n  byreal-test run_swap\n'));
 
-  // ① pick random token
-  let token;
-  try {
-    token = pickRandomToken();
-  } catch (err) {
-    console.error(chalk.red(`  ✗ Token selection failed: ${err.message}`));
-    process.exit(1);
-  }
+  // ① pick random token + retry swap up to 5 times
+  const MAX_SWAP_ATTEMPTS = 5;
+  let token, swapData, swapAt;
 
-  // ② execute swap
-  let swapData;
-  const swapAt = Date.now();
-  try {
-    swapData = executeSwap(token.mint, dryRun);
-  } catch (err) {
-    console.error(chalk.red(`  ✗ Swap failed: ${err.message}`));
-    process.exit(1);
+  for (let attempt = 1; attempt <= MAX_SWAP_ATTEMPTS; attempt++) {
+    try {
+      token = pickRandomToken();
+    } catch (err) {
+      console.error(chalk.red(`  ✗ Token selection failed: ${err.message}`));
+      process.exit(1);
+    }
+
+    swapAt = Date.now();
+    try {
+      swapData = executeSwap({
+        inputMint: USDC_MINT,
+        outputMint: token.mint,
+        amount: SWAP_AMOUNT,
+        dryRun,
+        label: `Buy: ${SWAP_AMOUNT} USDC → ${token.symbol}`,
+      });
+      break;  // swap succeeded, proceed
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Swap attempt ${attempt}/${MAX_SWAP_ATTEMPTS} failed for ${token.symbol}: ${err.message.split('\n')[0]}`));
+      if (attempt === MAX_SWAP_ATTEMPTS) {
+        console.error(chalk.red(`  ✗ All ${MAX_SWAP_ATTEMPTS} swap attempts failed`));
+        if (larkWebhook) {
+          await sendLark(larkWebhook, {
+            token: { symbol: 'N/A', mint: '' },
+            ctx: { txHash: '', orderId: '', outputMint: '' },
+            results: { swap: { alertLevel: 'alert', elapsed: 0, swapFailed: true } },
+          });
+        }
+        process.exit(1);
+      }
+      console.log(chalk.dim('  → Picking another token...\n'));
+    }
   }
 
   const ctx = {
@@ -310,7 +341,7 @@ async function runSwap(opts = {}) {
 
   // ⑤ poll kline API
   if (klineApiUrl) {
-    results.kline = await pollKlineApi(klineApiUrl, ctx, pollOpts);
+    results.kline = await pollKlineApi(klineApiUrl, ctx);
   } else {
     console.log(chalk.dim('  – kline API not configured (use --kline-api <url>)'));
   }
@@ -329,12 +360,47 @@ async function runSwap(opts = {}) {
   }
   console.log('');
 
-  // ⑦ lark notification
-  if (larkWebhook) {
+  // ⑦ lark notification — only on alert/warn
+  const hasAlert = Object.values(results).some(r => r.alertLevel === 'alert');
+  const hasWarn  = Object.values(results).some(r => r.alertLevel === 'warn');
+  if (larkWebhook && (hasAlert || hasWarn)) {
     await sendLark(larkWebhook, { token, ctx, results });
+  } else if (larkWebhook) {
+    console.log(chalk.dim('  → All OK, Lark skipped'));
+  }
+
+  // ⑧ wait 5 min then sell AToken → USDC
+  const receivedAmount = swapData.uiOutAmount;
+  if (receivedAmount && parseFloat(receivedAmount) > 0 && !dryRun) {
+    const SELL_WAIT = 5 * 60_000;
+    console.log(chalk.dim(`\n  Waiting 5 min before selling ${token.symbol}...`));
+    await sleep(SELL_WAIT);
+
+    console.log('');
+    try {
+      const sellData = executeSwap({
+        inputMint:  token.mint,
+        outputMint: USDC_MINT,
+        amount:     receivedAmount,
+        dryRun:     false,
+        label:      `Sell: ${receivedAmount} ${token.symbol} → USDC`,
+      });
+      const sellHash = (sellData.signatures || [])[0] || '';
+      console.log(chalk.dim(`  → sell txHash: ${sellHash}`));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Sell failed: ${err.message.split('\n')[0]}`));
+      if (larkWebhook) {
+        await sendLark(larkWebhook, {
+          token,
+          ctx: { ...ctx, txHash: '' },
+          results: { sell: { alertLevel: 'alert', elapsed: 0, sellFailed: true } },
+        });
+      }
+    }
+  } else if (dryRun) {
+    console.log(chalk.dim('\n  [DRY RUN] Sell step skipped'));
   }
 
-  const hasAlert = Object.values(results).some(r => r.alertLevel === 'alert');
   return { token, swapData, ctx, results, hasAlert };
 }