skillpp 0.1.0

package/skills/four-meme/four-meme-ai/scripts/quote-sell.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - sell quote via TokenManagerHelper3.trySell (BSC only).
+ * Usage: npx tsx quote-sell.ts <tokenAddress> <amountWei>
+ */
+
+import { createPublicClient, http } from 'viem';
+import { bsc } from 'viem/chains';
+
+const HELPER_ADDRESS = '0xF251F83e40a78868FcfA3FA4599Dad6494E46034' as const;
+
+const HELPER_ABI = [
+  {
+    name: 'trySell',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [
+      { name: 'tokenManager', type: 'address' },
+      { name: 'quote', type: 'address' },
+      { name: 'funds', type: 'uint256' },
+      { name: 'fee', type: 'uint256' },
+    ],
+  },
+] as const;
+
+const RPC_URL = process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+
+async function main() {
+  const tokenAddress = process.argv[2] as `0x${string}`;
+  const amountWei = BigInt(process.argv[3] ?? '0');
+
+  if (!tokenAddress) {
+    console.error('Usage: npx tsx quote-sell.ts <tokenAddress> <amountWei>');
+    console.error('BSC only.');
+    process.exit(1);
+  }
+
+  const client = createPublicClient({
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+
+  const [tokenManager, quote, funds, fee] = await client.readContract({
+    address: HELPER_ADDRESS,
+    abi: HELPER_ABI,
+    functionName: 'trySell',
+    args: [tokenAddress, amountWei],
+  });
+
+  const out = {
+    tokenManager,
+    quote: quote === '0x0000000000000000000000000000000000000000' ? 'native' : quote,
+    funds: funds.toString(),
+    fee: fee.toString(),
+  };
+  console.log(JSON.stringify(out, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme/four-meme-ai/scripts/send-token.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - send BNB or ERC20 from current wallet to a target address (BSC).
+ *
+ * Usage:
+ *   npx tsx send-token.ts <toAddress> <amountWei> [tokenAddress]
+ *   - toAddress: recipient wallet address (0x...)
+ *   - amountWei: amount in wei (for BNB or token decimals)
+ *   - tokenAddress: optional; omit or use "BNB" / "0x0" for native BNB; otherwise ERC20 token contract address
+ *
+ * Env: PRIVATE_KEY. Optional: BSC_RPC_URL.
+ */
+
+import { createWalletClient, http, parseAbi } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { bsc } from 'viem/chains';
+
+const ZERO = '0x0000000000000000000000000000000000000000' as const;
+
+const ERC20_ABI = parseAbi([
+  'function transfer(address to, uint256 amount) returns (bool)',
+]);
+
+function isAddress(s: string): boolean {
+  return /^0x[0-9a-fA-F]{40}$/.test(s);
+}
+
+async function main() {
+  const privateKey = process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    console.error('Set PRIVATE_KEY');
+    process.exit(1);
+  }
+  const pk = privateKey.startsWith('0x') ? (privateKey as `0x${string}`) : (`0x${privateKey}` as `0x${string}`);
+  const account = privateKeyToAccount(pk);
+
+  const toAddress = process.argv[2];
+  const amountWeiRaw = process.argv[3];
+  const tokenAddress = process.argv[4]; // optional: BNB if omitted or "BNB" or 0x0
+
+  if (!toAddress || !amountWeiRaw) {
+    console.error('Usage: send-token.ts <toAddress> <amountWei> [tokenAddress]');
+    console.error('  toAddress:   recipient 0x... address');
+    console.error('  amountWei:   amount in wei (for BNB or token smallest unit)');
+    console.error('  tokenAddress: optional; omit or BNB/0x0 = native BNB; else ERC20 contract address');
+    process.exit(1);
+  }
+  if (!isAddress(toAddress)) {
+    console.error('Invalid toAddress:', toAddress);
+    process.exit(1);
+  }
+
+  const amountWei = BigInt(amountWeiRaw);
+  if (amountWei <= 0n) {
+    console.error('amountWei must be positive');
+    process.exit(1);
+  }
+
+  const isNative =
+    !tokenAddress ||
+    tokenAddress.toUpperCase() === 'BNB' ||
+    tokenAddress === ZERO ||
+    tokenAddress.toLowerCase() === '0x0000000000000000000000000000000000000000';
+
+  const rpcUrl = process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+  const client = createWalletClient({
+    account,
+    chain: bsc,
+    transport: http(rpcUrl),
+  });
+
+  let txHash: `0x${string}`;
+
+  if (isNative) {
+    txHash = await client.sendTransaction({
+      to: toAddress as `0x${string}`,
+      value: amountWei,
+    });
+  } else {
+    if (!isAddress(tokenAddress)) {
+      console.error('Invalid tokenAddress:', tokenAddress);
+      process.exit(1);
+    }
+    txHash = await client.writeContract({
+      address: tokenAddress as `0x${string}`,
+      abi: ERC20_ABI,
+      functionName: 'transfer',
+      args: [toAddress as `0x${string}`, amountWei],
+    });
+  }
+
+  console.log(JSON.stringify({ txHash, to: toAddress, amountWei: amountWei.toString(), native: isNative }, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme/four-meme-ai/scripts/token-get.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - token detail + trading info (REST API)
+ * GET /meme-api/v1/private/token/get/v2?address=<address>
+ * Usage: npx tsx token-get.ts <tokenAddress>
+ * Output: JSON token info and trading info.
+ */
+
+const API_BASE = 'https://four.meme/meme-api/v1';
+
+async function main() {
+  const address = process.argv[2];
+  if (!address) {
+    console.error('Usage: npx tsx token-get.ts <tokenAddress>');
+    process.exit(1);
+  }
+  const url = `${API_BASE}/private/token/get/v2?address=${encodeURIComponent(address)}`;
+  const res = await fetch(url, {
+    headers: { Accept: 'application/json' },
+  });
+  if (!res.ok) {
+    throw new Error(`token/get/v2 failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  console.log(JSON.stringify(data, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme/four-meme-ai/scripts/token-list.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - token list (REST API)
+ * POST /meme-api/v1/public/token/search
+ *
+ * Legacy (still supported): [--orderBy=Hot] [--tokenName=] [--listedPancake=false] ...
+ * New params: [--type=HOT] [--listType=NOR] [--keyword=] [--tag=a,b] [--status=PUBLISH|TRADE|ALL] [--sort=DESC|ASC] [--version=V9]
+ * Legacy shortcut: [--queryMode=Binance|USD1] (infers listType BIN/BIN_DEX or USD1/USD1_DEX using listedPancake)
+ *
+ * Usage: npx tsx token-list.ts [options]
+ * Output: JSON list of tokens.
+ */
+
+const API_BASE = 'https://four.meme/meme-api/v1';
+
+function parseArg(name: string, defaultValue: string): string {
+  const prefix = `--${name}=`;
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length);
+  }
+  return defaultValue;
+}
+
+function hasArg(name: string): boolean {
+  const prefix = `--${name}=`;
+  return process.argv.some((a) => a.startsWith(prefix));
+}
+
+/** Map legacy orderBy → public search `type` (sort controlled by --sort=; default DESC). */
+function typeFromLegacyOrderBy(orderBy: string): string {
+  const k = orderBy.replace(/\s/g, '').toLowerCase();
+  const map: Record<string, string> = {
+    hot: 'HOT',
+    time: 'NEW',
+    timedesc: 'NEW',
+    new: 'NEW',
+    progress: 'PROGRESS',
+    progressdesc: 'PROGRESS',
+    trading: 'VOL',
+    tradingdesc: 'VOL',
+    vol: 'VOL',
+    volume: 'VOL',
+    last: 'LAST',
+    cap: 'CAP',
+    dex: 'DEX',
+    graduated: 'DEX',
+    burn: 'BURN',
+  };
+  return map[k] ?? 'HOT';
+}
+
+async function main() {
+  const pageIndex = Math.max(1, parseInt(parseArg('pageIndex', '1'), 10) || 1);
+  const pageSize = Math.min(100, Math.max(1, parseInt(parseArg('pageSize', '30'), 10) || 30));
+  const sort = (parseArg('sort', 'DESC').toUpperCase() === 'ASC' ? 'ASC' : 'DESC') as 'ASC' | 'DESC';
+
+  const listedPancake = parseArg('listedPancake', 'false').toLowerCase() === 'true';
+
+  // New API listType: allow explicit listType, or infer from legacy queryMode + listedPancake.
+  const explicitListType = hasArg('listType') ? parseArg('listType', 'NOR') : '';
+  const queryMode = parseArg('queryMode', '').trim().toLowerCase();
+  const inferredListType = (() => {
+    if (!queryMode) return '';
+    if (queryMode === 'binance' || queryMode === 'bnb' || queryMode === 'bnb_mpc') {
+      return listedPancake ? 'BIN_DEX' : 'BIN';
+    }
+    if (queryMode === 'usd1') {
+      return listedPancake ? 'USD1_DEX' : 'USD1';
+    }
+    return '';
+  })();
+  const listType = explicitListType || inferredListType || parseArg('listType', 'NOR');
+  const type = hasArg('type')
+    ? parseArg('type', 'HOT')
+    : typeFromLegacyOrderBy(parseArg('orderBy', 'Hot'));
+
+  let status: string;
+  if (hasArg('status')) {
+    status = parseArg('status', 'ALL').toUpperCase();
+  } else {
+    status = listedPancake ? 'TRADE' : 'PUBLISH';
+  }
+
+  const keywordRaw = hasArg('keyword') ? parseArg('keyword', '') : parseArg('tokenName', '');
+  const labelsRaw = hasArg('tag') ? parseArg('tag', '') : parseArg('labels', '');
+  const symbol = parseArg('symbol', '').trim();
+
+  const body: Record<string, unknown> = {
+    type,
+    listType,
+    pageIndex,
+    pageSize,
+    status,
+    sort,
+  };
+
+  if (keywordRaw.trim() !== '') {
+    body.keyword = keywordRaw.trim();
+  }
+  if (symbol !== '') {
+    body.symbol = symbol;
+  }
+  if (labelsRaw.trim() !== '') {
+    body.tag = labelsRaw
+      .split(',')
+      .map((t) => t.trim())
+      .filter(Boolean);
+  }
+  const version = parseArg('version', '').trim();
+  if (version !== '') {
+    body.version = version;
+  }
+
+  const url = `${API_BASE}/public/token/search`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    throw new Error(`token/search failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  console.log(JSON.stringify(data, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

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

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - token rankings (REST API)
+ * 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++) {
+    const arg = process.argv[i];
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length);
+  }
+  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 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 barType = parseArg('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}/public/token/ranking`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    throw new Error(`token/ranking failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  console.log(JSON.stringify(data, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme/four-meme-ai/scripts/verify-events.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * Verification helper: fetch TokenManager2 events for the last N blocks on BSC.
+ * Usage: npx tsx verify-events.ts [blockCount]
+ * Default blockCount 50. No private key or tx, read-only.
+ */
+
+import { createPublicClient, http, parseAbiItem } from 'viem';
+import { bsc } from 'viem/chains';
+
+const TOKEN_MANAGER2_BSC = '0x5c952063c7fc8610FFDB798152D69F0B9550762b' as const;
+const EVENTS = [
+  parseAbiItem(
+    'event TokenCreate(address creator, address token, uint256 requestId, string name, string symbol, uint256 totalSupply, uint256 launchTime, uint256 launchFee)'
+  ),
+  parseAbiItem(
+    'event TokenPurchase(address token, address account, uint256 price, uint256 amount, uint256 cost, uint256 fee, uint256 offers, uint256 funds)'
+  ),
+  parseAbiItem(
+    'event TokenSale(address token, address account, uint256 price, uint256 amount, uint256 cost, uint256 fee, uint256 offers, uint256 funds)'
+  ),
+  parseAbiItem('event LiquidityAdded(address base, uint256 offers, address quote, uint256 funds)'),
+];
+
+async function main() {
+  const blockCount = parseInt(process.argv[2] ?? '50', 10) || 50;
+  const rpcUrl = process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+  const client = createPublicClient({
+    chain: bsc,
+    transport: http(rpcUrl),
+  });
+  const block = await client.getBlockNumber();
+  const fromBlock = block - BigInt(blockCount);
+  const toBlock = block;
+  const logs = await client.getLogs({
+    address: TOKEN_MANAGER2_BSC,
+    events: EVENTS,
+    fromBlock: fromBlock < 0n ? 0n : fromBlock,
+    toBlock,
+  });
+  console.log(JSON.stringify({ fromBlock: String(fromBlock), toBlock: String(toBlock), count: logs.length, events: logs.map((l) => ({ eventName: l.eventName, blockNumber: Number(l.blockNumber), args: l.args })) }, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});