@four-meme/four-meme-ai 1.0.6 → 1.0.8

package/skills/four-meme-integration/scripts/token-rankings.ts

@@ -1,16 +1,59 @@
 #!/usr/bin/env node
 /**
  * Four.meme - token rankings (REST API)
- * POST /meme-api/v1/private/token/query/advanced
- * Body: { orderBy: "Time"|"ProgressDesc"|"TradingDesc"|"Hot"|"Graduated" [, barType: "HOUR24" ] }
- * Usage: npx tsx token-rankings.ts <orderBy> [--barType=HOUR24]
- *   orderBy: Time | ProgressDesc | TradingDesc | Hot | Graduated
- *   --barType only for TradingDesc (24h volume)
+ * POST /meme-api/v1/public/token/ranking
+ *
+ * Backward compatible: <orderBy> where orderBy = Time | ProgressDesc | TradingDesc | Hot | Graduated
+ *   [--barType=HOUR24|HOUR4|HOUR1|MIN30|MIN5] (only for TradingDesc; maps to VOL_* windows)
+ *
+ * You may also pass a native API RankingType directly: NEW, PROGRESS, VOL_DAY_1, HOT, DEX, VOL, LAST, CAP, …
+ *
+ * Optional filters: [--pageSize=20] [--symbol=] [--version=] [--rankingKind=]
+ *   [--minCap=] [--maxCap=] [--minVol=] [--maxVol=] [--minHold=] [--maxHold=]
+ *
+ * Usage: npx tsx token-rankings.ts <orderOrType> [--barType=HOUR24] [filters...]
  * Output: JSON ranking list.
  */
 
 const API_BASE = 'https://four.meme/meme-api/v1';
 
+const LEGACY_ORDER_BY = ['Time', 'ProgressDesc', 'TradingDesc', 'Hot', 'Graduated'] as const;
+
+/** Legacy TradingDesc + barType → public ranking `type`. */
+const BAR_TYPE_TO_VOL_TYPE: Record<string, string> = {
+  HOUR24: 'VOL_DAY_1',
+  DAY1: 'VOL_DAY_1',
+  HOUR4: 'VOL_HOUR_4',
+  HOUR1: 'VOL_HOUR_1',
+  MIN30: 'VOL_MIN_30',
+  MIN5: 'VOL_MIN_5',
+};
+
+const LEGACY_TO_TYPE: Record<string, string> = {
+  Time: 'NEW',
+  ProgressDesc: 'PROGRESS',
+  TradingDesc: 'VOL_DAY_1',
+  Hot: 'HOT',
+  Graduated: 'DEX',
+};
+
+/** Native ranking types allowed as the first argument (aligned with API RankingType). */
+const NATIVE_RANKING_TYPES = new Set([
+  'NEW',
+  'PROGRESS',
+  'VOL_MIN_5',
+  'VOL_MIN_30',
+  'VOL_HOUR_1',
+  'VOL_HOUR_4',
+  'VOL_DAY_1',
+  'VOL',
+  'LAST',
+  'HOT',
+  'CAP',
+  'DEX',
+  'BURN',
+]);
+
 function parseArg(name: string): string | undefined {
   const prefix = `--${name}=`;
   for (let i = 3; i < process.argv.length; i++) {
@@ -20,19 +63,84 @@ function parseArg(name: string): string | undefined {
   return undefined;
 }
 
+function parseNumArg(name: string): number | undefined {
+  const v = parseArg(name);
+  if (v == null || v.trim() === '') return undefined;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function resolveRankingType(first: string, barType?: string): string {
+  if (first === 'TradingDesc') {
+    if (barType && BAR_TYPE_TO_VOL_TYPE[barType]) {
+      return BAR_TYPE_TO_VOL_TYPE[barType];
+    }
+    return 'VOL_DAY_1';
+  }
+  if (LEGACY_TO_TYPE[first]) {
+    return LEGACY_TO_TYPE[first];
+  }
+  return first;
+}
+
+function normalizeLegacyOrderBy(s: string): string {
+  const map: Record<string, string> = {
+    time: 'Time',
+    progressdesc: 'ProgressDesc',
+    tradingdesc: 'TradingDesc',
+    hot: 'Hot',
+    graduated: 'Graduated',
+  };
+  return map[s.toLowerCase()] ?? s;
+}
+
 async function main() {
-  const orderBy = process.argv[2];
-  const validOrderBy = ['Time', 'ProgressDesc', 'TradingDesc', 'Hot', 'Graduated'];
-  if (!orderBy || !validOrderBy.includes(orderBy)) {
-    console.error('Usage: npx tsx token-rankings.ts <orderBy> [--barType=HOUR24]');
-    console.error('orderBy: Time | ProgressDesc | TradingDesc | Hot | Graduated');
+  const rawFirst = process.argv[2];
+  const first = rawFirst ? normalizeLegacyOrderBy(rawFirst) : '';
+  if (!first) {
+    console.error(
+      'Usage: npx tsx token-rankings.ts <orderBy|RankingType> [--barType=HOUR24] [--pageSize=20] ...',
+    );
+    console.error(
+      'Legacy orderBy: Time | ProgressDesc | TradingDesc | Hot | Graduated (barType for TradingDesc)',
+    );
+    console.error('Or native type: NEW, PROGRESS, VOL_DAY_1, HOT, DEX, VOL, LAST, CAP, BURN, ...');
     process.exit(1);
   }
-  const body: Record<string, string> = { orderBy };
+
   const barType = parseArg('barType');
-  if (barType) body.barType = barType;
+  let rankingType = resolveRankingType(first, barType);
+
+  const isLegacy = (LEGACY_ORDER_BY as readonly string[]).includes(first);
+  if (!isLegacy && !NATIVE_RANKING_TYPES.has(rankingType)) {
+    console.error(`Unknown ranking type: ${first}`);
+    console.error(
+      `Use legacy: ${LEGACY_ORDER_BY.join(' | ')} or native: ${[...NATIVE_RANKING_TYPES].join(', ')}`,
+    );
+    process.exit(1);
+  }
+
+  const pageSizeArg = parseNumArg('pageSize');
+  const pageSize = pageSizeArg != null ? Math.min(100, Math.max(1, pageSizeArg)) : 20;
+
+  const body: Record<string, unknown> = {
+    type: rankingType,
+    pageSize,
+  };
+
+  const symbol = parseArg('symbol')?.trim();
+  if (symbol) body.symbol = symbol;
+  const version = parseArg('version')?.trim();
+  if (version) body.version = version;
+  const rankingKind = parseArg('rankingKind')?.trim();
+  if (rankingKind) body.rankingKind = rankingKind;
+
+  for (const key of ['minCap', 'maxCap', 'minVol', 'maxVol', 'minHold', 'maxHold'] as const) {
+    const n = parseNumArg(key);
+    if (n !== undefined) body[key] = n;
+  }
 
-  const url = `${API_BASE}/private/token/query/advanced`;
+  const url = `${API_BASE}/public/token/ranking`;
   const res = await fetch(url, {
     method: 'POST',
     headers: {
@@ -42,7 +150,7 @@ async function main() {
     body: JSON.stringify(body),
   });
   if (!res.ok) {
-    throw new Error(`token/query/advanced failed: ${res.status} ${await res.text()}`);
+    throw new Error(`token/ranking failed: ${res.status} ${await res.text()}`);
   }
   const data = await res.json();
   console.log(JSON.stringify(data, null, 2));