@four-meme/four-meme-ai 1.0.0

package/skills/four-meme-integration/scripts/create-token-chain.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - submit createToken tx on BSC (TokenManager2.createToken).
+ * Uses createArg and signature from create-token-api.ts output.
+ *
+ * Usage:
+ *   npx tsx create-token-chain.ts <createArgHex> <signatureHex>
+ *   echo '{"createArg":"0x...","signature":"0x..."}' | npx tsx create-token-chain.ts --
+ *
+ * Env: PRIVATE_KEY or FOURMEME_PRIVATE_KEY. Optional: BSC_RPC_URL.
+ */
+
+import { createWalletClient, http, parseAbi } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { bsc } from 'viem/chains';
+
+const TOKEN_MANAGER2_BSC = '0x5c952063c7fc8610FFDB798152D69F0B9550762b' as const;
+
+const ABI = parseAbi([
+  'function createToken(bytes args, bytes signature) payable',
+]);
+
+function toHex(s: string): `0x${string}` {
+  if (s.startsWith('0x')) return s as `0x${string}`;
+  if (/^[0-9a-fA-F]+$/.test(s)) return ('0x' + s) as `0x${string}`;
+  const buf = Buffer.from(s, 'base64');
+  return ('0x' + buf.toString('hex')) as `0x${string}`;
+}
+
+async function main() {
+  const privateKey = process.env.PRIVATE_KEY || process.env.FOURMEME_PRIVATE_KEY;
+  if (!privateKey) {
+    console.error('Set PRIVATE_KEY or FOURMEME_PRIVATE_KEY');
+    process.exit(1);
+  }
+  const pk = privateKey.startsWith('0x') ? (privateKey as `0x${string}`) : (`0x${privateKey}` as `0x${string}`);
+  const account = privateKeyToAccount(pk);
+
+  let createArgHex: `0x${string}`;
+  let signatureHex: `0x${string}`;
+
+  const arg1 = process.argv[2];
+  if (arg1 === '--' || !arg1) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+    const json = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    createArgHex = toHex(json.createArg);
+    signatureHex = toHex(json.signature);
+  } else {
+    const arg2 = process.argv[3];
+    if (!arg2) {
+      console.error('Usage: npx tsx create-token-chain.ts <createArgHex> <signatureHex>');
+      console.error('   or: echo \'{"createArg":"0x...","signature":"0x..."}\' | npx tsx create-token-chain.ts --');
+      process.exit(1);
+    }
+    createArgHex = toHex(arg1);
+    signatureHex = toHex(arg2);
+  }
+
+  const rpcUrl = process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+  const client = createWalletClient({
+    account,
+    chain: bsc,
+    transport: http(rpcUrl),
+  });
+
+  const creationFeeWei = process.env.CREATION_FEE_WEI
+    ? BigInt(process.env.CREATION_FEE_WEI)
+    : 0n;
+
+  const hash = await client.writeContract({
+    address: TOKEN_MANAGER2_BSC,
+    abi: ABI,
+    functionName: 'createToken',
+    args: [createArgHex, signatureHex],
+    value: creationFeeWei,
+  });
+
+  console.log(JSON.stringify({ txHash: hash }, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme-integration/scripts/execute-buy.ts

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - execute buy on TokenManager2 (BSC only).
+ * Usage:
+ *   npx tsx execute-buy.ts <tokenAddress> amount <amountWei> <maxFundsWei>   # buy fixed token amount
+ *   npx tsx execute-buy.ts <tokenAddress> funds <fundsWei> <minAmountWei>   # spend fixed quote (e.g. BNB)
+ * Env: PRIVATE_KEY or FOURMEME_PRIVATE_KEY. Only V2 tokens (version 2 from getTokenInfo).
+ */
+
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { bsc } from 'viem/chains';
+
+const HELPER_ADDRESS = '0xF251F83e40a78868FcfA3FA4599Dad6494E46034' as const;
+const ZERO = '0x0000000000000000000000000000000000000000' as const;
+
+const HELPER_ABI = [
+  {
+    name: 'getTokenInfo',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'token', type: 'address' }],
+    outputs: [
+      { name: 'version', type: 'uint256' },
+      { name: 'tokenManager', type: 'address' },
+      { name: 'quote', type: 'address' },
+      { name: 'lastPrice', type: 'uint256' },
+      { name: 'tradingFeeRate', type: 'uint256' },
+      { name: 'minTradingFee', type: 'uint256' },
+      { name: 'launchTime', type: 'uint256' },
+      { name: 'offers', type: 'uint256' },
+      { name: 'maxOffers', type: 'uint256' },
+      { name: 'funds', type: 'uint256' },
+      { name: 'maxFunds', type: 'uint256' },
+      { name: 'liquidityAdded', type: 'bool' },
+    ],
+  },
+  {
+    name: 'tryBuy',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'funds', type: 'uint256' },
+    ],
+    outputs: [
+      { name: 'tokenManager', type: 'address' },
+      { name: 'quote', type: 'address' },
+      { name: 'estimatedAmount', type: 'uint256' },
+      { name: 'estimatedCost', type: 'uint256' },
+      { name: 'estimatedFee', type: 'uint256' },
+      { name: 'amountMsgValue', type: 'uint256' },
+      { name: 'amountApproval', type: 'uint256' },
+      { name: 'amountFunds', type: 'uint256' },
+    ],
+  },
+] as const;
+
+const TM2_ABI = [
+  {
+    name: 'buyToken',
+    type: 'function',
+    stateMutability: 'payable',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'maxFunds', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+  {
+    name: 'buyTokenAMAP',
+    type: 'function',
+    stateMutability: 'payable',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'funds', type: 'uint256' },
+      { name: 'minAmount', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+] as const;
+
+const ERC20_ABI = [
+  {
+    name: 'approve',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
+] as const;
+
+const RPC_URL = process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+
+async function main() {
+  const pk = process.env.PRIVATE_KEY || process.env.FOURMEME_PRIVATE_KEY;
+  if (!pk) {
+    console.error('Set PRIVATE_KEY or FOURMEME_PRIVATE_KEY');
+    process.exit(1);
+  }
+  const account = privateKeyToAccount(
+    (pk.startsWith('0x') ? pk : '0x' + pk) as `0x${string}`
+  );
+
+  const tokenAddress = process.argv[2] as `0x${string}`;
+  const mode = process.argv[3]; // 'amount' | 'funds'
+  const arg1 = process.argv[4];
+  const arg2 = process.argv[5];
+
+  if (!tokenAddress || !mode || !arg1 || !arg2) {
+    console.error('Usage:');
+    console.error('  execute-buy.ts <token> amount <amountWei> <maxFundsWei>');
+    console.error('  execute-buy.ts <token> funds <fundsWei> <minAmountWei>');
+    process.exit(1);
+  }
+
+  const publicClient = createPublicClient({
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+  const walletClient = createWalletClient({
+    account,
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+
+  const [version, tokenManager, quote] = await publicClient.readContract({
+    address: HELPER_ADDRESS,
+    abi: HELPER_ABI,
+    functionName: 'getTokenInfo',
+    args: [tokenAddress],
+  }).then((r) => [r[0], r[1], r[2]] as const);
+
+  if (Number(version) !== 2) {
+    console.error('Only TokenManager2 (V2) tokens are supported. This token is version', version);
+    process.exit(1);
+  }
+
+  const amountWei = mode === 'amount' ? BigInt(arg1) : 0n;
+  const maxFundsWei = mode === 'amount' ? BigInt(arg2) : 0n;
+  const fundsWei = mode === 'funds' ? BigInt(arg1) : 0n;
+  const minAmountWei = mode === 'funds' ? BigInt(arg2) : 0n;
+
+  const tryBuyResult = await publicClient.readContract({
+    address: HELPER_ADDRESS,
+    abi: HELPER_ABI,
+    functionName: 'tryBuy',
+    args: [tokenAddress, amountWei, fundsWei],
+  });
+  const amountMsgValue = tryBuyResult[5];
+  const amountApproval = tryBuyResult[6];
+
+  if (quote !== ZERO && amountApproval > 0n) {
+    const approveHash = await walletClient.writeContract({
+      address: quote,
+      abi: ERC20_ABI,
+      functionName: 'approve',
+      args: [tokenManager, amountApproval],
+    });
+    console.error('Approved quote token. Tx:', approveHash);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: approveHash });
+    if (receipt.status !== 'success') {
+      console.error('Approve failed');
+      process.exit(1);
+    }
+  }
+
+  let hash: `0x${string}`;
+  if (mode === 'amount') {
+    hash = await walletClient.writeContract({
+      address: tokenManager as `0x${string}`,
+      abi: TM2_ABI,
+      functionName: 'buyToken',
+      args: [tokenAddress, amountWei, maxFundsWei],
+      value: amountMsgValue,
+    });
+  } else {
+    hash = await walletClient.writeContract({
+      address: tokenManager as `0x${string}`,
+      abi: TM2_ABI,
+      functionName: 'buyTokenAMAP',
+      args: [tokenAddress, fundsWei, minAmountWei],
+      value: amountMsgValue,
+    });
+  }
+
+  console.log(JSON.stringify({ txHash: hash }, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme-integration/scripts/execute-sell.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - execute sell on TokenManager2 (BSC only).
+ * Usage: npx tsx execute-sell.ts <tokenAddress> <amountWei> [minFundsWei]
+ * Env: PRIVATE_KEY or FOURMEME_PRIVATE_KEY. Sends approve(tokenManager, amount) then sellToken(token, amount).
+ */
+
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { bsc } from 'viem/chains';
+
+const HELPER_ADDRESS = '0xF251F83e40a78868FcfA3FA4599Dad6494E46034' as const;
+
+const HELPER_ABI = [
+  {
+    name: 'getTokenInfo',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'token', type: 'address' }],
+    outputs: [
+      { name: 'version', type: 'uint256' },
+      { name: 'tokenManager', type: 'address' },
+      { name: 'quote', type: 'address' },
+      { name: 'lastPrice', type: 'uint256' },
+      { name: 'tradingFeeRate', type: 'uint256' },
+      { name: 'minTradingFee', type: 'uint256' },
+      { name: 'launchTime', type: 'uint256' },
+      { name: 'offers', type: 'uint256' },
+      { name: 'maxOffers', type: 'uint256' },
+      { name: 'funds', type: 'uint256' },
+      { name: 'maxFunds', type: 'uint256' },
+      { name: 'liquidityAdded', type: 'bool' },
+    ],
+  },
+] as const;
+
+const TM2_ABI_SIMPLE = [
+  {
+    name: 'sellToken',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+] as const;
+
+const TM2_ABI_WITH_MIN_FUNDS = [
+  {
+    name: 'sellToken',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'origin', type: 'uint256' },
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'minFunds', type: 'uint256' },
+    ],
+    outputs: [],
+  },
+] as const;
+
+const ERC20_ABI = [
+  {
+    name: 'approve',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
+] as const;
+
+const RPC_URL = process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+
+async function main() {
+  const pk = process.env.PRIVATE_KEY || process.env.FOURMEME_PRIVATE_KEY;
+  if (!pk) {
+    console.error('Set PRIVATE_KEY or FOURMEME_PRIVATE_KEY');
+    process.exit(1);
+  }
+  const account = privateKeyToAccount(
+    (pk.startsWith('0x') ? pk : '0x' + pk) as `0x${string}`
+  );
+
+  const tokenAddress = process.argv[2] as `0x${string}`;
+  const amountWei = BigInt(process.argv[3] ?? '0');
+  const minFundsWei = process.argv[4] ? BigInt(process.argv[4]) : null;
+
+  if (!tokenAddress || amountWei <= 0n) {
+    console.error('Usage: npx tsx execute-sell.ts <tokenAddress> <amountWei> [minFundsWei]');
+    process.exit(1);
+  }
+
+  const publicClient = createPublicClient({
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+  const walletClient = createWalletClient({
+    account,
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+
+  const [, tokenManager] = await publicClient.readContract({
+    address: HELPER_ADDRESS,
+    abi: HELPER_ABI,
+    functionName: 'getTokenInfo',
+    args: [tokenAddress],
+  }).then((r) => [r[0], r[1]] as const);
+
+  const approveHash = await walletClient.writeContract({
+    address: tokenAddress,
+    abi: ERC20_ABI,
+    functionName: 'approve',
+    args: [tokenManager as `0x${string}`, amountWei],
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash: approveHash });
+  if (receipt.status !== 'success') {
+    console.error('Approve failed');
+    process.exit(1);
+  }
+
+  const tm2 = tokenManager as `0x${string}`;
+  const hash: `0x${string}` =
+    minFundsWei !== null
+      ? await walletClient.writeContract({
+          address: tm2,
+          abi: TM2_ABI_WITH_MIN_FUNDS,
+          functionName: 'sellToken',
+          args: [0n, tokenAddress, amountWei, minFundsWei],
+        })
+      : await walletClient.writeContract({
+          address: tm2,
+          abi: TM2_ABI_SIMPLE,
+          functionName: 'sellToken',
+          args: [tokenAddress, amountWei],
+        });
+
+  console.log(JSON.stringify({ txHash: hash }, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme-integration/scripts/get-public-config.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - fetch public config (raisedToken for create-token API)
+ * Usage: npx tsx skills/four-meme-integration/scripts/get-public-config.ts
+ * Output: JSON with raisedToken and other config (use raisedToken in create body as-is).
+ */
+
+const API_BASE = 'https://four.meme/meme-api/v1';
+
+async function main() {
+  const res = await fetch(`${API_BASE}/public/config`);
+  if (!res.ok) {
+    throw new Error(`Config request failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  if (data.code !== '0' && data.code !== 0) {
+    throw new Error(`Config error: ${JSON.stringify(data)}`);
+  }
+  console.log(JSON.stringify(data.data ?? data, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme-integration/scripts/get-recent-events.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - get TokenCreate, TokenPurchase, TokenSale, LiquidityAdded from TokenManager2 (V2 only).
+ * Usage: npx tsx get-recent-events.ts <chainId> <fromBlock> [toBlock]
+ * If toBlock omitted, uses "latest". chainId 56 = BSC (TokenManager2 on BSC only for create; events on BSC).
+ */
+
+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)'),
+];
+
+function getRpcUrl(chainId: number): string {
+  if (chainId !== 56) {
+    console.error('Events are only on BSC (chainId 56). TokenManager2 is on BSC.');
+    process.exit(1);
+  }
+  return process.env.BSC_RPC_URL || 'https://bsc-dataseed.binance.org';
+}
+
+async function main() {
+  const chainId = parseInt(process.argv[2], 10);
+  const fromBlock = process.argv[3];
+  const toBlock = process.argv[4]; // optional, "latest" if omitted
+
+  if (!chainId || isNaN(chainId) || chainId !== 56 || !fromBlock) {
+    console.error('Usage: npx tsx get-recent-events.ts 56 <fromBlock> [toBlock]');
+    console.error('Example: npx tsx get-recent-events.ts 56 45000000 45000100');
+    process.exit(1);
+  }
+
+  const client = createPublicClient({
+    chain: bsc,
+    transport: http(getRpcUrl(chainId)),
+  });
+
+  const fromBlockBigInt = fromBlock === 'latest' ? 'latest' : BigInt(fromBlock);
+  const toBlockOpt: 'latest' | bigint | undefined = !toBlock
+    ? undefined
+    : toBlock === 'latest'
+      ? 'latest'
+      : BigInt(toBlock);
+
+  const logs = await client.getLogs({
+    address: TOKEN_MANAGER2_BSC,
+    events: EVENTS,
+    fromBlock: fromBlockBigInt,
+    ...(toBlockOpt !== undefined && { toBlock: toBlockOpt }),
+  });
+
+  const out = logs.map((log) => ({
+    eventName: log.eventName,
+    blockNumber: Number(log.blockNumber),
+    transactionHash: log.transactionHash,
+    args: log.args as object,
+  }));
+  console.log(JSON.stringify(out, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme-integration/scripts/get-tax-token-info.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - query TaxToken contract for fee/tax config (BSC only).
+ * Only works for TaxToken type (creatorType 5). Usage: npx tsx get-tax-token-info.ts <tokenAddress>
+ */
+
+import { createPublicClient, http } from 'viem';
+import { bsc } from 'viem/chains';
+
+const TAX_TOKEN_ABI = [
+  { name: 'feeRate', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'rateFounder', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'rateHolder', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'rateBurn', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'rateLiquidity', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'minDispatch', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'minShare', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'quote', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+  { name: 'founder', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+] 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}`;
+
+  if (!tokenAddress) {
+    console.error('Usage: npx tsx get-tax-token-info.ts <tokenAddress>');
+    console.error('BSC only. Token must be TaxToken type.');
+    process.exit(1);
+  }
+
+  const client = createPublicClient({
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+
+  const [feeRate, rateFounder, rateHolder, rateBurn, rateLiquidity, minDispatch, minShare, quote, founder] =
+    await Promise.all([
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'feeRate' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'rateFounder' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'rateHolder' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'rateBurn' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'rateLiquidity' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'minDispatch' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'minShare' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'quote' }),
+      client.readContract({ address: tokenAddress, abi: TAX_TOKEN_ABI, functionName: 'founder' }),
+    ]);
+
+  const out = {
+    feeRateBps: Number(feeRate),
+    feeRatePercent: Number(feeRate) / 100,
+    rateFounder: Number(rateFounder),
+    rateHolder: Number(rateHolder),
+    rateBurn: Number(rateBurn),
+    rateLiquidity: Number(rateLiquidity),
+    minDispatch: minDispatch.toString(),
+    minShare: minShare.toString(),
+    quote: quote === '0x0000000000000000000000000000000000000000' ? null : quote,
+    founder: founder === '0x0000000000000000000000000000000000000000' ? null : founder,
+  };
+  console.log(JSON.stringify(out, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/skills/four-meme-integration/scripts/get-token-info.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * Four.meme - get token info via TokenManagerHelper3 (BSC only).
+ * Usage: npx tsx get-token-info.ts <tokenAddress>
+ */
+
+import { createPublicClient, http } from 'viem';
+import { bsc } from 'viem/chains';
+
+const HELPER_ADDRESS = '0xF251F83e40a78868FcfA3FA4599Dad6494E46034' as const;
+
+const HELPER_ABI = [
+  {
+    name: 'getTokenInfo',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'token', type: 'address' }],
+    outputs: [
+      { name: 'version', type: 'uint256' },
+      { name: 'tokenManager', type: 'address' },
+      { name: 'quote', type: 'address' },
+      { name: 'lastPrice', type: 'uint256' },
+      { name: 'tradingFeeRate', type: 'uint256' },
+      { name: 'minTradingFee', type: 'uint256' },
+      { name: 'launchTime', type: 'uint256' },
+      { name: 'offers', type: 'uint256' },
+      { name: 'maxOffers', type: 'uint256' },
+      { name: 'funds', type: 'uint256' },
+      { name: 'maxFunds', type: 'uint256' },
+      { name: 'liquidityAdded', type: 'bool' },
+    ],
+  },
+] 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}`;
+
+  if (!tokenAddress) {
+    console.error('Usage: npx tsx get-token-info.ts <tokenAddress>');
+    console.error('BSC only.');
+    process.exit(1);
+  }
+
+  const client = createPublicClient({
+    chain: bsc,
+    transport: http(RPC_URL),
+  });
+
+  const helperAddress = HELPER_ADDRESS;
+  const result = await client.readContract({
+    address: helperAddress,
+    abi: HELPER_ABI,
+    functionName: 'getTokenInfo',
+    args: [tokenAddress],
+  });
+
+  const [
+    version,
+    tokenManager,
+    quote,
+    lastPrice,
+    tradingFeeRate,
+    minTradingFee,
+    launchTime,
+    offers,
+    maxOffers,
+    funds,
+    maxFunds,
+    liquidityAdded,
+  ] = result;
+
+  const out = {
+    version: Number(version),
+    tokenManager,
+    quote: quote === '0x0000000000000000000000000000000000000000' ? null : quote,
+    lastPrice: lastPrice.toString(),
+    tradingFeeRate: Number(tradingFeeRate) / 10000,
+    minTradingFee: minTradingFee.toString(),
+    launchTime: Number(launchTime),
+    offers: offers.toString(),
+    maxOffers: maxOffers.toString(),
+    funds: funds.toString(),
+    maxFunds: maxFunds.toString(),
+    liquidityAdded,
+  };
+  console.log(JSON.stringify(out, null, 2));
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});