How FOMONIC works

// anyone may call this; the money always goes to the fixed recipients
const pad = new ethers.Contract(LAUNCHPAD, [
  'function claimFees(address token)',
  'function getLaunch(address token) view returns (tuple(address creator,address feeRecipient,address pair,bool coinIs0,bool buyback,bool recipientChanged,bool exists,uint256 feesTok,uint256 feesQuote,uint40 launchedAt))',
], signer);

const info = await pad.getLaunch(coin);
console.log('collected so far:', ethers.utils.formatUnits(info.feesQuote, 6), 'USDC');

await (await pad.claimFees(coin, { gasLimit: 1200000 })).wait();

import { ethers } from 'ethers';

const CHAIN = 5042;
const LAUNCHPAD = '0x50715401ad67c6cfdaf09f71569657c8fdcb3928';
const USDC     = '0x3600000000000000000000000000000000000000';         // 6 decimals, gas on Arc is paid in it
const ROUTER   = '0x6e72061a66419fa96e065c1849d85332a5f42f5a';   // FomonicRouter — buy / sell
const PM       = '0x8366a39cc670b4001a1121b8f6a443a643e40951';   // Uniswap v4 PoolManager
const HOOK     = '0x6336dfa1e077c860d5e13a6ae1c0b7fc5c830088';   // FomonicHook — sets the fee, burns on sells

const provider = new ethers.providers.Web3Provider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer = provider.getSigner();
const me = await signer.getAddress();

// FomonicRouter does the whole swap in one call: it takes USDC, unlocks the pool, and sends
// the coins straight to you. minOut is enforced inside the transaction, so a pool that moved
// reverts instead of filling at a price you never agreed to.
const router = new ethers.Contract(ROUTER, [
  'function buy(address coin, uint256 amountIn, uint256 minOut) payable returns (uint256)',
  'function sell(address coin, uint256 amountIn, uint256 minOut) returns (uint256)',
], signer);

const coin = '0xYourCoinAddress';
const amountIn = ethers.utils.parseUnits('20', 6);        // 20 USDC

// there is no quoter contract on Arc and none is needed: every coin here has one full-range
// position, so L never changes mid-swap and the closed form below is exact, not an estimate.
const t = await fetch(`https://fomonic.fun/api/d/api/token/${coin}`).then((r) => r.json());
const Q96 = ethers.BigNumber.from(2).pow(96);
const P = ethers.BigNumber.from(t.sqrtPriceX96), Lq = ethers.BigNumber.from(t.poolLiq);
const afterFee = amountIn.sub(amountIn.mul(t.feePips).div(1000000));   // 15% pool fee
const P2 = t.isToken0
  ? Lq.mul(Q96).mul(P).div(Lq.mul(Q96).add(afterFee.mul(P)))           // paying currency0
  : P.add(afterFee.mul(Q96).div(Lq));                                  // paying currency1
const out = t.isToken0 ? Lq.mul(P.sub(P2)).div(Q96) : Lq.mul(Q96).mul(P2.sub(P)).div(P2).div(P);
const minOut = out.mul(9700).div(10000);                  // 3% slippage

const usdc = new ethers.Contract(USDC, ['function approve(address,uint256) returns (bool)'], signer);
await (await usdc.approve(ROUTER, amountIn)).wait();

await (await router.buy(coin, amountIn, minOut, { gasLimit: 700000 })).wait();

// A sell is taxed twice before it reaches the pool: the hook burns 2% of the coins going in
// (until 500,000,000 are dead), and then the 15% pool fee applies to what is left. Price the
// trade the same way as a buy, with those two cuts taken off the input first.
const coinC = new ethers.Contract(coin, [
  'function approve(address,uint256) returns (bool)',
  'function balanceOf(address) view returns (uint256)',
], signer);

const amountIn = (await coinC.balanceOf(me)).div(2);      // sell half
await (await coinC.approve(ROUTER, amountIn)).wait();

