Build on ApexisRouter

// The address can rotate. Read it at startup instead of hardcoding it.
const res = await fetch('https://www.apexiswap.com/api/developers/router');
const { address, abi, feeBps, dexes } = await res.json();

const enabledDexes = dexes.filter((d) => d.enabled);
// -> [{ id: 1, name: 'APEXISWAP', router: '0x…', wusdc: '0x…', flavour: 'ETH_STYLE', enabled: true }, …]

import { ethers } from 'ethers';

const ROUTER = '0xed32e78cdcd587c90fa104e38209b4512d6d5fd5'; // ApexisRouter
const DEX_ROUTER = '0x1229377adE15278818cD50214456db4b469f6f2b'; // APEXISWAP
const WUSDC = '0x1CCA7CA62bcBFdAB086765f451648d8C7591AECb'; // APEXISWAP's wrapped USDC
const TOKEN = '0x0000000000000000000000000000000000000000'; // APXS

// Only the pieces you call. The full ABI is at https://www.apexiswap.com/api/developers/router
const abi = [
  'function quoteFeeForPath(address[] path, uint256 amountIn) view returns (uint256 fee, uint256 net, uint16 bps)',
  'function swapNativeForTokens(address router, address[] path, uint256 minOut, uint256 deadline) payable',
];
const dexAbi = ['function getAmountsOut(uint256 amountIn, address[] path) view returns (uint256[] amounts)'];

const provider = new ethers.JsonRpcProvider('https://rpc.mainnet.arc.io', 5042);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);
const router = new ethers.Contract(ROUTER, abi, wallet);
const dex = new ethers.Contract(DEX_ROUTER, dexAbi, provider);

const path = [WUSDC, TOKEN];
const amountIn = ethers.parseUnits('10', 18); // native USDC on Arc has 18 decimals

// 1. Ask the router what reaches the pool after its fee. Quote the DEX with NET,
//    not gross: quoting the gross promises more than arrives and the swap reverts.
const { net, bps } = await router.quoteFeeForPath(path, amountIn);
console.log('fee bps for this path:', bps); // 30 normally, 100 for a graduated Pump token

// 2. Quote the DEX with the net amount and apply your slippage tolerance.
const amounts = await dex.getAmountsOut(net, path);
const expectedOut = amounts[amounts.length - 1];
const minOut = (expectedOut * 995n) / 1000n; // 0.5% slippage

// 3. Swap. The fee is skimmed from msg.value; tokens go straight to your wallet.
const deadline = Math.floor(Date.now() / 1000) + 600;
const tx = await router.swapNativeForTokens(DEX_ROUTER, path, minOut, deadline, { value: amountIn });
console.log('sent', tx.hash);
await tx.wait();

import { ethers } from 'ethers';

const ROUTER = '0xed32e78cdcd587c90fa104e38209b4512d6d5fd5';
const DEX_ROUTER = '0x1229377adE15278818cD50214456db4b469f6f2b';
const WUSDC = '0x1CCA7CA62bcBFdAB086765f451648d8C7591AECb';
const TOKEN = '0x0000000000000000000000000000000000000000';

const abi = [
  'function swapTokensForNative(address router, address[] path, uint256 amountIn, uint256 minOut, uint256 deadline)',
];
const erc20 = ['function approve(address spender, uint256 value) returns (bool)'];
const dexAbi = ['function getAmountsOut(uint256 amountIn, address[] path) view returns (uint256[] amounts)'];

const provider = new ethers.JsonRpcProvider('https://rpc.mainnet.arc.io', 5042);
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);
const router = new ethers.Contract(ROUTER, abi, wallet);
const token = new ethers.Contract(TOKEN, erc20, wallet);
const dex = new ethers.Contract(DEX_ROUTER, dexAbi, provider);

const path = [TOKEN, WUSDC];
const amountIn = ethers.parseUnits('1000', 18);

// Approve the FEE ROUTER, not the DEX. The router pulls your tokens, and the DEX
// pays the router so the fee can be taken on the USDC side.
await (await token.approve(ROUTER, amountIn)).wait();

// On a sell the fee comes off the OUTPUT, so quote the DEX with the full input and
// then subtract the fee from the expected output before setting minOut.
const amounts = await dex.getAmountsOut(amountIn, path);
const grossOut = amounts[amounts.length - 1];
const netOut = (grossOut * (10000n - 30n)) / 10000n; // 30 bps, or 100 for a graduated token
const minOut = (netOut * 995n) / 1000n;

const deadline = Math.floor(Date.now() / 1000) + 600;
// minOut is checked against what YOU receive, after the fee.
const tx = await router.swapTokensForNative(DEX_ROUTER, path, amountIn, minOut, deadline);
await tx.wait();

import { createPublicClient, createWalletClient, http, parseAbi, parseUnits } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const arc = {
  id: 5042,
  name: 'Arc',
  nativeCurrency: { name: 'USDC', symbol: 'USDC', decimals: 18 },
  rpcUrls: { default: { http: ['https://rpc.mainnet.arc.io'] } },
} as const;

const ROUTER = '0xed32e78cdcd587c90fa104e38209b4512d6d5fd5' as const;
const DEX_ROUTER = '0x1229377adE15278818cD50214456db4b469f6f2b' as const;
const WUSDC = '0x1CCA7CA62bcBFdAB086765f451648d8C7591AECb' as const;
const TOKEN = '0x0000000000000000000000000000000000000000' as const;

const routerAbi = parseAbi([
  'function quoteFeeForPath(address[] path, uint256 amountIn) view returns (uint256 fee, uint256 net, uint16 bps)',
  'function swapNativeForTokens(address router, address[] path, uint256 minOut, uint256 deadline) payable',
]);
const dexAbi = parseAbi(['function getAmountsOut(uint256 amountIn, address[] path) view returns (uint256[])']);

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const publicClient = createPublicClient({ chain: arc, transport: http() });
const walletClient = createWalletClient({ account, chain: arc, transport: http() });

const path = [WUSDC, TOKEN] as const;
const amountIn = parseUnits('10', 18);

const [, net] = await publicClient.readContract({
  address: ROUTER, abi: routerAbi, functionName: 'quoteFeeForPath', args: [path, amountIn],
});
const amounts = await publicClient.readContract({
  address: DEX_ROUTER, abi: dexAbi, functionName: 'getAmountsOut', args: [net, path],
});
const minOut = (amounts[amounts.length - 1] * 995n) / 1000n;
const deadline = BigInt(Math.floor(Date.now() / 1000) + 600);

const hash = await walletClient.writeContract({
  address: ROUTER, abi: routerAbi, functionName: 'swapNativeForTokens',
  args: [DEX_ROUTER, path, minOut, deadline], value: amountIn,
});
await publicClient.waitForTransactionReceipt({ hash });

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://rpc.mainnet.arc.io', 5042);
const router = new ethers.Contract('0xed32e78cdcd587c90fa104e38209b4512d6d5fd5', [
  'event SwapExecuted(address indexed user, address indexed router, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut, address feeToken, uint256 feeAmount)',
], provider);

// amountOut is the recipient's measured balance delta, so it is truthful even for
// fee-on-transfer tokens. feeToken is address(0) when the fee was taken in native USDC.
router.on('SwapExecuted', (user, dexRouter, tokenIn, tokenOut, amountIn, amountOut, feeToken, feeAmount) => {
  console.log({ user, dexRouter, tokenIn, tokenOut, amountIn, amountOut, feeToken, feeAmount });
});