const afterBurn = amountIn.sub(amountIn.mul(t.sellBurnBps).div(10000));
const netIn = afterBurn.sub(afterBurn.mul(t.feePips).div(1000000));
const P2 = t.isToken0
  ? Lq.mul(Q96).mul(P).div(Lq.mul(Q96).add(netIn.mul(P)))
  : P.add(netIn.mul(Q96).div(Lq));
const usdcOut = t.isToken0 ? Lq.mul(P.sub(P2)).div(Q96) : Lq.mul(Q96).mul(P2.sub(P)).div(P2).div(P);

await (await router.sell(coin, amountIn, usdcOut.mul(9700).div(10000), { gasLimit: 700000 })).wait();

const LAUNCH_ABI = [
  'function launchFee() view returns (uint256)',
  'function launch(string name, string symbol, (string uri,string logo,string description,string website,string twitter,string telegram) meta, bool buyback, address pair, uint256 pairBuyAmount) returns (address)',
];
const usdc = new ethers.Contract(USDC, [
  'function approve(address,uint256) returns (bool)',
  'function allowance(address,address) view returns (uint256)',
], signer);
const pad = new ethers.Contract(LAUNCHPAD, LAUNCH_ABI, signer);

const firstBuy = ethers.utils.parseUnits('25', 6);        // optional, 0 to skip
const fee = await pad.launchFee();
const need = fee.add(firstBuy);
if ((await usdc.allowance(me, LAUNCHPAD)).lt(need)) {
  await (await usdc.approve(LAUNCHPAD, ethers.constants.MaxUint256)).wait();
}

const meta = {
  uri: '', logo: 'ipfs://…', description: 'what this coin is about',
  website: 'https://example.com', twitter: 'https://x.com/handle', telegram: '',
};

// one transaction: deploy the coin, open the pool, seed the whole supply, keep the position
const gas = await pad.estimateGas.launch('My Coin', 'MINE', meta, false, USDC, firstBuy);
const tx = await pad.launch('My Coin', 'MINE', meta, false, USDC, firstBuy, {
  gasLimit: gas.mul(125).div(100),                        // a launch costs ≈6.2M gas
});
const receipt = await tx.wait();
console.log('launched in', receipt.transactionHash);

// price, market cap and the last trades of one coin — no wallet, no key
const r = await fetch('https://fomonic.fun/api/d/api/token/0xYourCoinAddress');
const t = await r.json();

console.log(t.symbol, t.price, t.mc, t.liquidityUsd, t.holders);
t.tradesList.slice(0, 5).forEach((x) =>
  console.log(x.side, Number(x.amountUsdc) / 1e6, 'USDC', x.trader));

// every coin on the launchpad, newest first
const { rows, total } = await fetch('https://fomonic.fun/api/d/api/tokens?sort=new&limit=50').then((r) => r.json());

for (const t of rows) {
  console.log(`$${t.symbol}  ${t.name}  mc $${Math.round(t.mc)}  ${t.trades} trades`);
}
console.log(total, 'coins');

// OHLC candles for a chart: tf = 1m | 5m | 15m | 1h | 4h | 1d
const { rows } = await fetch('https://fomonic.fun/api/d/api/candles/0xYourCoinAddress?tf=5m&limit=300')
  .then((r) => r.json());

// [{ t: unix seconds, o, h, l, c, v }]  — price is USDC per coin
const marketCaps = rows.map((k) => ({ time: k.t, value: k.c * 1e9 }));

// poll the coin list and react to a new launch (the CDN caches for a few seconds)
let seen = new Set();
setInterval(async () => {
  const { rows } = await fetch('https://fomonic.fun/api/d/api/tokens?sort=new&limit=20').then((r) => r.json());
  for (const t of rows.reverse()) {
    if (seen.has(t.address)) continue;
    seen.add(t.address);
    console.log('new coin', t.symbol, t.address, 'mc', t.mc);
  }
}, 5000);

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [{
    chainId: '0x13b2',
    chainName: 'Arc',
    rpcUrls: ['https://fomonic.fun/api/rpc'],
    nativeCurrency: { name: 'USDC', symbol: 'USDC', decimals: 18 },
    blockExplorerUrls: ['https://arc.etherscan.io'],
  }],
});