# ABI Source: https://docs.inkyswap.com/api-reference/contracts/abi Function signatures, event topics, and call data for the InkyPump V2 hook. This page lists the public surface of the InkyPump V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`. Signatures match the deployed implementation. ## Write functions ```solidity theme={null} function createLaunch(InkyPumpTypes.CreateLaunchParams calldata params) external payable returns (uint256 launchId); function createLaunchWithReferral( InkyPumpTypes.CreateLaunchParams calldata params, string calldata referralCode ) external payable returns (uint256 launchId); function buy( uint256 launchId, uint256 minTokensOut, InkyPumpTypes.CaptchaAuth calldata captcha ) external payable returns (uint256 tokensOut); function buyWithReferral( uint256 launchId, uint256 minTokensOut, InkyPumpTypes.CaptchaAuth calldata captcha, string calldata referralCode ) external payable returns (uint256 tokensOut); function sell( uint256 launchId, uint128 tokenAmount, uint256 minEthOut, InkyPumpTypes.CaptchaAuth calldata captcha ) external returns (uint256 payout); function sellWithReferral( uint256 launchId, uint128 tokenAmount, uint256 minEthOut, InkyPumpTypes.CaptchaAuth calldata captcha, string calldata referralCode ) external returns (uint256 payout); function updateCreatorFeeSplit(uint256 launchId, uint16 newSplitBps) external; function withdrawFees() external; function executeAccumulatedBuyback(uint256 launchId) external; ``` ## Read functions ### On the hook (`0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`) ```solidity theme={null} function getLaunchState(uint256 launchId) external view returns (InkyPumpTypes.LaunchConfig memory); function withdrawableFees(address account) external view returns (uint256); function accumulatedBuyback(uint256 launchId) external view returns (uint256); function viewer() external view returns (address); function tradingModule() external view returns (address); ``` ### On `LaunchViewModule` (`0xce83E3659251116d114Ec1CA729ffB49B99403c3`) The hook also has `previewBuy(uint256,uint256)` and `previewSell(uint256,uint128)` wrappers that delegate to the configured viewer contract. Use the view module functions below directly for the working preview path. See [Quotes](/api-reference/contracts/quotes) for the full pattern. ```solidity theme={null} function previewBuyLocal( uint128 saleSupply, uint96 targetRaise, uint32 gainBps, uint128 sold, uint128 remaining, uint256 ethIn ) external pure returns ( uint256 tokensOut, uint256 cost, uint256 refund, uint256 tokensRemaining ); function previewSellLocal( uint128 saleSupply, uint96 targetRaise, uint32 gainBps, uint128 sold, uint128 tokenAmount, uint128 netContributions, uint16 creatorFeeSplitBps, uint16 protocolFeeBps, uint16 variableFeeBps, uint16 bpsDenominator ) external pure returns ( uint256 netPayout, uint256 protocolFee, uint256 creatorFee, uint256 buybackFee ); function previewSaleSplit(uint96 targetRaise, uint32 gainBps) external view returns ( uint128 saleSupply, uint128 liquiditySupply, uint16 salePortionBps, uint256 marginalPrice, uint256 poolPrice ); ``` ## Events ```solidity theme={null} event LaunchCreated( uint256 indexed launchId, address indexed creator, address token, uint96 targetRaise ); event LaunchMetadata( uint256 indexed launchId, string name, string ticker, string description, string imageUrl, string telegram, string twitter, string website ); event Trade( uint256 indexed launchId, address indexed trader, TradeType tradeType, PriceData priceData, TradeData tradeData, uint256 refund ); event Referral( uint256 indexed launchId, address indexed trader, string referralCode ); event LaunchFinalized( uint256 indexed launchId, PoolId poolId, uint256 liquidityEth, uint256 liquidityTokens ); event BuybackExecuted( uint256 indexed launchId, uint128 tokensBurned, uint256 ethSpent ); event CreatorFeeSplitUpdated(uint256 indexed launchId, uint16 splitBps); event SalePortionResolved( uint256 indexed launchId, uint16 salePortionBps, uint256 marginalPrice, uint256 poolPrice ); event FeeAccrued(address indexed recipient, uint256 amount); event FeeWithdrawn(address indexed recipient, uint256 amount); ``` ## Event topic hashes For direct log subscription, these are the topic hashes (keccak256 of the canonical signature): | Event | Topic hash | | ---------------------------------- | -------------------------------------------------------------------- | | `Referral(uint256,address,string)` | `0x796dfbc4bdc1de15340f520a4b17fb287a10b2f6c50e702ee8dc9fa2c714dfc5` | Other topic hashes can be computed locally with `cast keccak256 "EventName(args)"`. ## Struct shapes ```solidity theme={null} struct CreateLaunchParams { string name; string ticker; string description; string imageUrl; string telegram; string twitter; string website; uint16 creatorFeeSplitBps; // 0 to 10000 uint32 gainBps; // 0 to 200000 (1x to 21x) uint96 targetRaise; // 1 to 5 ether uint32 antiSnipeDuration; // 0, 20, 40, or 60 seconds (UI restricted) uint64 startTime; // 0 for immediate, future timestamp for scheduled } // Note: there is no `prebuyEth` field. To prebuy at launch, send the prebuy amount // as `msg.value` on the `createLaunch` call. struct CaptchaAuth { uint256 deadline; bytes signature; } struct LaunchConfig { // see InkyPumpTypes.sol for the full layout uint64 launchTimestamp; uint32 antiSnipeDuration; uint16 creatorFeeSplitBps; // ... other fields including the token address, finalized flag, etc. } ``` For the full struct definitions in source, see `pump-contracts-v2/src/libraries/InkyPumpTypes.sol`. # Integration Guide Source: https://docs.inkyswap.com/api-reference/contracts/integration-guide End to end V2 integration. Setup, launching, trading, listening for events. This guide walks through integrating the InkyPump V2 hook into a JavaScript or TypeScript application. Examples use viem. The same calls work with ethers, web3.js, or any other library. ## Setup ```javascript theme={null} import { createPublicClient, createWalletClient, http, parseEther } from "viem" import { privateKeyToAccount } from "viem/accounts" const INK_MAINNET = { id: 57073, name: "Ink", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }, rpcUrls: { default: { http: ["https://rpc-gel.inkonchain.com"] } }, } const HOOK = "0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4" const publicClient = createPublicClient({ chain: INK_MAINNET, transport: http() }) const account = privateKeyToAccount(process.env.PRIVATE_KEY) const walletClient = createWalletClient({ account, chain: INK_MAINNET, transport: http() }) ``` The hook ABI is published as part of the InkyPump SDK or can be pulled from the [ABI page](/api-reference/contracts/abi). ## Read launch state ```javascript theme={null} const state = await publicClient.readContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "getLaunchState", args: [launchId], }) console.log("Finalized:", state.finalized) console.log("Target raise:", state.targetRaise) console.log("Tokens remaining on curve:", state.tokensRemaining) ``` If `state.finalized` is true, the token has bonded. Route trades through the V4 pool instead. ## Preview a buy Previews use the `LaunchViewModule` at `0xce83E3659251116d114Ec1CA729ffB49B99403c3` with state read from `getLaunchState`. The hook also exposes wrapper preview functions, but the working path used by the InkyPump frontend is the view module call below. ```javascript theme={null} const LAUNCH_VIEW_MODULE = "0xce83E3659251116d114Ec1CA729ffB49B99403c3" const state = await publicClient.readContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "getLaunchState", args: [launchId], }) const { tokensOut, cost, refund, tokensRemaining } = await publicClient.readContract({ address: LAUNCH_VIEW_MODULE, abi: LAUNCH_VIEW_MODULE_ABI, functionName: "previewBuyLocal", args: [ state.saleSupply, state.targetRaise, state.gainBps, state.sold, state.saleSupply - state.sold, // remaining parseEther("0.1"), // ethIn ], }) const minTokensOut = (tokensOut * 99n) / 100n // 1 percent slippage ``` ## Execute a buy ```javascript theme={null} const captcha = await fetchCaptchaFromBackend({ launchId, account: account.address }) const hash = await walletClient.writeContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "buy", args: [launchId, minTokensOut, captcha], value: parseEther("0.1"), }) const receipt = await publicClient.waitForTransactionReceipt({ hash }) ``` For trades after the anti-snipe window has passed, the captcha argument can be empty: ```javascript theme={null} const emptyCaptcha = { deadline: 0n, signature: "0x" } ``` ## Listen for events ```javascript theme={null} import { parseAbiItem } from "viem" const tradeEvent = parseAbiItem( "event Trade(uint256 indexed launchId, address indexed trader, uint8 tradeType, (uint256 priceAfter, uint256 marketCap) priceData, (uint256 ethAmount, uint256 tokenAmount, uint256 fee) tradeData, uint256 refund)" ) const unwatch = publicClient.watchEvent({ address: HOOK, event: tradeEvent, onLogs: (logs) => { for (const log of logs) { console.log("Trade:", log.args) } }, }) ``` For referral events: ```javascript theme={null} const referralEvent = parseAbiItem( "event Referral(uint256 indexed launchId, address indexed trader, string referralCode)" ) ``` ## Create a launch ```javascript theme={null} const params = { name: "My Token", ticker: "MINE", description: "...", imageUrl: "https://...", telegram: "", twitter: "", website: "", creatorFeeSplitBps: 7000, gainBps: 50_000, targetRaise: parseEther("3"), antiSnipeDuration: 40, startTime: 0n, } // To prebuy, pass `value: parseEther("0.1")` (or any amount) on the writeContract call below. const hash = await walletClient.writeContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "createLaunch", args: [params], value: 0n, }) const receipt = await publicClient.waitForTransactionReceipt({ hash }) // Parse the LaunchCreated event from receipt.logs to get the launchId and token address ``` ## Withdraw creator fees ```javascript theme={null} const hash = await walletClient.writeContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "withdrawFees", }) ``` The hook sends your accrued ETH balance to the caller. ## After bonding Once `getLaunchState` returns `finalized: true`, trade through the Uniswap Universal Router at `0x551134e92e537cEAa217c2ef63210Af3CE96a065`. The pool fee is 0.1 percent. Use the V4 Quoter for previews. For the pool key, derive it from the token and WETH: ```javascript theme={null} const poolKey = { currency0: tokenAddress < WETH ? tokenAddress : WETH, currency1: tokenAddress < WETH ? WETH : tokenAddress, fee: 1_000, tickSpacing: 60, hooks: HOOK, } ``` The Universal Router takes a path encoded against this pool key. See the [Uniswap V4 router docs](https://docs.uniswap.org/contracts/v4/overview) for the full encoding. ## Where to test For a quick read-only test against the live system, read a launch state: ```bash theme={null} cast call 0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4 \ "getLaunchState(uint256)" \ $LAUNCH_ID \ --rpc-url https://rpc-gel.inkonchain.com ``` If the call returns a hex blob (the encoded `LaunchConfig`) without reverting, your setup is talking to the live hook correctly. ## Doing this from your editor The [InkyPump MCP server](/api-reference/mcp) wraps the hook so you can call these functions through Claude Code or Codex without writing the integration yourself. Useful for one off launches and testing. # Overview Source: https://docs.inkyswap.com/api-reference/contracts/overview InkyPump V2 contract addresses, architecture, and where each module lives. This section covers the V2 contracts on Ink mainnet. For V1 contracts, see [Legacy Contracts](/legacy/contracts). ## Addresses on Ink mainnet (chain 57073) | Contract | Address | | ----------------------------- | -------------------------------------------- | | InkyPumpHook (proxy) | `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` | | LaunchViewModule | `0xce83E3659251116d114Ec1CA729ffB49B99403c3` | | SaleSplitCalculator | `0xF665c51026e4c35Bbc4FC91F00c7A4b10089ED1f` | | PoolManager (Uniswap V4) | `0x360E68faCcca8cA495c1B759Fd9EEe466db9FB32` | | Universal Router (Uniswap V4) | `0x551134e92e537cEAa217c2ef63210Af3CE96a065` | | Quoter (Uniswap V4) | `0x3972C00f7ed4885e145823eb7C655375d275A1C5` | | StateView (Uniswap V4) | `0x76Fd297e2D437cd7f76d50F01AfE6160f86e9990` | | Position Manager (Uniswap V4) | `0x1b35d13a2E2528f192637F14B05f0Dc0e7dEB566` | | Permit2 | `0x000000000022D473030F116dDEE9F6B43aC78BA3` | | WETH | `0x4200000000000000000000000000000000000006` | ## Architecture V2 splits the launch system into a UUPS proxy plus separate stateless modules. The proxy holds state and routes calls. The modules implement the logic. ``` InkyPumpHook (proxy, holds state) ├── delegates trading logic to LaunchTradingModule ├── delegates view / preview logic to LaunchViewModule └── state lives in LaunchSharedState Helpers: SaleSplitCalculator (decides sale supply vs liquidity supply per launch) LaunchAccounting (computes fee splits) LinearBondingCurve (forward and inverse curve math) ``` Modules are stateless and swappable. An admin can deploy a new `LaunchTradingModule` and point the proxy at it through `configureModules`, without redeploying the hook itself. ## Why modular * Bug fixes ship as a module redeploy without touching the proxy or its state * Each module can be audited independently * New features (like the referral variants of buy and sell) added by upgrading the trading module ## Common integration entry points | What you want to do | What to call | | ------------------------ | ------------------------------------------------------------------------------- | | Launch a token | `createLaunch` or `createLaunchWithReferral` on the hook | | Buy on the curve | `buy` or `buyWithReferral` on the hook | | Sell on the curve | `sell` or `sellWithReferral` on the hook | | Preview a buy | `previewBuyLocal(...)` on `LaunchViewModule`, with state from `getLaunchState` | | Preview a sell | `previewSellLocal(...)` on `LaunchViewModule`, with state from `getLaunchState` | | Read launch state | `getLaunchState(launchId)` on the hook | | Update creator fee split | `updateCreatorFeeSplit(launchId, newSplitBps)` on the hook | | Withdraw accrued fees | `withdrawFees()` on the hook | | Swap a bonded token | Uniswap Universal Router on the V4 pool | ## Constants From `LaunchSharedState.sol`: ```solidity theme={null} uint256 public constant TOTAL_SUPPLY = 1_000_000_000 ether; uint256 public constant MIN_RAISE = 1 ether; uint256 public constant MAX_RAISE = 5 ether; uint32 public constant MAX_GAIN_BPS = 200_000; // 21x ceiling uint256 public constant MIN_BUY_ETH = 0.00001 ether; uint128 public constant MIN_SELL_TOKENS = 1 ether; uint256 public constant PROTOCOL_FEE_BPS = 100; // 1 percent uint256 public constant VARIABLE_FEE_BPS = 100; // 1 percent uint256 public constant BPS_DENOMINATOR = 10_000; uint24 public constant POOL_FEE = 1_000; // 0.1 percent on V4 pool ``` ## Where to next Function signatures and event topics. createLaunch and createLaunchWithReferral. buy, sell, and the referral variants. Preview functions for buys, sells, and sale splits. End to end integration walkthrough. V1 contract addresses. Always verify contract addresses before calling. The proxy at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` is the only V2 entry point. If you see a different address claiming to be the V2 hook, treat it as untrusted. # Quotes Source: https://docs.inkyswap.com/api-reference/contracts/quotes Read-only preview functions for buys, sells, and sale split calculations. The preview functions live on the `LaunchViewModule` at `0xce83E3659251116d114Ec1CA729ffB49B99403c3`. They are pure, free to call, and take local launch state as parameters. The pattern is: read launch state from the hook, pass it to the view module. After bonding, use the Uniswap V4 Quoter at `0x3972C00f7ed4885e145823eb7C655375d275A1C5` instead. ## previewBuyLocal ```solidity theme={null} function previewBuyLocal( uint128 saleSupply, uint96 targetRaise, uint32 gainBps, uint128 sold, uint128 remaining, uint256 ethIn ) external pure returns ( uint256 tokensOut, uint256 cost, uint256 refund, uint256 tokensRemaining ); ``` | Return field | Meaning | | ----------------- | --------------------------------------------------------------------------------------------------------- | | `tokensOut` | Tokens you would receive at the current curve price | | `cost` | ETH actually consumed by the curve (may be less than `ethIn` if your buy would push past the bond target) | | `refund` | ETH that would be refunded (`ethIn - cost`, or zero if the curve absorbs all of it) | | `tokensRemaining` | Tokens left on the curve after the hypothetical buy | If `refund` is non zero, your buy would trigger the bond. Both the curve buy and the bond happen in the same transaction when you execute. The local params come from `getLaunchState(launchId)`: * `saleSupply` = `state.saleSupply` * `targetRaise` = `state.targetRaise` * `gainBps` = `state.gainBps` * `sold` = `state.sold` * `remaining` = `state.saleSupply - state.sold` ## previewSellLocal ```solidity theme={null} function previewSellLocal( uint128 saleSupply, uint96 targetRaise, uint32 gainBps, uint128 sold, uint128 tokenAmount, uint128 netContributions, uint16 creatorFeeSplitBps, uint16 protocolFeeBps, uint16 variableFeeBps, uint16 bpsDenominator ) external pure returns ( uint256 netPayout, uint256 protocolFee, uint256 creatorFee, uint256 buybackFee ); ``` | Return field | Meaning | | ------------- | -------------------------------------------------------- | | `netPayout` | ETH you would receive after fees | | `protocolFee` | ETH taken as the 1 percent protocol fee | | `creatorFee` | ETH credited to the creator from the variable fee | | `buybackFee` | ETH credited to the buyback module from the variable fee | `netPayout + protocolFee + creatorFee + buybackFee` equals the gross curve payout for `tokenAmount`. Local params come from `getLaunchState(launchId)` plus the protocol constants (`PROTOCOL_FEE_BPS = 100`, `VARIABLE_FEE_BPS = 100`, `BPS_DENOMINATOR = 10000`). ## previewSaleSplit ```solidity theme={null} function previewSaleSplit(uint96 targetRaise, uint32 gainBps) external view returns ( uint128 saleSupply, uint128 liquiditySupply, uint16 salePortionBps, uint256 marginalPrice, uint256 poolPrice ); ``` Use this before launch to see how the supply will be split between the bonding curve and the post bond V4 pool. | Return field | Meaning | | ----------------- | --------------------------------------------- | | `saleSupply` | Tokens sold through the curve | | `liquiditySupply` | Tokens paired with ETH in the V4 pool at bond | | `salePortionBps` | `saleSupply` as bps of total supply | | `marginalPrice` | Price of the last token on the curve | | `poolPrice` | Opening price of the V4 pool | `marginalPrice` and `poolPrice` are equal by design. The split is chosen so the curve hands off to the pool without a price gap. `previewSaleSplit` is also callable on the hook (the hook delegates to the view module's `previewSaleSplit` selector for this read). ## Off chain reading The simplest way to call these from JavaScript: ```javascript theme={null} import { createPublicClient, http, parseEther } from "viem" import { INKY_PUMP_HOOK_ABI, LAUNCH_VIEW_MODULE_ABI } from "./abi" const HOOK = "0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4" const VIEW = "0xce83E3659251116d114Ec1CA729ffB49B99403c3" const client = createPublicClient({ chain: { id: 57073, rpcUrls: { default: { http: ["https://rpc-gel.inkonchain.com"] } } }, transport: http(), }) const state = await client.readContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "getLaunchState", args: [launchId], }) const preview = await client.readContract({ address: VIEW, abi: LAUNCH_VIEW_MODULE_ABI, functionName: "previewBuyLocal", args: [ state.saleSupply, state.targetRaise, state.gainBps, state.sold, state.saleSupply - state.sold, parseEther("0.1"), ], }) ``` Using `cast` from Foundry: ```bash theme={null} # 1. Read state from the hook cast call 0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4 \ "getLaunchState(uint256)" $LAUNCH_ID \ --rpc-url https://rpc-gel.inkonchain.com # 2. Pass the unpacked state to the view module's previewBuyLocal cast call 0xce83E3659251116d114Ec1CA729ffB49B99403c3 \ "previewBuyLocal(uint128,uint96,uint32,uint128,uint128,uint256)(uint256,uint256,uint256,uint256)" \ $SALE_SUPPLY $TARGET_RAISE $GAIN_BPS $SOLD $REMAINING $ETH_IN_WEI \ --rpc-url https://rpc-gel.inkonchain.com ``` ## Post bond quotes After a token bonds, the preview functions on the view module no longer reflect tradable price. Use the Uniswap V4 Quoter instead: ```solidity theme={null} // Uniswap V4 Quoter at 0x3972C00f7ed4885e145823eb7C655375d275A1C5 function quoteExactInputSingle(QuoteExactSingleParams memory params) external returns (uint256 amountOut, uint256 gasEstimate); ``` The V4 Quoter is non view (it uses revert-data for the answer), so it has to be simulated through `eth_call` rather than called directly. Most viem and ethers clients handle this transparently. # Token Creation Source: https://docs.inkyswap.com/api-reference/contracts/token-creation createLaunch and createLaunchWithReferral on the InkyPump V2 hook. Launches happen through two entry points on the InkyPump V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`. Use `createLaunch` for a plain launch. Use `createLaunchWithReferral` to record a referral code on chain at creation time. ## createLaunch ```solidity theme={null} function createLaunch(InkyPumpTypes.CreateLaunchParams calldata params) external payable returns (uint256 launchId); ``` `msg.value` is the optional creator prebuy. Send 0 for no prebuy. Send any positive amount to prebuy that much ETH at the curve's starting price in the same transaction. Returns the new `launchId`. The launch's token address is in the `LaunchCreated` event emitted by the same call. ## createLaunchWithReferral ```solidity theme={null} function createLaunchWithReferral( InkyPumpTypes.CreateLaunchParams calldata params, string calldata referralCode ) external payable returns (uint256 launchId); ``` Same behaviour as `createLaunch`, plus a `Referral` event recording the code: ```solidity theme={null} event Referral(uint256 indexed launchId, address indexed trader, string referralCode); ``` If `referralCode` is empty, this still works but does not emit the `Referral` event. Use the plain `createLaunch` when you do not have a referral code. ## CreateLaunchParams ```solidity theme={null} struct CreateLaunchParams { string name; string ticker; string description; string imageUrl; string telegram; // optional string twitter; // optional string website; // optional uint16 creatorFeeSplitBps; // 0 to 10_000 uint32 gainBps; // 0 to 200_000 (1x to 21x) uint96 targetRaise; // 1 ether to 5 ether uint32 antiSnipeDuration; // 0, 20, 40, or 60 seconds uint64 startTime; // 0 for immediate, future unix timestamp for scheduled } ``` ### Prebuy There is no `prebuyEth` field. To prebuy at launch, send the prebuy amount as `msg.value` on the `createLaunch` call. The creator's prebuy executes in the same transaction as the launch, at the curve's starting price, and bypasses the anti-snipe captcha gate. ### Field constraints | Field | Constraint | Reverts if violated | | -------------------- | ---------------------------------------------------------- | ------------------- | | `targetRaise` | Between `MIN_RAISE` (1 ether) and `MAX_RAISE` (5 ether) | `RaiseOutOfRange` | | `gainBps` | At most `MAX_GAIN_BPS` (200,000) | `GainTooHigh` | | `creatorFeeSplitBps` | At most `BPS_DENOMINATOR` (10,000) | `SplitOutOfRange` | | `msg.value` | 0 (no prebuy) or any positive amount your wallet can cover | none directly | | `startTime` | Either 0 or in the future | `LaunchInPast` | ### What happens during the call 1. The hook deploys a new ERC20 token with the supplied metadata 2. It computes the sale supply and liquidity supply for the curve through `SaleSplitCalculator(targetRaise, gainBps)` 3. It records the `LaunchConfig` in storage at the new `launchId` 4. It emits `LaunchCreated` and `LaunchMetadata` 5. If `msg.value > 0`, it executes the creator prebuy at the curve's starting price 6. If called as `createLaunchWithReferral` with a non empty code, it emits `Referral` ## Events emitted ```solidity theme={null} event LaunchCreated( uint256 indexed launchId, address indexed creator, address token, uint96 targetRaise ); event LaunchMetadata( uint256 indexed launchId, string name, string ticker, string description, string imageUrl, string telegram, string twitter, string website ); event SalePortionResolved( uint256 indexed launchId, uint16 salePortionBps, uint256 marginalPrice, uint256 poolPrice ); ``` If `msg.value > 0`, a `Trade` event also fires for the prebuy. ## Example: minimal launch ```javascript theme={null} import { encodeFunctionData, parseEther } from "viem" const params = { name: "My Token", ticker: "MINE", description: "Launching on InkyPump V2", imageUrl: "https://example.com/logo.png", telegram: "", twitter: "", website: "", creatorFeeSplitBps: 7000, // 70 percent of variable fee to creator gainBps: 50_000, // 6x gain targetRaise: parseEther("3"), antiSnipeDuration: 40, // 40 second captcha gate startTime: 0n, } // To prebuy, send ETH with the transaction (set `value` on the tx call below). const data = encodeFunctionData({ abi: INKY_PUMP_HOOK_ABI, functionName: "createLaunch", args: [params], }) const hash = await wallet.sendTransaction({ to: "0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4", data, value: 0n, }) ``` ## Common errors | Revert | Cause | | ----------------- | --------------------------------------------------------------- | | `RaiseOutOfRange` | `targetRaise` is below 1 ether or above 5 ether | | `GainTooHigh` | `gainBps` exceeds 200,000 | | Tx out of funds | Wallet does not have enough ETH for gas plus `msg.value` prebuy | | `LaunchInPast` | `startTime` is in the past and not zero | | `SplitOutOfRange` | `creatorFeeSplitBps` is above 10,000 | # Trading Source: https://docs.inkyswap.com/api-reference/contracts/trading buy, sell, and the referral variants on the InkyPump V2 hook. Trades on the bonding curve go through the InkyPump V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`. There are four write functions: `buy`, `buyWithReferral`, `sell`, and `sellWithReferral`. The referral variants emit an extra `Referral` event. After a token bonds, trades route through the Uniswap Universal Router instead. See [Post-Bond Pool](/trading/post-bond-pool) for that path. ## buy ```solidity theme={null} function buy( uint256 launchId, uint256 minTokensOut, InkyPumpTypes.CaptchaAuth calldata captcha ) external payable returns (uint256 tokensOut); ``` | Param | Meaning | | -------------- | ------------------------------------------------------------- | | `launchId` | The launch ID returned by `createLaunch` | | `minTokensOut` | Slippage floor. Reverts if fewer tokens would be sent | | `captcha` | Captcha signature, required only during the anti-snipe window | `msg.value` is the ETH you spend. Must be at least `MIN_BUY_ETH` (`0.00001 ether`). Returns `tokensOut`, the number of tokens credited to `msg.sender`. ## buyWithReferral ```solidity theme={null} function buyWithReferral( uint256 launchId, uint256 minTokensOut, InkyPumpTypes.CaptchaAuth calldata captcha, string calldata referralCode ) external payable returns (uint256 tokensOut); ``` Same as `buy`, plus emits `Referral(launchId, msg.sender, referralCode)` if `referralCode` is non empty. No fee impact. ## sell ```solidity theme={null} function sell( uint256 launchId, uint128 tokenAmount, uint256 minEthOut, InkyPumpTypes.CaptchaAuth calldata captcha ) external returns (uint256 payout); ``` | Param | Meaning | | ------------- | ------------------------------------------------------------------------ | | `launchId` | The launch ID | | `tokenAmount` | Tokens to sell. Must be at least `MIN_SELL_TOKENS` (`1 ether` = 1 token) | | `minEthOut` | Slippage floor on the ETH payout | | `captcha` | Captcha signature, required only during the anti-snipe window | The contract pulls `tokenAmount` from `msg.sender` (you need to approve the hook first, or the token's `transferFrom` allowance has to cover the trade). Returns the net ETH payout. ## sellWithReferral ```solidity theme={null} function sellWithReferral( uint256 launchId, uint128 tokenAmount, uint256 minEthOut, InkyPumpTypes.CaptchaAuth calldata captcha, string calldata referralCode ) external returns (uint256 payout); ``` Same as `sell`, plus emits `Referral`. No fee impact. ## Captcha auth The anti-snipe captcha is an off chain ECDSA signature from the InkyPump signer. ```solidity theme={null} struct CaptchaAuth { uint256 deadline; // expiration timestamp for this signature bytes signature; // ECDSA signature from the authorized captcha signer } ``` If the anti-snipe window has ended for the launch (`block.timestamp > launchTimestamp + antiSnipeDuration`), the captcha is not checked. You can pass empty fields. If the window is still active, you must provide a valid signature. Otherwise the call reverts with `CaptchaRequired()`. The InkyPump UI fetches the signature automatically from its backend. For direct integrations that need to trade during the anti-snipe window, contact InkyPump for backend signing access. ## Fees The hook splits the input (on buy) or the gross payout (on sell) before processing: ```solidity theme={null} protocolFee = amount * PROTOCOL_FEE_BPS / BPS_DENOMINATOR; // 1 percent variableFee = amount * VARIABLE_FEE_BPS / BPS_DENOMINATOR; // 1 percent creatorFee = variableFee * creatorFeeSplitBps / BPS_DENOMINATOR; buybackFee = variableFee - creatorFee; netAmount = amount - protocolFee - variableFee; ``` `creatorFee` accrues to the launch creator. `buybackFee` accrues to a buyback module that periodically buys and burns the token. ## Events emitted Every successful trade emits: ```solidity theme={null} event Trade( uint256 indexed launchId, address indexed trader, TradeType tradeType, // BUY or SELL PriceData priceData, TradeData tradeData, uint256 refund ); event FeeAccrued(address indexed recipient, uint256 amount); ``` The `*WithReferral` variants additionally emit: ```solidity theme={null} event Referral( uint256 indexed launchId, address indexed trader, string referralCode ); ``` ## Common errors | Revert | Cause | | ------------------ | -------------------------------------------------------------------------------- | | `CaptchaRequired` | In the anti-snipe window without a valid signature | | `InvalidCaptcha` | Signature does not verify against the configured signer or `deadline` has passed | | `SlippageExceeded` | Output below `minTokensOut` (buy) or `minEthOut` (sell) | | `BelowMinBuy` | `msg.value` is below `MIN_BUY_ETH` | | `BelowMinSell` | `tokenAmount` is below `MIN_SELL_TOKENS` | | `LaunchFinalized` | The token has bonded. Use the V4 pool instead | | `LaunchNotStarted` | `launchTimestamp` is in the future (scheduled launch) | # API Examples Source: https://docs.inkyswap.com/api-reference/examples Working examples for the InkyPump V2 contract and REST API. This page collects working snippets you can copy. All examples target the live V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` on Ink mainnet. ## Preview a buy from cast Previews use the `LaunchViewModule` with local state. Read the launch state first, then call `previewBuyLocal` with the unpacked fields. See [Quotes](/api-reference/contracts/quotes) for the full pattern. ```bash theme={null} # 1. Read launch state from the hook cast call 0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4 \ "getLaunchState(uint256)" $LAUNCH_ID \ --rpc-url https://rpc-gel.inkonchain.com # 2. Pass the unpacked state to the view module cast call 0xce83E3659251116d114Ec1CA729ffB49B99403c3 \ "previewBuyLocal(uint128,uint96,uint32,uint128,uint128,uint256)(uint256,uint256,uint256,uint256)" \ $SALE_SUPPLY $TARGET_RAISE $GAIN_BPS $SOLD $REMAINING 100000000000000 \ --rpc-url https://rpc-gel.inkonchain.com ``` Returns four uint256 values: `tokensOut`, `cost`, `refund`, `tokensRemaining`. ## Read launch state from cast ```bash theme={null} cast call 0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4 \ "getLaunchState(uint256)" \ $LAUNCH_ID \ --rpc-url https://rpc-gel.inkonchain.com ``` The returned bytes decode to the `LaunchConfig` struct. For a typed decode, use viem or ethers with the ABI. ## Buy with viem ```typescript theme={null} import { createWalletClient, http, parseEther } from "viem" import { privateKeyToAccount } from "viem/accounts" import { INKY_PUMP_HOOK_ABI } from "./abi" const HOOK = "0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4" const account = privateKeyToAccount(process.env.PRIVATE_KEY) const client = createWalletClient({ account, chain: { id: 57073, rpcUrls: { default: { http: ["https://rpc-gel.inkonchain.com"] } } }, transport: http(), }) const captcha = { deadline: 0n, signature: "0x" } // empty if past anti-snipe window const hash = await client.writeContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "buy", args: [launchId, minTokensOut, captcha], value: parseEther("0.1"), }) ``` ## Sell with viem (requires approval first) ```typescript theme={null} // Approve the hook to pull tokens await client.writeContract({ address: tokenAddress, abi: ERC20_ABI, functionName: "approve", args: [HOOK, tokenAmount], }) // Then sell await client.writeContract({ address: HOOK, abi: INKY_PUMP_HOOK_ABI, functionName: "sell", args: [launchId, tokenAmount, minEthOut, captcha], }) ``` ## Listen for Trade events ```typescript theme={null} import { createPublicClient, http, parseAbiItem } from "viem" const publicClient = createPublicClient({ chain: { id: 57073, rpcUrls: { default: { http: ["https://rpc-gel.inkonchain.com"] } } }, transport: http(), }) const tradeEvent = parseAbiItem( "event Trade(uint256 indexed launchId, address indexed trader, uint8 tradeType, (uint256,uint256) priceData, (uint256,uint256,uint256) tradeData, uint256 refund)" ) publicClient.watchEvent({ address: "0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4", event: tradeEvent, onLogs: (logs) => logs.forEach((log) => console.log(log.args)), }) ``` ## Fetch recent V2 tokens from REST ```bash theme={null} curl "https://inkypump.com/api/tokens/recent-v2?limit=10" ``` Returns the most recent V2 launches with address, ticker, image URL, and target raise. ## Fetch a single token ```bash theme={null} curl "https://inkypump.com/api/token/0x6791df130bd16722516e891f4fd38651ee382ebb" ``` Returns the token's full record. Includes the `launch_id` field if it is a V2 token. ## Use the MCP server After the [MCP server](/api-reference/mcp) is registered: In a Claude Code chat: ``` > wallet_info > recent_launches { "limit": 5 } > preview_launch { "name": "Test", "ticker": "TEST", "targetRaiseEth": 2 } ``` The agent calls the MCP tools and returns the JSON responses. ## End to end: launch from cast ```bash theme={null} # Encode CreateLaunchParams calldata. Easier to do this through cast send with --abi-file. cast send 0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4 \ "createLaunch((string,string,string,string,string,string,string,uint96,uint32,uint16,uint32,uint96,uint64))" \ "(My Token,MINE,Description,https://example.com/image.png,,,,3000000000000000000,50000,7000,40,0,0)" \ --rpc-url https://rpc-gel.inkonchain.com \ --private-key $PRIVATE_KEY \ --value 0 ``` Easier through the UI or the MCP for one off launches. Direct contract calls are for automation. # Chat Messages Source: https://docs.inkyswap.com/api-reference/inkypump/chat-messages GET /api/chat Retrieve and post chat messages for a token ## GET - Retrieve Messages Fetch chat messages for a specific token. ### Query Parameters The token contract address Maximum number of messages to return Number of messages to skip for pagination ### Response Returns an array of message objects directly: Unique message ID Token contract address Ethereum address of the sender Message content (max 500 characters) ISO timestamp of when the message was sent ## POST - Send Message **API Access Required**: To use the POST endpoint for sending messages, please contact [@emperoroftheink](https://t.me/emperoroftheink) on Telegram for access credentials and usage guidelines. Post a new chat message for a token. ### Request Body Cloudflare Turnstile verification token The token contract address Message content (max 500 characters) Ethereum signature for authentication ### Rate Limits * Maximum 5 messages per minute per address ```json theme={null} [ { "id": "msg_123456", "token_address": "0x1234567890abcdef1234567890abcdef12345678", "sender_address": "0xabcdef1234567890abcdef1234567890abcdef12", "message": "This token looks promising!", "created_at": "2024-01-15T10:30:00Z" } ] ``` ### POST Response Example ```json theme={null} { "id": "msg_789012", "token_address": "0x1234567890abcdef1234567890abcdef12345678", "sender_address": "0xabcdef1234567890abcdef1234567890abcdef12", "message": "Great project!", "created_at": "2024-01-15T11:00:00Z" } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/chat?tokenAddress=0x1234567890abcdef1234567890abcdef12345678&limit=50" curl -X POST "https://inkypump.com/api/chat" \ -H "Content-Type: application/json" \ -d '{ "token": "TURNSTILE_TOKEN", "tokenAddress": "0x1234567890abcdef1234567890abcdef12345678", "message": "Great project!", "signature": "0xSignature..." }' ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkypump.com/api/chat?tokenAddress=0x1234...&limit=50'); const messages = await response.json(); const postResponse = await fetch('https://inkypump.com/api/chat', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ token: turnstileToken, tokenAddress: '0x1234...', message: 'Great project!', signature: signature }) }); ``` ```python Python theme={null} import requests response = requests.get( "https://inkypump.com/api/chat", params={"tokenAddress": "0x1234...", "limit": 50} ) messages = response.json() response = requests.post( "https://inkypump.com/api/chat", json={ "token": "TURNSTILE_TOKEN", "tokenAddress": "0x1234...", "message": "Great project!", "signature": "0xSignature..." } ) ``` # Emperor of the INK (EOTI) Source: https://docs.inkyswap.com/api-reference/inkypump/emperor GET /api/eoti Get the current Emperor of the INK - the daily Emperor token selected through competitive bidding ## Description Returns information about the current Emperor of the INK (EOTI), which is the daily Emperor token that receives premium placement and visibility across the platform. The EOTI is selected through a competitive bidding system where projects can bid to become the Emperor for the next day. The endpoint automatically returns the current day's Emperor token based on the smart contract. ## Query Parameters Include bidding data such as current bid amount, next Emperor, and bidding history ## Response Token contract address ISO timestamp of token creation Creator's wallet address Token name Token symbol Token description Token logo URL Telegram channel URL Twitter/X profile URL Official website URL Current market capitalization in ETH Funding progress (0-1, where 1 means fully funded and live) Current token price in ETH 24-hour trading volume 24-hour price change percentage Number of buy transactions in the last 24 hours Number of sell transactions in the last 24 hours 1-hour trading volume 1-hour price change percentage Number of buy transactions in the last hour Number of sell transactions in the last hour Total number of token holders Percentage of supply held by top 10 holders Percentage of supply held by developer Bidding information (only included if includeBidData=true) Current highest bid amount in wei Starting bid amount for the current epoch in wei Last bid amount in wei Timestamp of the last bid Formatted last bid information Bid amount in ETH Unix timestamp of the bid Address of the token that will be Emperor tomorrow Address of today's Emperor token Address of yesterday's Emperor token Whether the current epoch has been claimed ```json theme={null} { "address": "0x75e7A5316e44755FF4ad724ee45337D1Eef6895e", "created_at": "2024-01-10T08:15:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "Emperor Token", "ticker": "EMPEROR", "description": "The reigning Emperor of the INK ecosystem", "image_url": "https://example.com/emperor-logo.png", "telegram": "https://t.me/emperortoken", "twitter": "https://twitter.com/emperortoken", "website": "https://emperortoken.com", "market_cap": 1250.5, "funding_progress": 1.0, "price_eth": 0.00125, "volume_24h": 450.8, "price_change_24h": 125.3, "txns_24h_buys": 892, "txns_24h_sells": 423 } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/eoti" curl -X GET "https://inkypump.com/api/eoti?includeBidData=true" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkypump.com/api/eoti'); const emperor = await response.json(); const withBidData = await fetch('https://inkypump.com/api/eoti?includeBidData=true'); const emperorWithBids = await withBidData.json(); ``` ```python Python theme={null} import requests response = requests.get("https://inkypump.com/api/eoti") emperor = response.json() with_bid_data = requests.get( "https://inkypump.com/api/eoti", params={"includeBidData": "true"} ) emperor_with_bids = with_bid_data.json() ``` # Get Token Source: https://docs.inkyswap.com/api-reference/inkypump/get-token GET /api/token Retrieve detailed information about a specific token by its address ## Query Parameters The Ethereum address of the token to retrieve ## Response The token contract address ISO timestamp of when the token was created The address of the token creator The full name of the token The token symbol/ticker Description of the token URL to the token's image/logo Telegram channel/group URL Twitter/X profile URL Official website URL Current market capitalization in ETH Funding progress (0-1, where 1 means fully funded and live) Current price in ETH Array of recent price update transactions with supply, trader, and transaction details ```json theme={null} { "address": "0x1234567890abcdef1234567890abcdef12345678", "created_at": "2024-01-15T10:30:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "Example Token", "ticker": "EXMP", "description": "An example token for demonstration", "image_url": "https://example.com/token-logo.png", "telegram": "https://t.me/exampletoken", "twitter": "https://twitter.com/exampletoken", "website": "https://exampletoken.com", "market_cap": 125.5, "funding_progress": 0.75, "price_eth": 0.000125 } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/token?address=0x1234567890abcdef1234567890abcdef12345678" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkypump.com/api/token?address=0x1234567890abcdef1234567890abcdef12345678'); const token = await response.json(); ``` ```python Python theme={null} import requests response = requests.get( "https://inkypump.com/api/token", params={"address": "0x1234567890abcdef1234567890abcdef12345678"} ) token = response.json() ``` # King of the INK (KOTI) Source: https://docs.inkyswap.com/api-reference/inkypump/koti GET /api/koti Get the current King of the INK - the token with the highest market cap still in funding phase ## Description Returns the token with the highest market capitalization that hasn't reached full funding yet (funding\_progress \< 1). This endpoint is useful for discovering the most popular token currently raising funds. ## Response Token contract address ISO timestamp of token creation Creator's wallet address Token name Token symbol Token description Token logo URL Telegram channel URL Twitter/X profile URL Official website URL Current market capitalization in ETH Funding progress (0-1, where 1 means fully funded) Current token price in ETH 24-hour trading volume 24-hour price change percentage Number of buy transactions in the last 24 hours Number of sell transactions in the last 24 hours ```json theme={null} { "address": "0x1234567890abcdef1234567890abcdef12345678", "created_at": "2024-01-15T10:30:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "King Token", "ticker": "KING", "description": "The current king of the hill", "image_url": "https://example.com/king-logo.png", "telegram": "https://t.me/kingtoken", "twitter": "https://twitter.com/kingtoken", "website": "https://kingtoken.com", "market_cap": 450.75, "funding_progress": 0.85, "price_eth": 0.00045, "volume_24h": 125.3, "price_change_24h": 35.2, "txns_24h_buys": 342, "txns_24h_sells": 156 } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/koti" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkypump.com/api/koti'); const koti = await response.json(); ``` ```python Python theme={null} import requests response = requests.get("https://inkypump.com/api/koti") koti = response.json() ``` # Leaderboard Source: https://docs.inkyswap.com/api-reference/inkypump/leaderboard GET /api/leaderboard Get the points leaderboard with pagination and search functionality ## Query Parameters Page number for pagination (10 items per page) Search for specific addresses (partial matching supported) ## Response Array of leaderboard entries Ethereum wallet address Total points earned Total number of pages available Total number of entries in the leaderboard ## Rate Limits * 10 requests per minute per IP address (computational endpoint) ```json theme={null} { "leaderboard": [ { "address": "0x1234567890abcdef1234567890abcdef12345678", "points": 15420 }, { "address": "0xabcdef1234567890abcdef1234567890abcdef12", "points": 12350 }, { "address": "0x9876543210fedcba9876543210fedcba98765432", "points": 10200 } ], "totalPages": 25, "totalCount": 245 } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/leaderboard?page=1" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkypump.com/api/leaderboard?page=1'); const data = await response.json(); ``` ```python Python theme={null} import requests response = requests.get( "https://inkypump.com/api/leaderboard", params={"page": 1} ) data = response.json() ``` # List Tokens Source: https://docs.inkyswap.com/api-reference/inkypump/list-tokens GET /api/tokens Retrieve a paginated list of tokens with advanced filtering and sorting options ## Query Parameters Page number for pagination Search by token name, ticker, description, owner address, or token address Filter by status. Comma-separated values: `live`, `funding` Sort order. Options: `newest`, `oldest`, `trending`, `mcap-high`, `mcap-low` Timeframe for trending calculation. Options: `5m`, `1h`, `6h`, `24h` Filter by social links. Comma-separated values: `telegram`, `twitter`, `website` Minimum funding progress (0-1) Maximum funding progress (0-1) Minimum market cap in ETH Maximum market cap in ETH Minimum transaction count Maximum transaction count Filter tokens created after this date (ISO format) Filter tokens created before this date (ISO format) ## Response Array of token objects Token contract address Token name Token symbol Token description Token logo URL Market capitalization in ETH Funding progress (0-1) Current price in ETH 24-hour trading volume 24-hour price change percentage Total number of token holders Total number of tokens matching the filters Total number of pages available ```json theme={null} { "tokens": [ { "address": "0x1234567890abcdef1234567890abcdef12345678", "created_at": "2024-01-15T10:30:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "Example Token", "ticker": "EXMP", "description": "An example token", "image_url": "https://example.com/logo.png", "telegram": "https://t.me/example", "twitter": "https://twitter.com/example", "website": "https://example.com", "market_cap": 125.5, "funding_progress": 1.0, "price_eth": 0.000125, "volume_24h": 45.2, "price_change_24h": 12.5, "txns_24h_buys": 150, "txns_24h_sells": 120, "total_holders": 523 } ], "totalCount": 1523, "totalPages": 153 } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/tokens?page=1&sortBy=trending&status=live" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkypump.com/api/tokens?page=1&sortBy=trending&status=live'); const data = await response.json(); ``` ```python Python theme={null} import requests response = requests.get( "https://inkypump.com/api/tokens", params={ "page": 1, "sortBy": "trending", "status": "live" } ) data = response.json() ``` # Referral System Source: https://docs.inkyswap.com/api-reference/inkypump/referral GET /api/referral Manage referral codes and track referral rewards ## Description The referral API endpoints allow you to generate referral codes, track referral performance, and view reward statistics. Users earn points when their referrals trade, create tokens, or achieve milestones. ## Endpoints ### Get Referral Code Generate or retrieve your unique referral code #### Headers Bearer token or wallet signature for authentication #### Response ```json theme={null} { "code": "INKY-ABC123", "created_at": "2024-01-15T10:30:00Z", "total_referrals": 15, "active_referrals": 12, "total_points_earned": 5250.5 } ``` *** ### Get Referral Stats Get detailed statistics about your referral performance #### Headers Bearer token or wallet signature for authentication #### Query Parameters Time period for stats. Options: `24h`, `7d`, `30d`, `all` #### Response ```json theme={null} { "referral_code": "INKY-ABC123", "stats": { "total_referrals": 15, "active_referrals": 12, "total_points_earned": 5250.5, "points_from_trading": 3500.2, "points_from_token_creation": 1000.0, "points_from_milestones": 750.3 }, "recent_activity": [ { "type": "trade", "referral_address": "0xabc...def", "points_earned": 25.5, "timestamp": "2024-01-15T09:00:00Z" } ], "top_referrals": [ { "address": "0x123...456", "points_generated": 850.2, "joined_at": "2024-01-10T08:00:00Z" } ] } ``` *** ### Register with Referral Code Register a new user with a referral code #### Request Body The referral code to use for registration The wallet address of the new user #### Response ```json theme={null} { "success": true, "message": "Successfully registered with referral code", "referrer": "0xabc...def" } ``` *** ### Get Referral Leaderboard View the top referrers on the platform #### Query Parameters Number of top referrers to return (max: 100) Time period for leaderboard. Options: `24h`, `7d`, `30d`, `all` #### Response ```json theme={null} { "leaderboard": [ { "rank": 1, "address": "0xabc...def", "referral_code": "INKY-TOP1", "total_referrals": 523, "points_earned": 125000.5 }, { "rank": 2, "address": "0x123...456", "referral_code": "INKY-MOON", "total_referrals": 412, "points_earned": 98500.3 } ], "updated_at": "2024-01-15T10:00:00Z" } ``` ## Reward Structure | Action | Reward | Description | | ------------------------- | ------------- | -------------------------------------------------- | | **Buy Volume** | 10% of points | Earn 10% of points from referral's ETH buy volume | | **Sell Volume** | 10% of points | Earn 10% of points from referral's ETH sell volume | | **Token Creation** | 10% bonus | 10% bonus when referral creates a new token | | **Milestone Achievement** | Variable | Points when referral hits certain milestones | ## Rate Limiting Referral API endpoints have specific rate limits: * Generate/Get Code: 10 requests per minute * Stats/Leaderboard: 30 requests per minute * Registration: 5 requests per minute per IP ```bash cURL theme={null} # Get your referral code curl -X GET "https://inkypump.com/api/referral/code" \ -H "Authorization: Bearer YOUR_TOKEN" # Get referral statistics curl -X GET "https://inkypump.com/api/referral/stats?period=7d" \ -H "Authorization: Bearer YOUR_TOKEN" # Register with referral code curl -X POST "https://inkypump.com/api/referral/register" \ -H "Content-Type: application/json" \ -d '{ "referral_code": "INKY-ABC123", "wallet_address": "0xnewuser..." }' # Get leaderboard curl -X GET "https://inkypump.com/api/referral/leaderboard?limit=20&period=30d" ``` ```typescript TypeScript theme={null} // Get your referral code const codeResponse = await fetch('https://inkypump.com/api/referral/code', { headers: { 'Authorization': `Bearer ${authToken}` } }); const codeData = await codeResponse.json(); // Get referral statistics const statsResponse = await fetch('https://inkypump.com/api/referral/stats?period=7d', { headers: { 'Authorization': `Bearer ${authToken}` } }); const statsData = await statsResponse.json(); // Register with referral code const registerResponse = await fetch('https://inkypump.com/api/referral/register', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ referral_code: 'INKY-ABC123', wallet_address: '0xnewuser...' }) }); const registerData = await registerResponse.json(); // Get leaderboard const leaderboardResponse = await fetch('https://inkypump.com/api/referral/leaderboard?limit=20&period=30d'); const leaderboardData = await leaderboardResponse.json(); ``` ```python Python theme={null} import requests # Get your referral code code_response = requests.get( "https://inkypump.com/api/referral/code", headers={"Authorization": f"Bearer {auth_token}"} ) code_data = code_response.json() # Get referral statistics stats_response = requests.get( "https://inkypump.com/api/referral/stats", params={"period": "7d"}, headers={"Authorization": f"Bearer {auth_token}"} ) stats_data = stats_response.json() # Register with referral code register_response = requests.post( "https://inkypump.com/api/referral/register", json={ "referral_code": "INKY-ABC123", "wallet_address": "0xnewuser..." } ) register_data = register_response.json() # Get leaderboard leaderboard_response = requests.get( "https://inkypump.com/api/referral/leaderboard", params={"limit": 20, "period": "30d"} ) leaderboard_data = leaderboard_response.json() ``` # Batch Token Lookup Source: https://docs.inkyswap.com/api-reference/inkypump/tokens-batch POST /api/tokens/batch Get multiple tokens by their addresses in a single request ## Description Fetches detailed information for multiple tokens in a single request. This endpoint is optimized for applications that need to retrieve data for multiple tokens efficiently, such as portfolio trackers or analytics dashboards. ## Request Body Array of token contract addresses (max: 50 addresses per request) Include trading metrics (volume, price changes, transaction counts) Include holder distribution data Include social media links ## Response Array of token objects matching the requested addresses Token contract address ISO timestamp of token creation Creator's wallet address Token name Token symbol Token description Token logo URL Telegram channel URL (if includeSocials=true) Twitter/X profile URL (if includeSocials=true) Official website URL (if includeSocials=true) Current market capitalization in ETH Funding progress (0-1, where 1 means fully funded) Current token price in ETH 24-hour trading volume (if includeMetrics=true) 24-hour price change percentage (if includeMetrics=true) Number of buy transactions in the last 24 hours (if includeMetrics=true) Number of sell transactions in the last 24 hours (if includeMetrics=true) Total number of token holders (if includeHolders=true) Percentage of supply held by top 10 holders (if includeHolders=true) Percentage of supply held by developer (if includeHolders=true) Whether the token has completed funding Array of addresses that were not found or are invalid Array of any errors encountered during processing ```json theme={null} { "tokens": [ { "address": "0x1234567890abcdef1234567890abcdef12345678", "created_at": "2024-01-15T10:30:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "Moon Token", "ticker": "MOON", "description": "To the moon and beyond", "image_url": "https://example.com/moon-logo.png", "telegram": "https://t.me/moontoken", "twitter": "https://twitter.com/moontoken", "website": "https://moontoken.com", "market_cap": 500.5, "funding_progress": 1.0, "price_eth": 0.00125, "volume_24h": 250.8, "price_change_24h": 15.3, "txns_24h_buys": 425, "txns_24h_sells": 312, "total_holders": 1250, "top_10_percentage": 35.2, "dev_holding_percentage": 5.0, "is_graduated": true }, { "address": "0x9876543210fedcba9876543210fedcba98765432", "created_at": "2024-01-14T08:15:00Z", "owner": "0xfedcba9876543210fedcba9876543210fedcba98", "name": "Star Token", "ticker": "STAR", "description": "Reach for the stars", "image_url": "https://example.com/star-logo.png", "telegram": "https://t.me/startoken", "twitter": null, "website": null, "market_cap": 125.3, "funding_progress": 0.65, "price_eth": 0.00089, "volume_24h": 45.2, "price_change_24h": -5.2, "txns_24h_buys": 89, "txns_24h_sells": 67, "total_holders": 423, "top_10_percentage": 48.7, "dev_holding_percentage": 10.0, "is_graduated": false } ], "notFound": [ "0xinvalidaddress123" ], "errors": [] } ``` ```bash cURL theme={null} curl -X POST "https://inkypump.com/api/tokens/batch" \ -H "Content-Type: application/json" \ -d '{ "addresses": [ "0x1234567890abcdef1234567890abcdef12345678", "0x9876543210fedcba9876543210fedcba98765432" ] }' curl -X POST "https://inkypump.com/api/tokens/batch" \ -H "Content-Type: application/json" \ -d '{ "addresses": [ "0x1234567890abcdef1234567890abcdef12345678", "0x9876543210fedcba9876543210fedcba98765432" ], "includeMetrics": false, "includeHolders": true }' ``` ```typescript TypeScript theme={null} const addresses = [ '0x1234567890abcdef1234567890abcdef12345678', '0x9876543210fedcba9876543210fedcba98765432' ]; const response = await fetch('https://inkypump.com/api/tokens/batch', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ addresses }) }); const data = await response.json(); const minimalResponse = await fetch('https://inkypump.com/api/tokens/batch', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ addresses, includeMetrics: false, includeHolders: true }) }); const minimalData = await minimalResponse.json(); ``` ```python Python theme={null} import requests addresses = [ "0x1234567890abcdef1234567890abcdef12345678", "0x9876543210fedcba9876543210fedcba98765432" ] response = requests.post( "https://inkypump.com/api/tokens/batch", json={"addresses": addresses} ) data = response.json() minimal_response = requests.post( "https://inkypump.com/api/tokens/batch", json={ "addresses": addresses, "includeMetrics": False, "includeHolders": True } ) minimal_data = minimal_response.json() ``` # Tokens by Owner Source: https://docs.inkyswap.com/api-reference/inkypump/tokens-by-owner GET /api/tokens/by-owner Get all tokens created by a specific wallet address ## Description Returns a paginated list of all tokens created by a specific wallet address. This endpoint is useful for viewing a creator's portfolio of launched tokens. ## Query Parameters The wallet address of the token creator Page number for pagination Number of tokens per page (max: 100) Sorting order. Options: * `created_at_desc`: Newest first * `created_at_asc`: Oldest first * `market_cap_desc`: Highest market cap first * `market_cap_asc`: Lowest market cap first * `funding_progress_desc`: Highest funding progress first * `volume_24h_desc`: Highest 24h volume first Include tokens that have been disabled or failed ## Response Array of token objects Token contract address ISO timestamp of token creation Creator's wallet address Token name Token symbol Token description Token logo URL Current market capitalization in ETH Funding progress (0-1, where 1 means fully funded) 24-hour trading volume Total number of token holders Whether the token has completed funding Pagination metadata Current page number Items per page Total number of tokens Total number of pages ```json theme={null} { "tokens": [ { "address": "0x1234567890abcdef1234567890abcdef12345678", "created_at": "2024-01-15T10:30:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "Moon Token", "ticker": "MOON", "description": "To the moon and beyond", "image_url": "https://example.com/moon-logo.png", "market_cap": 500.5, "funding_progress": 1.0, "volume_24h": 250.8, "total_holders": 1250, "is_graduated": true }, { "address": "0x9876543210fedcba9876543210fedcba98765432", "created_at": "2024-01-14T08:15:00Z", "owner": "0xabcdef1234567890abcdef1234567890abcdef12", "name": "Star Token", "ticker": "STAR", "description": "Reach for the stars", "image_url": "https://example.com/star-logo.png", "market_cap": 125.3, "funding_progress": 0.65, "volume_24h": 45.2, "total_holders": 423, "is_graduated": false } ], "pagination": { "page": 1, "limit": 20, "total": 5, "totalPages": 1 } } ``` ```bash cURL theme={null} curl -X GET "https://inkypump.com/api/tokens/by-owner?owner=0xabcdef1234567890abcdef1234567890abcdef12" curl -X GET "https://inkypump.com/api/tokens/by-owner?owner=0xabcdef1234567890abcdef1234567890abcdef12&sort=market_cap_desc&limit=10" ``` ```typescript TypeScript theme={null} const ownerAddress = '0xabcdef1234567890abcdef1234567890abcdef12'; const response = await fetch(`https://inkypump.com/api/tokens/by-owner?owner=${ownerAddress}`); const data = await response.json(); const sortedResponse = await fetch( `https://inkypump.com/api/tokens/by-owner?owner=${ownerAddress}&sort=market_cap_desc&limit=10` ); const sortedData = await sortedResponse.json(); ``` ```python Python theme={null} import requests owner_address = "0xabcdef1234567890abcdef1234567890abcdef12" response = requests.get( "https://inkypump.com/api/tokens/by-owner", params={"owner": owner_address} ) data = response.json() sorted_response = requests.get( "https://inkypump.com/api/tokens/by-owner", params={ "owner": owner_address, "sort": "market_cap_desc", "limit": 10 } ) sorted_data = sorted_response.json() ``` # Upload Image Source: https://docs.inkyswap.com/api-reference/inkypump/upload-image POST /api/upload Upload an image for token creation with security verification **API Access Required**: To use this endpoint, please contact [@emperoroftheink](https://t.me/emperoroftheink) on Telegram for access credentials and usage guidelines. ## Request Body Image file to upload (PNG, JPG, JPEG, GIF, WEBP). Maximum size: 5MB Cloudflare Turnstile verification token Wallet address of the uploader for rate limiting ## Response Public URL of the uploaded image ## Rate Limits * 5 uploads per minute per IP address * 3 uploads per minute per wallet address * Progressive rate limiting with stricter limits for repeated violations ## File Validation * **Accepted formats**: PNG, JPG, JPEG, GIF, WEBP * **Maximum file size**: 5MB * **Content validation**: Files are validated to ensure they match their declared MIME type ```json theme={null} { "url": "https://supabase.example.com/storage/v1/object/public/images/a3f5e2c891b4d7f6e8a9c1b3d5e7f9a1b3c5d7e9.png" } ``` ```bash cURL theme={null} curl -X POST "https://inkypump.com/api/upload" \ -H "Content-Type: multipart/form-data" \ -F "file=@/path/to/image.png" \ -F "turnstileToken=YOUR_TURNSTILE_TOKEN" \ -F "walletAddress=0xYourWalletAddress" ``` ```typescript TypeScript theme={null} const formData = new FormData(); formData.append('file', fileInput.files[0]); formData.append('turnstileToken', turnstileToken); formData.append('walletAddress', walletAddress); const response = await fetch('https://inkypump.com/api/upload', { method: 'POST', body: formData }); const data = await response.json(); ``` ```python Python theme={null} import requests files = {'file': open('image.png', 'rb')} data = { 'turnstileToken': 'YOUR_TURNSTILE_TOKEN', 'walletAddress': '0xYourWalletAddress' } response = requests.post( 'https://inkypump.com/api/upload', files=files, data=data ) result = response.json() ``` # Get Liquidity Pairs Source: https://docs.inkyswap.com/api-reference/inkyswap/get-pairs GET /api/pairs Retrieve all available liquidity pairs sorted by liquidity ## Description Returns all liquidity pairs available on InkySwap, sorted by total liquidity in USD descending. This endpoint automatically converts WETH addresses to native ETH representation for easier integration. ## Response Array of liquidity pair objects Liquidity pair contract address First token in the pair Token contract address Token symbol Token name Token decimals Second token in the pair Token contract address Token symbol Token name Token decimals Total liquidity value in USD Reserve amount of token0 Reserve amount of token1 24-hour trading volume in USD Trading fee percentage (e.g., 0.003 for 0.3%) ```json theme={null} [ { "address": "0x1234567890abcdef1234567890abcdef12345678", "token0": { "address": "0x0000000000000000000000000000000000000000", "symbol": "ETH", "name": "Ethereum", "decimals": 18 }, "token1": { "address": "0xabcdef1234567890abcdef1234567890abcdef12", "symbol": "USDC", "name": "USD Coin", "decimals": 6 }, "liquidity_usd": 5000000, "reserve0": "1250000000000000000000", "reserve1": "2500000000000", "volume_24h": 125000, "fee_tier": 0.003 } ] ``` ```bash cURL theme={null} curl -X GET "https://inkyswap.com/api/pairs" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkyswap.com/api/pairs'); const pairs = await response.json(); ``` ```python Python theme={null} import requests response = requests.get("https://inkyswap.com/api/pairs") pairs = response.json() ``` # Get Swap Quote Source: https://docs.inkyswap.com/api-reference/inkyswap/get-quote GET /api/quote Get a price quote for swapping tokens with optional transaction building ## Query Parameters Input token address (use `0x0000000000000000000000000000000000000000` for native ETH) Output token address (use `0x0000000000000000000000000000000000000000` for native ETH) Amount of input token (in smallest unit). Either `amount` or `amountOut` must be provided Desired amount of output token (in smallest unit). Either `amount` or `amountOut` must be provided Slippage tolerance in basis points (e.g., 100 = 1%). Range: 0-10000 Whether to build the transaction data User's wallet address (required if `buildTx` is true) ## Response Actual input amount in smallest unit Expected output amount in smallest unit Minimum output amount after slippage (if slippage provided) Maximum input amount after slippage (if using exact output) Exchange rate for this specific trade (accounts for price impact) Current spot price without price impact Token addresses in the swap route Estimated price impact percentage (0-1) Total LP fees in input token amount Additional quote information LP fee percentage Router contract address Applied slippage in basis points Transaction data (if `buildTx` is true) Sender address Router contract address Encoded transaction data ETH value to send (for ETH swaps) Estimated gas price Estimated gas limit ```json theme={null} { "amountIn": "1000000000000000000", "amountOut": "2500000000", "minimumAmountOut": "2475000000", "executionRate": "2500000000000000000000", "spotRate": "2505000000000000000000", "path": [ "0x0000000000000000000000000000000000000000", "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" ], "priceImpact": 0.002, "lpFee": "3000000000000000", "metadata": { "lpFeePercent": 0.003, "routerAddress": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D", "slippageBps": 100 }, "transaction": { "from": "0x1234567890abcdef1234567890abcdef12345678", "to": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D", "data": "0x7ff36ab500000...", "value": "1000000000000000000", "gasPrice": "50000000000", "gas": "250000" } } ``` ```bash cURL theme={null} curl -X GET "https://inkyswap.com/api/quote?tokenIn=0x0000000000000000000000000000000000000000&tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000" curl -X GET "https://inkyswap.com/api/quote?tokenIn=0x0000000000000000000000000000000000000000&tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&slippage=100&buildTx=true&userAddress=0x1234567890abcdef1234567890abcdef12345678" ``` ```typescript TypeScript theme={null} const response = await fetch( 'https://inkyswap.com/api/quote?' + new URLSearchParams({ tokenIn: '0x0000000000000000000000000000000000000000', tokenOut: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', amount: '1000000000000000000' }) ); const quote = await response.json(); const txResponse = await fetch( 'https://inkyswap.com/api/quote?' + new URLSearchParams({ tokenIn: '0x0000000000000000000000000000000000000000', tokenOut: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', amount: '1000000000000000000', slippage: '100', buildTx: 'true', userAddress: '0x1234567890abcdef1234567890abcdef12345678' }) ); const txQuote = await txResponse.json(); ``` ```python Python theme={null} import requests response = requests.get( "https://inkyswap.com/api/quote", params={ "tokenIn": "0x0000000000000000000000000000000000000000", "tokenOut": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "amount": "1000000000000000000" } ) quote = response.json() tx_response = requests.get( "https://inkyswap.com/api/quote", params={ "tokenIn": "0x0000000000000000000000000000000000000000", "tokenOut": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "amount": "1000000000000000000", "slippage": "100", "buildTx": "true", "userAddress": "0x1234567890abcdef1234567890abcdef12345678" } ) tx_quote = tx_response.json() ``` # Get Token List Source: https://docs.inkyswap.com/api-reference/inkyswap/get-tokens GET /api/tokens Retrieve the combined token list from official registry and live InkyPump tokens ## Description Returns a comprehensive token list that combines: 1. The official InkySwap token registry from GitHub 2. All InkyPump tokens that have reached full funding (funding\_progress = 1) This endpoint follows the Uniswap Token List standard format for easy integration with DEX interfaces. ## Response Name of the token list ISO timestamp of the token list Version information Major version number Minor version number Patch version number Array of token objects Chain ID (57073 for INK mainnet) Token contract address Token symbol/ticker Token name Token decimals (typically 18) URL to token logo image ```json theme={null} { "name": "InkySwap Token List", "timestamp": "2024-01-15T12:00:00Z", "version": { "major": 1, "minor": 0, "patch": 0 }, "tokens": [ { "chainId": 57073, "address": "0x0000000000000000000000000000000000000000", "symbol": "ETH", "name": "Ethereum", "decimals": 18, "logoURI": "https://raw.githubusercontent.com/InkySwap/token-logos/main/eth.png" }, { "chainId": 57073, "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "symbol": "USDC", "name": "USD Coin", "decimals": 6, "logoURI": "https://raw.githubusercontent.com/InkySwap/token-logos/main/usdc.png" }, { "chainId": 57073, "address": "0x1234567890abcdef1234567890abcdef12345678", "symbol": "MEME", "name": "Meme Token", "decimals": 18, "logoURI": "https://supabase.example.com/storage/v1/object/public/images/meme.png" } ] } ``` ```bash cURL theme={null} curl -X GET "https://inkyswap.com/api/tokens" ``` ```typescript TypeScript theme={null} const response = await fetch('https://inkyswap.com/api/tokens'); const tokenList = await response.json(); const tokens = tokenList.tokens.map(token => ({ ...token, })); ``` ```python Python theme={null} import requests response = requests.get("https://inkyswap.com/api/tokens") token_list = response.json() ink_tokens = [ token for token in token_list["tokens"] if token["chainId"] == 57073 ] ``` # MCP Server Source: https://docs.inkyswap.com/api-reference/mcp Launch InkyPump V2 tokens from Claude Code, Codex, or any other MCP-aware client InkyPump ships a [Model Context Protocol](https://modelcontextprotocol.io) server so that an LLM client (Claude Code, Codex CLI, Cursor, etc.) can create tokens, preview launch economics, and read live launch state through structured tools, without leaving the editor. The MCP signs `createLaunch` transactions with a hot wallet whose private key the operator supplies. Always load a **burner** wallet with only enough ETH for prebuys + gas. Writes are **off by default**. You must opt in explicitly per environment. ## Tools | Tool | Purpose | | ----------------- | -------------------------------------------------------------------------------------------------------------------------- | | `launch_token` | Broadcasts `createLaunch` / `createLaunchWithReferral` on the InkyPump V2 hook. Requires explicit confirm + writes opt-in. | | `preview_launch` | Dry-run: resolves on-chain params and reports expected creator-fee economics. No transaction. | | `wallet_info` | Returns the MCP signer address and its current Ink ETH balance. | | `recent_launches` | Fetches recent V2 launches. Returns a sanitized, allowlisted field set. | | `launch_status` | Reads `getLaunchState(launchId)` and reports funding progress. | ## Install The MCP is published to npm as [`@inkyswap/pump-mcp`](https://www.npmjs.com/package/@inkyswap/pump-mcp); source lives at [InkySwap/pump-mcp](https://github.com/InkySwap/pump-mcp). `npx` handles the install and update for you. No clone or build required. ```bash theme={null} umask 077 printf '%s' '0xYOUR_BURNER_PRIVATE_KEY' > ~/.inkypump-mcp-key chmod 600 ~/.inkypump-mcp-key ``` The MCP refuses to read this file if it's group- or world-readable. ```bash theme={null} claude mcp add inkypump \ -e INKYPUMP_MCP_PRIVATE_KEY_FILE=$HOME/.inkypump-mcp-key \ -e INKYPUMP_MCP_ENABLE_WRITES=true \ -s user \ -- npx -y @inkyswap/pump-mcp ``` For **Codex CLI**, drop the equivalent block into `~/.codex/config.toml`: ```toml theme={null} [mcp_servers.inkypump] command = "npx" args = ["-y", "@inkyswap/pump-mcp"] [mcp_servers.inkypump.env] INKYPUMP_MCP_PRIVATE_KEY_FILE = "/Users/you/.inkypump-mcp-key" INKYPUMP_MCP_ENABLE_WRITES = "true" ``` Prefer to run from source? Clone [InkySwap/pump-mcp](https://github.com/InkySwap/pump-mcp) and run `bun install --frozen-lockfile && bun run build && node dist/index.js`. ## Environment | Variable | Default | Required | Purpose | | ------------------------------- | -------------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------- | | `INKYPUMP_MCP_PRIVATE_KEY_FILE` | n/a | one of these two | Path to a `chmod 600` file containing the hex private key. **Preferred.** POSIX mode check skipped on Windows. | | `INKYPUMP_MCP_PRIVATE_KEY` | n/a | one of these two | Raw hex private key. Stored plaintext in your MCP config, only use if that config is encrypted. | | `INKYPUMP_MCP_ENABLE_WRITES` | `false` | yes for `launch_token` | Must be `true` / `1` / `yes` to permit broadcasting transactions. | | `INKYPUMP_MCP_MAX_PREBUY_ETH` | `0.1` | no | Per-call cap on prebuy ETH. Operator hard limit. | | `INKYPUMP_MCP_MAX_RAISE_ETH` | `5` | no | Per-call cap on `targetRaiseEth`. Defaults to the contract max. | | `INKYPUMP_MCP_MAX_GAS_GWEI` | `100` | no | Per-call cap on `maxFeePerGas` in gwei. Defends against an RPC reporting inflated fees. | | `INKYPUMP_MCP_RPC_URL` | `https://rpc-gel.inkonchain.com` | no | Override the Ink RPC endpoint. Rejected if it contains userinfo, query, or fragment. | | `INKYPUMP_BASE_URL` | `https://inkypump.com` | no | Origin used to build trade URLs and call `/api/tokens/recent-v2`. Must be an origin (no path). | ## Safety model The MCP signs on-chain transactions, so it's treated as a hot-wallet boundary. Defense in depth, in order: `launch_token` refuses unless `INKYPUMP_MCP_ENABLE_WRITES=true`. The read-only tools always work. Every `launch_token` call requires `confirm: "YES"`. The LLM must include it deliberately. Hallucinated calls fail closed. `MAX_PREBUY_ETH`, `MAX_RAISE_ETH`, and `MAX_GAS_GWEI` clamp every write regardless of what the LLM or the RPC passes. Every write checks the RPC reports chain ID 57073 before signing. Defends against a hijacked or misconfigured `INKYPUMP_MCP_RPC_URL`. Every write pins the nonce via `getTransactionCount({ blockTag: "pending" })` and times out the receipt wait at 120s with no retries. Tool errors are stripped of private keys, signed-tx payloads, URL credentials, and RPC API keys in the path before reaching the model. `recent_launches` allowlists fields, clips strings, re-validates image URLs, and warns the model the data is creator-controlled. Image and social URLs must be `https://`, must not use reserved TLDs (`.local`, `.internal`, `.localhost`, `.test`, `.example`, `.invalid`), and must resolve via DNS to a public IP (covers RFC1918, loopback, link-local, CGNAT, IPv6 unique-local, hex-form IPv4-mapped). ## Example session ```text theme={null} > wallet_info { "address": "0x…", "balanceEth": "0.4", "chainId": 57073 } > preview_launch { "name": "Anita", "ticker": "ANITA", "description": "Test launch", "imageUrl": "https://example.com/anita.png", "targetRaiseEth": 3, "curveGainMultiplier": 6, "creatorFeeSplitBps": 5000 } { "feeMath": { "creatorEarningsAsPctOfVolume": 0.495, "protocolFeePct": 1, "variableFeePctOfAfterProtocol": 1 }, ... } > launch_token { …same args plus "confirm": "YES" } { "transactionHash": "0x…", "tokenAddress": "0x…", "tradeUrl": "https://inkypump.com/trade/0x…", "explorerUrl": "https://explorer.inkonchain.com/tx/0x…" } ``` ## `launch_token` parameters Token display name (1-48 chars). Ticker symbol without `$` (1-12 chars). Short pitch (1-500 chars). Public square image. Rejected if the URL is non-https, contains credentials, uses a reserved TLD, or resolves to a private IP. 1-5 ETH. Bounded further by `INKYPUMP_MCP_MAX_RAISE_ETH`. Must be the literal string `"YES"`. This is the final-write gate. Optional. Empty string disables. Optional. Empty string disables. Optional. Empty string disables. End/start price ratio. 1 = flat, 21 = contract max. Creator share of variable fee in bps. 5000 = 50/50 with burn, 10000 = all creator. Anti-snipe duration. 0 disables. Unix start timestamp. 0 = launch immediately. Creator prebuy. Must be ≤ `targetRaiseEth` and ≤ `INKYPUMP_MCP_MAX_PREBUY_ETH`. Optional. Alphanumeric (with `-` / `_`), 1-64 chars. ## Contract surface `launch_token` calls these functions on the `InkyPumpHook` contract: * `createLaunch(CreateLaunchParams)` when `referralCode` is empty * `createLaunchWithReferral(CreateLaunchParams, string)` otherwise Both are documented in detail in the [contracts integration guide](/api-reference/contracts/integration-guide). # API Overview Source: https://docs.inkyswap.com/api-reference/overview What APIs InkyPump exposes and which one to use for what. InkyPump exposes three things you can integrate against: 1. The V2 smart contracts on Ink mainnet 2. The InkyPump REST API at `inkypump.com` 3. The InkyPump MCP server, a stdio server for editors like Claude Code and Codex Pick based on what you are building. ## When to use each | You want to... | Use | | ------------------------------------------------ | ------------------------------------------------- | | Read token state, list tokens, fetch leaderboard | [InkyPump REST API](#inkypump-rest-api) | | Launch or trade tokens from a backend | [V2 contracts](/api-reference/contracts/overview) | | Read swap quotes for the broader InkySwap DEX | [InkySwap REST API](#inkyswap-rest-api) | | Drive InkyPump from your editor or an AI agent | [MCP server](/api-reference/mcp) | ## V2 contracts Direct contract integration. Read state, broadcast trades, listen for events. | Resource | Address (Ink mainnet) | | ---------------- | -------------------------------------------- | | InkyPump V2 hook | `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` | | RPC | `https://rpc-gel.inkonchain.com` | For full surface and examples, see [Contracts Overview](/api-reference/contracts/overview). ## InkyPump REST API JSON over HTTPS at `https://inkypump.com`. No auth required for read endpoints. Image uploads require a captcha token. | Endpoint | Returns | | --------------------------------------------- | ---------------------------------------------------- | | `GET /api/tokens/recent-v2?limit=N` | Recently launched V2 tokens | | `GET /api/token?address=0x...` | Token details, V1 or V2 | | `GET /api/tokens/by-owner?owner=0x...` | Tokens created by an address | | `GET /api/tokens/batch?addresses=0x...,0x...` | Token details for a list of addresses | | `GET /api/leaderboard?limit=N` | Aggregated points and rankings | | `GET /api/referral/stats?address=0x...` | Referral attribution stats for a wallet | | `GET /api/eoti` | Current Emperor of the INK | | `GET /api/eoti?includeBidData=true` | Current Emperor plus open auction bid data | | `GET /api/koti` | Current King of the INK (top performing curve) | | `POST /api/upload` | Image upload (token logos, requires Turnstile token) | | `GET /api/chat?tokenAddress=0x...&limit=N` | Token chat messages | See the [InkyPump API](/api-reference/inkypump/get-token) section for per endpoint pages. ## InkySwap REST API Separate from InkyPump. Covers the wider InkySwap DEX on Ink. | Endpoint | Returns | | ----------------- | ------------------------ | | `GET /api/pairs` | InkySwap liquidity pairs | | `GET /api/quote` | Swap quote for the DEX | | `GET /api/tokens` | Listed tokens on the DEX | See [InkySwap API](/api-reference/inkyswap/get-pairs). ## MCP server A stdio MCP at the `@inkyswap/pump-mcp` npm package. Runs locally. Connects to your editor and exposes V2 tools (`launch_token`, `preview_launch`, `wallet_info`, `recent_launches`, `launch_status`). See [MCP Server](/api-reference/mcp). ## Versions The V2 contracts are the current launch system. V1 contracts still respond to read calls. Anything tagged "V2" on this page is the live system. Anything tagged "V1" is documented for compatibility. # Community Resources Source: https://docs.inkyswap.com/community/resources Connect with the InkySwap community and access helpful resources Join our vibrant community to stay updated, get support, and connect with other traders and creators in the InkySwap ecosystem. ## Official Channels **Main Community Hub** * 24/7 community support * Real-time announcements * Trading discussions * Token launch alerts * Direct team interaction Join: [@inkyswap](https://t.me/inkyswap) **Latest Updates & News** * Platform announcements * Feature releases * Market insights * Educational content * Community highlights Follow: [@inkyswap](https://twitter.com/inkyswap) ## Developer Resources **Build on InkySwap** * REST API endpoints * WebSocket connections * Code examples * Rate limiting info * Integration guides **Technical Support** * API access requests * Bug reports * Integration help * Custom solutions Contact: @emperoroftheink on Telegram ## Platform Links **Token Launch Platform** * Create new tokens * Trade on bonding curves * Emperor auctions * Post-bond trading **Decentralized Exchange** * Swap tokens * Provide liquidity * View Vision * Portfolio tracking **Learn & Explore** * Getting started guides * Trading tutorials * API reference * FAQ & glossary ## Educational Content ### Getting Started Start with our [Introduction](/getting-started/introduction) to understand the platform Explore our [Trading Guide](/trading/getting-started) for detailed instructions Follow the [Token Creation Guide](/token-creation/getting-started) to launch your project Understand the [Referral Program](/rewards/referral) to maximize earnings ### Video Tutorials Video tutorials coming soon! Follow our Twitter for announcements. ## Community Guidelines ### Code of Conduct * Treat all community members with respect * No harassment, discrimination, or hate speech * Be patient with newcomers * Help others when you can * No unsolicited DMs or promotions * Don't share referral codes excessively * Report suspicious activity immediately * Never ask for private keys or seeds * Share valuable insights and information * Ask questions after checking FAQ first * Provide constructive feedback * Celebrate community wins * No market manipulation * Don't spread FUD or false information * DYOR (Do Your Own Research) * Not financial advice ## Safety & Security **Beware of Scams**: Official team members will NEVER DM you first or ask for private keys, seed phrases, or funds. ### Staying Safe * Only use links from this documentation * Check for verified badges on social media * Confirm admin/mod status in Telegram * Verify contract addresses on explorer * Never share seed phrases * Use hardware wallets for large amounts * Double-check transaction details * Keep software updated ### Report Issues If you encounter: * Scams or impersonators * Bugs or technical issues * Suspicious tokens or activity * Community guideline violations **Report immediately to:** * Telegram admins in [@inkyswap](https://t.me/inkyswap) * Technical issues to @emperoroftheink * Security concerns privately to team ## Tools & Utilities ### Essential Tools **Ink Explorer** * Verify transactions * Check contract details * View token holdings * Track wallet activity **DexScreener** * Real-time price charts * Volume analytics * Liquidity metrics * Trading history **Built-in Tracking** * View your holdings * Track P\&L * Transaction history * Points earned **Network Status** * Current gas prices * Network congestion * Optimal timing * Fee estimates ## Partnerships & Integrations Interested in partnering with InkySwap? Contact @emperoroftheink on Telegram to discuss integration opportunities. ### Current Integrations * **Kraken**: Operating on Ink L2 * **WalletConnect**: 300+ wallet support * **Cloudflare**: Security and protection * **DexScreener**: Price data integration ### Integration Opportunities * Trading bots and automation * Analytics platforms * Portfolio managers * DeFi aggregators * Educational platforms ## Stay Updated ### Newsletter Newsletter coming soon! Follow our Twitter [@inkyswap](https://twitter.com/inkyswap) for launch announcement. ### Important Links Summary | Platform | Link | Purpose | | --------------- | ----------------------------------------- | ------------------- | | **Telegram** | [@inkyswap](https://t.me/inkyswap) | Community & Support | | **Twitter** | [@inkyswap](https://twitter.com/inkyswap) | News & Updates | | **InkyPump** | [inkypump.com](https://inkypump.com) | Token Creation | | **InkySwap** | [inkyswap.com](https://inkyswap.com) | Token Trading | | **Dev Contact** | @emperoroftheink | Technical Support | ## Contributing ### How to Contribute Found an issue? Report it to @emperoroftheink with details Share ideas in our Telegram community or with the dev team Write guides, make videos, or create educational content Develop trading bots, analytics tools, or integrations using our API ### Recognition Program Active community contributors may receive: * Special roles in Telegram * Early access to features * Bonus points for airdrop * Direct team access * Community shoutouts ## Emergency Contacts For urgent issues: **Critical Issues Only** * Platform down: Check Twitter [@inkyswap](https://twitter.com/inkyswap) * Security breach: DM @emperoroftheink immediately * Lost funds: Transaction hash to support * Contract issues: Verify on block explorer first **Response Times:** * Critical: \< 1 hour * High: \< 4 hours * Normal: \< 24 hours Remember: The InkySwap community is here to help! Don't hesitate to ask questions and engage with fellow traders and creators. # About Us Source: https://docs.inkyswap.com/company/about-us What InkyLabs builds and how the platform works. InkyLabs builds InkyPump and InkySwap, two products that share infrastructure on Ink mainnet. * **InkyPump** is the token launch platform. Creators raise ETH through a bonding curve and tokens bond to a Uniswap V4 pool after the raise. See [Introduction](/getting-started/introduction). * **InkySwap** is the wider decentralized exchange on Ink. It hosts trading for tokens beyond just InkyPump launches. Both run on Ink mainnet (chain 57073), Kraken's Layer 2 built on Ethereum. ## How the platform stays trustless The launch contract is a UUPS proxy. State is held by the proxy, logic by separately upgradeable modules. There are no admin keys that can drain user funds. The initial pool seed at bonding is held by the hook and is not withdrawable. ## What we work on | Area | What it covers | | --------------- | ----------------------------------------------------------------------- | | Smart contracts | The V2 hook, modules, and curve math | | Indexer | Reads on chain events and exposes them through REST and the InkyPump UI | | Frontend | The inkypump.com web app and PWA | | MCP server | Editor and agent integration for developers | ## Contact * Telegram: [@inkyswap](https://t.me/inkyswap) for community and support * X: [@inkyswap](https://x.com/inkyswap) for updates * Developer contact: [@emperoroftheink](https://t.me/emperoroftheink) on Telegram # Brand Kit Source: https://docs.inkyswap.com/company/brand-kit Official branding guidelines and resources for InkySwap ## Our Brands InkySwap is a decentralized exchange platform that makes DeFi trading simple and efficient. InkyPump is a unique token pump mechanism designed to enhance price action through community participation. ## Brand Guidelines When using our brand assets, please follow these guidelines: * Use our logo as provided without alterations * Don't imply unauthorized partnerships or relationships * Don't use our brand for illegal activities * Don't combine our logo with other images without consent ## Logo Usage Our logo must be used according to these specifications: * Always use the official logo files as provided * Maintain adequate spacing around the logo * Use only approved color variations * Ensure minimum size requirements for legibility ## Brand Assets Access our official brand assets including logos, color palettes, and typography guidelines: [Download Brand Kit](https://www.inkypump.com/assets/brand-kit.pdf) # Privacy Policy Source: https://docs.inkyswap.com/company/privacy-policy How we handle and protect your information Last updated: Sun 5 Jan 2025 ## Information We Collect Public wallet addresses and transaction data visible on the blockchain. Information about how you interact with our platform, including trading history and liquidity provisions. ## How We Use Your Information To operate, maintain, and improve our platform To protect against fraudulent or unauthorized transactions To send important updates and announcements To analyze usage patterns and improve user experience We never collect or store private keys or seed phrases. # Terms of Service Source: https://docs.inkyswap.com/company/terms-of-service Guidelines and rules for using InkyLabs Last updated: Sun 5 Jan 2025 ## Service Agreement By accessing or using InkyLabs, you agree to be bound by these terms and all applicable laws and regulations. Our services are provided "as is" without any warranties, expressed or implied. ## User Responsibilities Users are responsible for maintaining the security of their wallet and credentials. Users agree to use the platform for legitimate purposes only. Users understand and accept the risks associated with decentralized finance. ## Trading Rules Users must engage in fair trading practices Users acknowledge the inherent risks in cryptocurrency trading Users agree to pay applicable platform fees Users understand transactions are governed by smart contracts ## Platform Rights We reserve the right to: * Modify or discontinue services * Update terms and conditions * Take action against policy violations * Implement emergency security measures Violation of these terms may result in restriction or termination of platform access. ## Disclaimer Cryptocurrency trading involves substantial risk. Always conduct your own research and trade responsibly. # Introduction Source: https://docs.inkyswap.com/getting-started/introduction What InkyPump is, how V2 works, and where to go next. InkyPump is a token launch platform on Ink mainnet (chain 57073). You can create a token, raise ETH through a bonding curve, and have it bond to a Uniswap V4 pool when the curve fills. The platform is at [inkypump.com](https://inkypump.com). ## What you can do | Action | Where | | -------------------------- | --------------------------------------------------------------------------- | | Launch a token | [Create page](https://inkypump.com/create) or `createLaunch` on the V2 hook | | Trade tokens on a curve | Token's trade page or `buy` and `sell` on the V2 hook | | Trade tokens after bonding | Token's trade page or Uniswap Universal Router | | Earn from your token | Variable fee split, withdrawn with `withdrawFees` | | Refer trades and launches | Share `?ref=` URLs, points accrue automatically | | Launch from your editor | The [InkyPump MCP server](/api-reference/mcp) | ## Versions InkyPump V2 is the current launch system. It launched on Ink mainnet with a flat 2 percent fee, configurable curve gain, captcha based anti-snipe, on chain referral attribution, and bonding to Uniswap V4. V1 is the original launch system. It is deprecated. V1 tokens still trade through their original contracts and Uniswap V2 pairs. For V1 specifics, see [Legacy](/legacy/overview). ## How V2 works in two minutes 1. A creator launches a token. They pick a target raise (1 to 5 ETH), a curve gain multiplier (1x to 21x), a creator fee split, and an optional anti-snipe window 2. The contract deploys the token and opens trading on a linear bonding curve 3. Traders buy and sell on the curve. Every trade pays 2 percent total fees (1 percent protocol, 1 percent variable to creator and buyback) 4. When the curve raises the target, the contract bonds the token to a Uniswap V4 pool with a 0.1 percent fee 5. Trading continues on the V4 pool. The creator keeps earning through the hook on every V4 swap ## Where to go next Start trading or launching in under a minute. Walkthrough of the V2 launch flow. How buy and sell works on V2. The 2 percent fee structure. V2 contract addresses and function signatures. Drive InkyPump from Claude Code or Codex. # PWA Installation Guide Source: https://docs.inkyswap.com/getting-started/pwa-installation Install InkySwap as a Progressive Web App for a native app experience InkySwap is available as a Progressive Web App (PWA), allowing you to install it on your device for a faster, more native experience with offline capabilities. ## What is a PWA? A Progressive Web App combines the best of web and mobile apps: * **Installable**: Add to your home screen like a native app * **Offline Support**: Works even without internet connection (limited features) * **Fast Loading**: Cached resources for instant loading * **Automatic Updates**: Always get the latest version * **No App Store**: Install directly from your browser ## Installation Instructions Navigate to [https://inkyswap.com](https://inkyswap.com) in Google Chrome Click the install icon in the address bar (looks like a computer with an arrow) Alternatively: * Click the three dots menu (⋮) in the top right * Select "Install InkySwap..." Click "Install" in the popup dialog InkySwap will open in its own window. You can also find it in: * Chrome Apps (chrome://apps) * Your desktop/dock * Start menu (Windows) or Applications folder (Mac) Navigate to [https://inkyswap.com](https://inkyswap.com) in Microsoft Edge Click the install icon in the address bar Alternatively: * Click the three dots menu (⋯) in the top right * Select "Apps" → "Install this site as an app" Optionally customize the app name, then click "Install" Choose to: * Pin to taskbar * Pin to Start * Create desktop shortcut * Auto-start on device login Navigate to [https://inkyswap.com](https://inkyswap.com) in Safari PWA installation only works in Safari on iOS, not in Chrome or other browsers Tap the share icon at the bottom of the screen (square with arrow pointing up) Scroll down and tap "Add to Home Screen" * Edit the name if desired * Tap "Add" in the top right corner * The PWA icon will appear on your home screen Navigate to [https://inkyswap.com](https://inkyswap.com) in Chrome Also works in Edge, Firefox, and Samsung Internet You may see an "Add InkySwap to Home screen" banner at the bottom If not: * Tap the three dots menu (⋮) in the top right * Select "Add to Home screen" or "Install app" * Review the app name * Tap "Add" or "Install" The PWA will appear: * On your home screen * In your app drawer * In recent apps when running Navigate to [https://inkyswap.com](https://inkyswap.com) in Firefox Look for an install icon in the address bar Firefox PWA support is limited. Consider using Chrome or Edge for full PWA features. Install the "Progressive Web Apps for Firefox" extension for better PWA support As an alternative: * Bookmark the site (Ctrl/Cmd + D) * Add to bookmarks toolbar for quick access ## Features Available in PWA ### Full Functionality ✅ Token trading and swapping\ ✅ Token creation and launching\ ✅ Portfolio tracking\ ✅ Chat and social features\ ✅ Wallet connections\ ✅ Real-time price updates ### Enhanced Experience ✅ Faster loading times\ ✅ Full-screen mode\ ✅ App-like navigation\ ✅ Push notifications (coming soon)\ ✅ Offline browsing of cached pages\ ✅ Home screen shortcut ## Managing Your PWA ### Update the App The PWA automatically checks for updates when you open it. Updates are applied in the background. Pull down to refresh (mobile) or press Ctrl/Cmd + R (desktop) to force check for updates. ### Uninstall the App **Chrome/Edge:** 1. Open the PWA 2. Click the three dots menu 3. Select "Uninstall InkySwap..." **Alternative:** * Go to chrome://apps or edge://apps * Right-click InkySwap * Select "Remove from Chrome/Edge" 1. Long press the InkySwap icon on home screen 2. Tap "Remove App" or the (x) button 3. Confirm deletion 1. Long press the InkySwap icon 2. Drag to "Uninstall" or tap "App info" 3. Select "Uninstall" **Alternative:** * Go to Settings → Apps * Find InkySwap * Tap "Uninstall" ## Troubleshooting * Ensure you're using a supported browser (Chrome, Edge, Safari) * Check you're on HTTPS ([https://inkyswap.com](https://inkyswap.com)) * Clear browser cache and cookies * Try incognito/private mode * Wait a few seconds for the install prompt * Close and reopen the app * Clear the app cache in browser settings * Uninstall and reinstall the PWA * Check your internet connection * Ensure your wallet extension is installed in the browser * For mobile, use WalletConnect for best compatibility * Try connecting in the browser first, then in PWA * Clear app data and cache * Ensure you have sufficient storage space * Close other apps to free up memory * Update your browser to the latest version iOS PWAs have some limitations: * No push notifications (yet) * Limited to 50MB cache * Must use Safari for installation * May lose data if unused for weeks ## Benefits of Using the PWA Cached resources mean near-instant loading and smooth navigation Access InkySwap directly from your home screen or desktop Takes up minimal space compared to native apps Automatically stays current with the latest features ## Browser Compatibility | Browser | Desktop | Mobile | PWA Support | | ---------------- | ---------- | ---------- | ----------- | | Chrome | ✅ Full | ✅ Full | Excellent | | Edge | ✅ Full | ✅ Full | Excellent | | Safari | ✅ Full | ✅ iOS only | Good (iOS) | | Firefox | ⚠️ Limited | ⚠️ Limited | Limited | | Brave | ✅ Full | ✅ Full | Excellent | | Opera | ✅ Full | ✅ Full | Good | | Samsung Internet | N/A | ✅ Full | Good | For the best PWA experience, we recommend using Chrome, Edge, or Brave on desktop, and Safari on iOS or Chrome on Android. ## Need Help? If you're experiencing issues with the PWA installation or usage: Join our Telegram: [@inkyswap](https://t.me/inkyswap) Contact: @emperoroftheink on Telegram # Quickstart Source: https://docs.inkyswap.com/getting-started/quickstart From zero to trading or launching on InkyPump V2 in a few minutes. This page covers the three most common starting paths: trading a token, launching a token, and integrating from your editor through the MCP. ## Before you start You need: * A wallet with support for Ink mainnet (chain 57073) * A small amount of ETH on Ink for gas * A browser, or for the integration path, a terminal with Node 22 or later Bridge ETH to Ink at [bridge.inkonchain.com](https://bridge.inkonchain.com) if you do not have any. ## Path 1: Trade a token Go to [inkypump.com](https://inkypump.com). Pick a token from the home page or paste its address. Click Connect, pick your wallet, switch to Ink mainnet. Enter the ETH or token amount. The preview shows expected output, the 2 percent fee, and price impact. Sign in your wallet. The trade lands in the next block. For the full mechanics, see [Trading on InkyPump](/trading/getting-started). ## Path 2: Launch a token [inkypump.com/create](https://inkypump.com/create) Name, ticker, description, image. Optional social links. Pick a target raise between 1 and 5 ETH. Pick a curve gain (1x to 21x). Pick your creator fee split (0 to 100 percent of the 1 percent variable fee). 0, 20, 40, or 60 seconds of captcha protection at launch. Pass the captcha, sign the transaction, land on your token's trade page. For the full walkthrough, see [Create Your Token](/token-creation/getting-started). ## Path 3: Launch from your editor (MCP) If you use Claude Code or Codex CLI, you can run the InkyPump MCP server locally and call its tools directly from your editor. ```bash theme={null} umask 077 printf '0x%s' "$(openssl rand -hex 32)" > ~/.inkypump-mcp-key chmod 600 ~/.inkypump-mcp-key ``` ```bash theme={null} claude mcp add inkypump \ -e INKYPUMP_MCP_PRIVATE_KEY_FILE=$HOME/.inkypump-mcp-key \ -e INKYPUMP_MCP_ENABLE_WRITES=true \ -- npx -y @inkyswap/pump-mcp ``` Read the public address with `wallet_info`, then send ETH to it. Ask the agent to call `launch_token`, `preview_launch`, or `recent_launches`. For the full MCP reference, see [MCP Server](/api-reference/mcp). ## Common questions | Question | Answer | | ---------------------------- | ---------------------------------------------------------------------------------------------------------- | | What chain is InkyPump on? | Ink mainnet, chain ID 57073 | | What is the trade fee? | 2 percent on the curve (1 percent protocol + 1 percent variable). 0.1 percent on the V4 pool after bonding | | Is there a creation fee? | No | | What is the minimum raise? | 1 ETH | | What is the maximum raise? | 5 ETH | | Can I trade V1 tokens? | Yes. V1 tokens still trade through their original contracts. See [Legacy](/legacy/overview) | | Is the platform open source? | Contracts and indexer are public. See [Community](/community/resources) for links | # V1 Contracts Source: https://docs.inkyswap.com/legacy/contracts Deployed contract addresses for the V1 InkyPump system on Ink mainnet. These are the V1 contracts. They are deprecated and only kept here for reference and to support trading of existing V1 tokens. For new integrations, use the [V2 contracts](/api-reference/contracts/overview). ## TokenFactory (V1) The original launch contract. Used an exponential bonding curve and finalized to Uniswap V2. | | | | ------- | -------------------------------------------- | | Address | `0x1D74317d760f2c72A94386f50E8D10f2C902b899` | | Chain | Ink mainnet (57073) | | Status | Live, no new launches | Tokens launched on this contract still trade through their original Uniswap V2 pair after they bonded. ## Early V4 Hook (transitional) A short lived Uniswap V4 hook that shipped between V1 and the current V2. A small number of tokens launched here. It is still queryable. | | | | ------- | -------------------------------------------- | | Address | `0x4728F37593B7F7091E6208f6518A04aBFeC96Ac4` | | Chain | Ink mainnet (57073) | | Status | Live, no new launches | For docs purposes this is grouped under V1 since it predates the current V2 hook. ## TokenUpdate Used to update metadata on V1 tokens. | | | | ------- | -------------------------------------------- | | Address | `0x330152B13B4ecaE511d1e2a211c6C63CB36be061` | | Chain | Ink mainnet (57073) | ## Uniswap V2 Router (used by V1 finalization) | | | | ------- | -------------------------------------------- | | Address | `0xA8C1C38FF57428e5C3a34E0899Be5Cb385476507` | | Chain | Ink mainnet (57073) | ## V1 Constants These are the constants that V1 launches used. | Constant | Value | | -------------------------------- | --------------------------------------------------------- | | Total supply | 1,000,000,000 tokens | | Liquidity supply (post finalize) | 200,000,000 (20 percent) | | Sale supply (curve) | 800,000,000 (80 percent) | | Funding goal | 3 ETH (hardcoded per token) | | Creation fee | 0.001 ETH | | Anti-snipe window | 25 seconds | | Anti-snipe fee | 30 percent decaying to 5 percent linearly over 25 seconds | | Base fee after window | 5 percent | | Curve type | Exponential, `price = a * e^(b * x)` | | Finalization | Add liquidity to Uniswap V2 pair, burn LP tokens | ## Migration There is no on chain migration path from V1 to V2. V1 tokens stay on V1. New tokens are V2 by default. # Permanent Liquidity (V1) Source: https://docs.inkyswap.com/legacy/lp-burning How V1 handled liquidity through the bonding curve and Uniswap V2 LP burn. This page describes the V1 liquidity model. V2 uses a different mechanic. See [Bonding to Uniswap V4](/token-creation/bonding-to-uniswap-v4) for the current system. ## Two phases of V1 liquidity V1 tokens went through two phases. ### Phase 1: Bonding curve During the curve phase, there was no traditional liquidity pool. The `TokenFactory` contract held all ETH paid in and minted tokens out according to an exponential curve. Price was determined by the curve formula. There was no impermanent loss because there were no LPs. | | | | ------------- | --------------------------------- | | Sale supply | 800,000,000 (80 percent of total) | | Target raise | 3 ETH | | Curve formula | `price = a * e^(b * x)` | ### Phase 2: Uniswap V2 finalization Once a token raised the 3 ETH target, the contract added liquidity to a Uniswap V2 pair and burned the LP tokens. From that point on the token traded on Uniswap V2 like any other token. | | | | ------------------ | ------------------------------------------------- | | Liquidity supply | 200,000,000 (20 percent of total) | | LP burn | 100 percent of LP tokens sent to the zero address | | Trading after bond | Uniswap V2 pair | ## Why LPs were burned Burning the LP tokens removed the ability for anyone to withdraw liquidity. This made the pool permanent. No rug pull is possible because no one holds the LP, including the protocol. ## How to verify a V1 token bonded 1. Look up the token's Uniswap V2 pair on the [Ink explorer](https://explorer.inkonchain.com) 2. Check that the LP token balance of the burn address (`0x000000000000000000000000000000000000dEaD` or `0x0`) equals the total LP supply 3. Confirm the pair has ETH and the token in its reserves ## How V2 differs V2 does not use Uniswap V2 or burn LP tokens. V2 bonds to a Uniswap V4 pool with a hook. The mechanic and the post bond fee model are different. See [Bonding to Uniswap V4](/token-creation/bonding-to-uniswap-v4). # Legacy (V1) Overview Source: https://docs.inkyswap.com/legacy/overview V1 is the original InkyPump launch system. It is deprecated. Use V2 for new launches. This section covers the deprecated V1 system. V1 tokens still trade on chain, but new launches use V2. See the [Token Creation](/token-creation/getting-started) and [Trading](/trading/getting-started) sections for the current system. ## What V1 is V1 was the original InkyPump launch system on Ink. It used a single `TokenFactory` contract with an exponential bonding curve. Tokens finalized to a Uniswap V2 liquidity pair after raising 3 ETH. There was an anti-snipe mechanic that decayed fees from 30 percent to 5 percent over the first 25 seconds. V1 also includes an early Uniswap V4 hook deployment that shipped briefly before being replaced by the current V2 hook. Both are documented here as legacy. ## What still works on V1 * Buying and selling V1 tokens still works through the original V1 contracts and the existing Uniswap V2 pairs * V1 tokens still appear in the InkyPump UI when you visit their trade page * The leaderboard still counts V1 trade volume (with the V1 fee model, the volume points formula is `volume / 95 * 100`) ## What does not work on V1 * New token launches no longer route to V1. The Create flow creates V2 tokens * V1 boost auctions still operate on the same `TokenBoosted` contract (it is shared with V2) ## Where to go next Side by side comparison of every mechanic that changed. Contract addresses for the V1 era. How V1 handled liquidity through the bonding curve. The current launch system. # V1 vs V2 Source: https://docs.inkyswap.com/legacy/v1-vs-v2 Side by side comparison of the V1 and V2 launch systems. V2 is the current launch system. V1 is deprecated. This page exists to help V1 token holders and integrators understand what changed. ## Quick comparison | Topic | V1 | V2 | | ----------------------- | ------------------------------------------------- | ---------------------------------------------------------------------- | | Launch contract | `TokenFactory` (single contract) | `InkyPumpHook` (UUPS proxy) with swappable modules | | Launch contract address | `0x1D74317d760f2c72A94386f50E8D10f2C902b899` | `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` | | Curve type | Exponential, `price = a * e^(b * x)` | Linear with configurable gain multiplier (1x to 21x) | | Target raise | 3 ETH (hardcoded) | Configurable per launch, 1 to 5 ETH | | Creation fee | 0.001 ETH | None | | Base trade fee | 5 percent | 2 percent (1 percent protocol + 1 percent variable) | | Anti-snipe | Fee decay 30 percent to 5 percent over 25 seconds | Captcha gate for 0 to 60 seconds (no fee penalty) | | Creator earnings | Built into the 5 percent fee | Configurable share of the 1 percent variable fee | | Finalization | Add to Uniswap V2 pair, burn LP | Bond to a Uniswap V4 pool with a 0.1 percent swap fee | | Architecture | Monolithic | Modular: separate Hook, TradingModule, ViewModule, SaleSplitCalculator | | Upgradeability | UUPS proxy on one contract | UUPS proxy with separately upgradeable modules | | Referrals on chain | Event field on every trade | Separate `Referral` event emitted only when referral code is present | ## Fee math compared V1 (after the 25 second anti-snipe window): ``` fee = ethIn * 0.05 netForCurve = ethIn - fee ``` V2 (constant for the full token lifetime, regardless of when you trade): ``` protocolFee = ethIn * 0.01 variableFee = ethIn * 0.01 netForCurve = ethIn - protocolFee - variableFee // 98 percent creatorShare = variableFee * (creatorFeeSplitBps / 10000) buybackShare = variableFee - creatorShare ``` ## What stayed the same * Total supply is still 1,000,000,000 tokens * Tokens still bond from an initial sale pool to an automated market maker * The `tokens_v2` table in the API still returns the same shape for V2 tokens that the `tokens` table did for V1, with extra V2 fields added * The leaderboard still counts trade volume across both versions, with separate formulas * The Emperor of the INK auction still works for any token, V1 or V2 ## What is new in V2 * Per launch target raise (1 to 5 ETH) * Per launch curve steepness (1x to 21x gain multiplier) * Configurable creator vs buyback fee split, updatable after launch * Optional anti-snipe window with captcha gate * Scheduled launches (set a start time in the future) * Optional creator prebuy at launch * On chain referral attribution via a dedicated event ## Should you migrate There is no migration path. V1 tokens stay on V1 contracts and continue to trade. V2 is for new launches. # Leaderboard Source: https://docs.inkyswap.com/rewards/leaderboard How points are earned across InkyPump V1, V2, and InkySwap LP. The InkyPump leaderboard counts three categories of points and combines them into a single ranking. ## What gets counted | Category | Source | What earns points | | ----------------------- | --------------------- | ------------------------------------------------------ | | InkyPump trading points | V1 and V2 trades | ETH volume traded, with a multiplier for the fee model | | InkySwap points | InkySwap V4 swaps | ETH volume swapped on the broader InkySwap DEX | | LP points | InkySwap LP provision | Time weighted liquidity provided to InkySwap pools | The leaderboard adds the three categories together for the total ranking. Each category is also visible separately in the UI. ## How V1 and V2 trading points differ V1 and V2 had different fee models. The point formula adjusts so the points earned reflect the gross volume, not the net of fees. | Version | Fee | Formula (gross volume per ETH spent) | | ------- | --------- | ------------------------------------ | | V1 | 5 percent | `ethSpent * 100 / 95` | | V2 | 2 percent | `ethSpent * 100 / 98` | This means a 1 ETH trade on V2 counts more in volume than a 1 ETH trade on V1 because the V2 trade paid less in fees. The leaderboard shows the resulting points number directly. You do not need to do the math yourself. ## Referral points A separate referral category counts points earned by referring trades. When someone trades using your referral code, you accrue points equal to a fraction of their volume. This is computed off chain by the InkyPump backend from the on chain `Referral` events emitted by V2 trades. V1 trades also count for referrals if the user passed a referral code on the legacy contract. For mechanics, see [Referrals](/rewards/referral). ## Token creation points Creating a launch awards a flat creation bonus. Creating a launch with a valid referral code awards an additional bonus to the referrer. ## Where the data comes from The leaderboard updates as soon as new trades are indexed. * V2 events are indexed from the InkyPump V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` * V1 events are indexed from the legacy `TokenFactory` at `0x1D74317d760f2c72A94386f50E8D10f2C902b899` * InkySwap LP and swap events come from the wider InkySwap V4 deployment ## API To pull the leaderboard data into your own application, use the [GET /api/leaderboard](/api-reference/inkypump/leaderboard) endpoint. It returns the same data the UI renders. ## Reset and snapshots The leaderboard is cumulative. There is no reset. For ranked events or seasonal competitions, InkyPump runs separate snapshots that capture point balances at a fixed time. Those are announced on the [InkyPump Telegram](https://t.me/inkyswap) and [X](https://x.com/inkyswap) when they happen. # Referral Program Source: https://docs.inkyswap.com/rewards/referral How referral links work, how points get attributed, and what users see. When someone uses your referral link and then trades on InkyPump, you earn points on their trade volume. Referrals work for both V1 and V2 trades. They also work for token launches. ## How to share a referral link Your referral code is your wallet address or a short alias you set on your account page. To refer someone, send them either: ``` https://inkypump.com/?ref= https://inkypump.com/join/ ``` Both work the same way. The `/join/` route is meant for short links and message embedding. It stores the code in their browser and redirects to the home page. ## What happens when they visit When a new visitor opens an InkyPump URL with your referral code, the site middleware stores the code in their browser's local storage under the key `ref`. From that point on, every trade and every token launch they make through the UI passes your code to the contract. The user sees no difference in the UI. There is no banner. There is no obligation to use the link a second time. The code stays in their local storage and applies to every future trade. The code persists until they clear browser storage or open the site with a different `?ref=` value, which overwrites it. ## What gets attributed to you | Action | What you earn | | ----------------------------------------------------- | --------------------------------------------------------- | | They trade a V2 token with your code in local storage | Referral points equal to a fraction of their trade volume | | They trade a V1 token with your code | Same, on the V1 trade volume | | They launch a V2 token with your code | A flat referral bonus on the launch | The exact share is computed off chain by the InkyPump backend. It is a multiplier on the volume points the trader themselves earn. ## How it works on chain On V2, when a trader passes a referral code, the UI calls `buyWithReferral`, `sellWithReferral`, or `createLaunchWithReferral` on the InkyPump V2 hook. The contract emits a `Referral(launchId, trader, referralCode)` event in addition to the normal `Trade` or `LaunchCreated` event. ```solidity theme={null} event Referral( uint256 indexed launchId, address indexed trader, string referralCode ); ``` The InkyPump indexer joins these events to the corresponding trade and credits points to the wallet behind the code. On V1, the referral string was a parameter on every trade event. The indexer reads it directly from the V1 event log. ## What is not on chain * No fee discount for using a referral * No on chain payout. The referrer's points are tracked off chain * No validation of the code. Any string is accepted by the contract ## Where to see your stats On your account page on inkypump.com, the Team tab shows: * Total referrals * Number of unique referees * Total volume from referees * Total referral points earned The data updates as new trades land and get indexed. ## API To pull referral data programmatically, see [GET /api/referral/stats](/api-reference/inkypump/referral). # Frequently Asked Questions Source: https://docs.inkyswap.com/support/faq Common questions about InkyPump V2 and InkySwap. Cannot find what you are looking for? Join the [Telegram community](https://t.me/inkyswap) for support. ## General InkyPump is a token launch platform on Ink mainnet. You create a token, raise ETH through a bonding curve, and the token automatically bonds to a Uniswap V4 pool when the curve fills. The platform is at [inkypump.com](https://inkypump.com). V2 is the current launch system. It has a flat 2 percent fee, configurable curve gain, captcha based anti-snipe, on chain referral attribution, and bonds to Uniswap V4. V1 was the original system with a 5 percent fee, an exponential curve, and Uniswap V2 bonding. V1 is deprecated. See [V1 vs V2](/legacy/v1-vs-v2) for a detailed comparison. Ink mainnet. Chain ID 57073. RPC at `https://rpc-gel.inkonchain.com`. Block explorer at [explorer.inkonchain.com](https://explorer.inkonchain.com). The V2 contracts have been reviewed. The launch contract is a UUPS proxy with separately upgradeable modules. The proxy is at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`. There are no admin keys that can drain user funds. Anyone can verify the contract source on [explorer.inkonchain.com](https://explorer.inkonchain.com). ## Token Creation Go to [inkypump.com/create](https://inkypump.com/create), connect a wallet on Ink mainnet, fill in the name, ticker, description, and image. Pick a target raise between 1 and 5 ETH. Confirm. The token launches immediately or at a scheduled time. See [Create Your Token](/token-creation/getting-started). There is no creation fee on V2. You pay gas for the launch transaction. If you choose to prebuy, you pay the prebuy ETH on top. A bonding curve is a smart contract that prices tokens based on how many have already been sold. V2 uses a linear curve. You choose a gain multiplier from 1x (flat) to 21x (steep) at launch. The curve runs until the target ETH is raised. See [Bonding Curve](/token-creation/bonding-curve). The token bonds to a Uniswap V4 pool. The raised ETH is paired with the liquidity portion of the supply, the pool opens, and trading moves from the curve to the V4 pool. The V4 pool charges 0.1 percent on swaps. See [Bonding to Uniswap V4](/token-creation/bonding-to-uniswap-v4). Yes. Set `startTime` on `CreateLaunchParams` to a future Unix time. The contract accepts buys and sells only after that time. ## Trading On the curve: only on InkyPump through the V2 hook. After bonding: through the InkyPump UI or directly on the Uniswap V4 pool. Both routes use the same liquidity. On the V2 curve: 2 percent total (1 percent protocol, 1 percent variable to creator and buyback). After bonding on the V4 pool: 0.1 percent. There is no fee decay or time based fee math. The 2 percent is constant for the curve's lifetime. A captcha gate that runs for 0 to 60 seconds after launch. During the window, trades require a captcha signature. The InkyPump UI handles the signature automatically. Direct contract calls without the signature revert. It is not a fee penalty. See [Anti-Snipe](/token-creation/anti-snipe). Common causes: insufficient ETH for gas, slippage tolerance too tight, the launch has not started yet (scheduled launch), the launch already bonded (use the V4 pool), or you are in the anti-snipe window without using the UI. Anything that supports Ink mainnet through WalletConnect or direct integration. MetaMask, Rabby, Coinbase Wallet, Kraken Wallet, Phantom, Trust Wallet, and the rest of the WalletConnect ecosystem. ## Emperor of the INK A daily Dutch auction for premium homepage placement on inkypump.com. The winning token gets 24 hours featured at the top. Works for both V1 and V2 tokens. See [Emperor of the INK](/trading/boosted-token). Starts at 0.1 ETH and decays by 0.05 ETH per day until someone bids. Floor is 0.05 ETH. After a winning bid, the next auction starts at 2x the winning amount. ## Rewards and Referrals Through trade volume (both V1 and V2), through launching tokens (small bonus), through referrals (referrer earns when their referees trade), and through InkySwap LP. See [Leaderboard](/rewards/leaderboard). Share a URL with `?ref=` or `/join/`. When someone trades or launches after visiting your URL, you accrue points off the volume they generate. The InkyPump backend reads on chain `Referral` events emitted by V2 trades. See [Referrals](/rewards/referral). No. Referrals are tracking only. There is no fee discount and no fee penalty for using or not using a referral code. The 2 percent trade fee is the same either way. ## API and Integration Yes. Three options: direct contract calls on the V2 hook, the InkyPump REST API at `inkypump.com`, and the [MCP server](/api-reference/mcp) for editor or agent integration. See [API Overview](/api-reference/overview). Yes. Both V1 and V2 contracts are public and any wallet can trade against them. The anti-snipe captcha gate means bots cannot front run launches in the first 0 to 60 seconds. Outside that window, bot trading is unrestricted. Use the [InkyPump MCP server](/api-reference/mcp). It wraps `createLaunch` and the preview functions for use from Claude Code, Codex, or any MCP compatible client. ## Liquidity and Security On V2: the bonding curve holds all ETH until the token bonds. At bonding, the contract creates the V4 pool and seeds it. The seed is held by the InkyPump hook and is not withdrawable. The token contract has no admin minter. There is no key that can drain user funds. Yes. The pool seed created at bonding is held by the InkyPump hook and is not withdrawable by anyone, including the InkyPump team. The hook collects swap fees and routes them to creators and buyback, but the principal liquidity stays in the pool. If you added a concentrated liquidity position to the V4 pool after bonding, yes. Your position is yours and you can withdraw it any time. The initial pool seed is not a withdrawable LP position. ## Mobile InkyPump runs as a Progressive Web App. Install from your mobile browser. No app store install needed. See [PWA Installation](/getting-started/pwa-installation). ## Contact Live support and announcements. Platform updates and news. Telegram: @emperoroftheink for API access, technical issues, partnership inquiries. Full API and contract reference. # Glossary Source: https://docs.inkyswap.com/support/glossary Terms used across InkyPump V2 and InkySwap. ## A **Address.** A unique identifier for wallets and smart contracts on the blockchain. Looks like `0x1234...abcd`. **Anti-snipe.** A captcha gate on V2 launches that runs for 0 to 60 seconds after launch. Buys and sells during the window require a captcha signature. Not a fee penalty. See [Anti-Snipe](/token-creation/anti-snipe). **AMM (Automated Market Maker).** A protocol that prices assets through a formula instead of an order book. V2 tokens trade on a Uniswap V4 pool after bonding. ## B **Bonding curve.** The mathematical curve that prices a token while it raises ETH. V2 uses a linear curve with a configurable gain multiplier (1x to 21x). The curve runs until the target raise is met, then the token bonds to a Uniswap V4 pool. See [Bonding Curve](/token-creation/bonding-curve). **Bond event.** The moment a token's bonding curve fills and the contract migrates liquidity to a Uniswap V4 pool. Happens automatically in one transaction. **Buyback.** A portion of the variable fee that buys and burns the token from the curve or the V4 pool. Configurable per launch (`creatorFeeSplitBps`). ## C **Captcha auth.** The signed token required by the V2 hook during the anti-snipe window. The InkyPump UI fetches it automatically. **Cloudflare Turnstile.** The captcha system used for the launch creation form to prevent automated launches. **Creator fee split (`creatorFeeSplitBps`).** A number from 0 to 10000 set by the creator at launch. Controls how much of the 1 percent variable fee goes to the creator versus the buyback. Updatable after launch by the creator. ## D **DEX (Decentralized Exchange).** A peer to peer marketplace where transactions happen directly between traders. InkySwap is a DEX. V2 tokens trade on a Uniswap V4 pool after bonding. **Dutch auction.** An auction where the price starts high and decreases over time. Used for Emperor of the INK selection. ## E **Emperor of the INK (EOTI).** The daily featured token on InkyPump's homepage, selected through a Dutch auction. Works for both V1 and V2 tokens. See [Emperor of the INK](/trading/boosted-token). **Event (on chain).** A log emitted by a contract. V2 emits `LaunchCreated`, `Trade`, `Referral`, `LaunchFinalized`, and others. Used by indexers to track activity. ## F **Finalization (or bonding).** The transaction in which a token's curve closes and a Uniswap V4 pool is created and seeded. **Funding progress.** The percentage of the target raise that has been raised so far. Shown on the trade page. ## G **Gain multiplier (`gainBps`).** Controls how steep the V2 bonding curve is. 1x is flat. 21x is the maximum. The contract field is in bps so 200,000 corresponds to 21x. **Gas fees.** Transaction costs paid in ETH. Required for every on chain operation. ## H **Hook.** A smart contract on a Uniswap V4 pool that runs custom logic on each swap. The InkyPump V2 hook routes swap fees back to the creator and buyback after a token bonds. ## I **Ink mainnet.** The Layer 2 blockchain where InkyPump runs. Chain ID 57073. **InkyPump.** The token launch platform at [inkypump.com](https://inkypump.com). **InkyPump V2 hook.** The current launch contract at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` on Ink mainnet. **InkySwap.** The wider DEX on Ink, separate from InkyPump. ## K **King of the INK (KOTI).** The V2 token with the strongest performance relative to its bonding curve progress. Featured on the homepage. ## L **Launch ID.** A unique uint256 identifier for each V2 launch. Returned by `createLaunch`. **Launch timestamp.** Unix time at which a V2 launch opens for trading. Set to 0 for immediate launch. **Liquidity supply.** The portion of the total supply paired with ETH in the V4 pool at bonding. Computed by `SaleSplitCalculator` based on the target raise and gain multiplier. ## M **Market cap.** Token price multiplied by total supply. **Min buy / min sell.** The smallest allowed trade. `MIN_BUY_ETH = 0.00001 ether`. `MIN_SELL_TOKENS = 1 ether` (1 token). ## P **PoolKey.** The Uniswap V4 struct that identifies a pool: token pair, fee, tick spacing, and hook. The post bond pool uses fee 1000 (0.1 percent) and tick spacing 60. **Points.** Reward units earned through trading, launching, and referring. Aggregated on the leaderboard. See [Leaderboard](/rewards/leaderboard). **Post-bond.** The phase after a token bonds. Trading happens on the Uniswap V4 pool. Curve calls revert. **Prebuy.** Optional creator buy at launch. Send the prebuy ETH amount as `msg.value` on the `createLaunch` call. There is no separate `prebuyEth` parameter on the struct. Prebuys bypass the anti-snipe captcha gate because they execute in the same transaction as the launch. **Pre-bond.** The phase before a token bonds. Trading happens on the bonding curve. **Price impact.** How much a trade moves the price. Larger trades relative to remaining curve supply cause higher impact. **Protocol fee.** The 1 percent fixed fee on every V2 curve trade. Goes to the InkyPump treasury. **Proxy.** A contract that delegates execution to an implementation contract. The InkyPump V2 hook is a UUPS proxy. ## R **Referral.** An on chain attribution mechanism on V2. When a trader passes a referral code, the contract emits a `Referral(launchId, trader, referralCode)` event. No fee impact. Used for off chain point attribution. See [Referrals](/rewards/referral). **Referral code.** Any string. The contract does not validate it. Off chain systems decide what counts. ## S **Sale supply.** The portion of total supply sold through the curve. The rest is paired in the V4 pool at bonding. **Slippage.** The buffer between the previewed output and the minimum acceptable output. If the chain state changes between preview and execution, slippage protects you from a worse fill. See [Slippage](/trading/slippage). **Smart contract.** Self executing code on the blockchain. ## T **Target raise.** The ETH amount the curve needs to raise before the token bonds. V2 supports 1 to 5 ETH per launch. **Tick spacing.** A Uniswap V4 parameter that controls the granularity of pool prices. V2 pools use 60. **Token.** An ERC20 contract launched through InkyPump. **TokenFactory.** The V1 launch contract, deprecated. See [Legacy Contracts](/legacy/contracts). **Total supply.** 1,000,000,000 tokens per V2 launch. **Transaction hash (tx hash).** Unique identifier for a blockchain transaction. Search on [explorer.inkonchain.com](https://explorer.inkonchain.com). ## U **Uniswap V4.** The AMM protocol V2 tokens bond to. Pools support hooks that run custom logic on swaps. **Universal Router.** The Uniswap V4 router used to swap against bonded V2 pools. At `0x551134e92e537cEAa217c2ef63210Af3CE96a065` on Ink. **UUPS proxy.** A proxy pattern where the upgrade logic lives in the implementation, not the proxy itself. Used by the V2 hook. ## V **Variable fee.** The 1 percent on every V2 curve trade that splits between creator and buyback according to `creatorFeeSplitBps`. **V1.** The legacy launch system using the `TokenFactory` contract and Uniswap V2 bonding. Deprecated. **V2.** The current launch system using the InkyPump V2 hook and Uniswap V4 bonding. ## W **Wallet.** Software or hardware that stores private keys and signs transactions. **WalletConnect.** Protocol that lets mobile wallets connect to web apps through QR codes. **WETH.** Wrapped ETH. On Ink mainnet at `0x4200000000000000000000000000000000000006`. The V4 pools pair the launched token with WETH. **withdrawFees().** The function creators call on the V2 hook to receive their accrued earnings. ## Symbols **0x.** Prefix for Ethereum addresses and hex values. **Bps (basis points).** 1 bps equals 0.01 percent. 10000 bps equals 100 percent. `BPS_DENOMINATOR = 10_000` in the contracts. # Anti-Snipe Source: https://docs.inkyswap.com/token-creation/anti-snipe How the V2 anti-snipe window works. Captcha gate, no fee penalty. Anti-snipe on V2 is a captcha gate. It is not a fee penalty. The 2 percent fee stays constant for the full curve, including inside the anti-snipe window. ## What anti-snipe does When you launch a token, you can pick an anti-snipe window of 0, 20, 40, or 60 seconds. During this window, any buy or sell call that does not include a valid captcha signature reverts with `CaptchaRequired()`. The captcha is signed by an off chain signer that the InkyPump UI uses automatically. A normal user on inkypump.com does not see anything different. A bot that calls the contract directly cannot trade until the window ends. After the window closes, the captcha check is skipped and anyone can trade without a signature. ## The four options | `antiSnipeDuration` | Effect | | ------------------- | ------------------------------------------------------------------------------- | | 0 seconds | No anti-snipe. Anyone can trade from the first block. | | 20 seconds | Brief gate. Good if you want to publish the contract address before opening up. | | 40 seconds | Medium gate. | | 60 seconds | The maximum. Useful for high profile launches where you expect bot pressure. | ## What it actually protects against It protects against scripts that watch the mempool and try to land a buy in the same block as the launch. Those scripts cannot produce the captcha signature, so their transactions revert. It does not protect against humans clicking fast on the UI. The UI gets the captcha signature automatically, so any human user can buy as soon as the launch is live. ## Who is exempt The creator's prebuy at launch (the optional ETH sent as `msg.value` on `createLaunch`) bypasses the captcha check. This is because the creator's prebuy is executed in the same transaction as `createLaunch`, before the anti-snipe window starts running. ## How to set the duration at launch The launch form on inkypump.com has an anti-snipe section with the four options as buttons. The selected value becomes the `antiSnipeDuration` field on the launch. On chain you pass it as part of `CreateLaunchParams`: ```solidity theme={null} struct CreateLaunchParams { // ... uint32 antiSnipeDuration; // 0, 20, 40, or 60 // ... } ``` The field is a `uint32` so the contract accepts any value, but the UI restricts the choice to the four supported options. ## How the gate is implemented The check lives in `LaunchTradingModule._verifyCaptcha`: ```solidity theme={null} function _verifyCaptcha( InkyPumpTypes.LaunchConfig storage config, uint256 launchId, address account, InkyPumpTypes.CaptchaAuth calldata captcha ) internal { uint32 duration = config.antiSnipeDuration; if (duration == 0) return; if (block.timestamp > uint256(config.launchTimestamp) + duration) return; if (captcha.signature.length == 0) revert CaptchaRequired(); // ECDSA signature verification against the configured signer } ``` Two early exits make the gate a no op outside the window: `duration == 0` (anti-snipe is off) and `block.timestamp` past the end of the window. ## What the UI shows When the anti-snipe window is active on a token, a thin bar appears at the top of the trade page with a countdown. The bar says "Anti-Snipe Active, Bot protection, Ends in MM:SS". The countdown reflects the real on chain remaining time. After the countdown ends, the bar disappears and trading continues normally. # Bonding Curve Source: https://docs.inkyswap.com/token-creation/bonding-curve How the V2 bonding curve prices tokens and what the gain multiplier does. InkyPump V2 uses a linear bonding curve. Price grows in a straight line from the starting price to the target price as tokens get sold. The slope of that line is set by the curve gain multiplier you choose at launch. ## The basics When you launch a token on V2, the contract calculates two prices. | Price | Meaning | | ----------- | ---------------------------------------------------------------------------- | | Start price | The price of the first token sold on the curve. | | End price | The price of the last token sold before the curve fills and the token bonds. | The curve gain multiplier (`gainBps` in the contract) controls how much higher the end price is compared to the start price. | Gain multiplier | End price relative to start | Notes | | --------------- | --------------------------- | ----------------------------------------------- | | 1x | Same as start (flat) | Constant price along the curve. | | 5x | 5 times start price | Moderate growth. | | 11x | 11 times start price | Steep. | | 21x | 21 times start price | The contract maximum (`MAX_GAIN_BPS = 200000`). | ## What the multiplier actually changes Steeper curves mean later buyers pay more and earlier buyers see their position appreciate faster on paper. Flatter curves mean later buyers pay closer to the same as early buyers. Steep curves can feel rewarding to early supporters but they front load risk. If the token bonds and the V4 pool opens at a higher price, late curve buyers can be underwater immediately. Flat curves spread the entry price more evenly and reduce the "pump on the curve then dump on the pool" pattern. ## Sale supply vs liquidity supply Of the 1,000,000,000 token total supply, the contract splits the supply into two parts based on your target raise and gain multiplier. `SaleSplitCalculator` decides how many tokens are sold on the curve versus how many are paired with ETH in the post bond V4 pool. The split is not fixed at 80 / 20 like V1. It is calculated per launch to make the marginal price at the end of the curve match the opening price of the V4 pool. This avoids a price jump at the bond. You can preview the split for any target and gain combination with `previewSaleSplit(targetRaise, gainBps)` on the hook. ## Math reference The curve is implemented in `LinearBondingCurve.sol`. The forward integral (ETH paid for N tokens) and the inverse (tokens received for E ETH) both have closed forms. The contract uses these directly, so there is no off chain solver involved. Constants from `LaunchSharedState.sol`: ```solidity theme={null} uint256 public constant MIN_RAISE = 1 ether; uint256 public constant MAX_RAISE = 5 ether; uint32 public constant MAX_GAIN_BPS = 200_000; // 21x ceiling uint256 public constant MIN_BUY_ETH = 0.00001 ether; uint128 public constant MIN_SELL_TOKENS = 1 ether; // 1 token uint256 public constant TOTAL_SUPPLY = 1_000_000_000 ether; ``` ## How to read the curve in the UI The trade page shows a curve chart with three reference points. * Starting market cap (left end of the curve) * Current market cap (where the curve has been bought up to so far) * Bonding market cap (right end of the curve, the point at which the token bonds) As trades happen, the current marker moves along the curve. When it reaches the right end, the token bonds and the chart transitions to the V4 pool view. # Bonding to Uniswap V4 Source: https://docs.inkyswap.com/token-creation/bonding-to-uniswap-v4 What happens when a V2 token raises its target and bonds to a Uniswap V4 pool. When a V2 token raises its target ETH, the curve closes and the remaining liquidity migrates to a Uniswap V4 pool with the InkyPump V2 hook attached. This is the bond event. It happens atomically in the transaction that pushes the cumulative raise over the target. ## What gets created at bonding The contract creates one new Uniswap V4 pool: | Field | Value | | ------------ | -------------------------------------------------------------------- | | Token A | The launched token | | Token B | WETH (`0x4200000000000000000000000000000000000006`) | | Fee | 0.1 percent (1000 in V4 fee units) | | Tick spacing | 60 | | Hook | The InkyPump V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4` | The pool is seeded with two things at creation: 1. All ETH raised through the curve, paired with 2. The liquidity supply of tokens computed by `SaleSplitCalculator` at launch The pool opens at a price chosen so it matches the marginal price at the end of the curve. There is no price jump at the bond. ## What happens to the curve After bonding, the curve contract stops accepting buys and sells. Any `buy` or `sell` call against the launch reverts. Trading moves entirely to the V4 pool. The launch state stays readable. You can still call `getLaunchState(launchId)` and read everything about the curve. ## What changes for traders Before bonding, traders called `buy` or `sell` on the InkyPump V2 hook with a launch ID. After bonding, traders swap against the V4 pool through the Uniswap Universal Router at `0x551134e92e537cEAa217c2ef63210Af3CE96a065`. The InkyPump UI handles this switch automatically. From a user perspective the trade page looks the same and the buttons still say "Buy" and "Sell". Fees also change. Before bonding it was 2 percent total. After bonding it is 0.1 percent on the V4 pool. ## What changes for the creator The variable fee split still applies, but now it routes through the V4 hook on every swap instead of through the curve. The creator continues to earn from trades. The split is still controlled by `creatorFeeSplitBps`. The buyback portion still flows to a buyback that buys and burns the token from the pool. Withdrawal is still done with `withdrawFees()` on the hook. ## How to tell if a token has bonded Three signals: 1. Call `getLaunchState(launchId)` on the hook. The returned struct has a flag indicating whether the launch is finalized. 2. Listen for the `LaunchFinalized` event. It is emitted in the same transaction as the bond. 3. In the UI, the bonding curve card on the trade page shows "BONDED" instead of a live progress percentage, and the chart switches from the curve to the V4 pool price. ## Why a 0.1 percent fee V4 pools use parts per million for fees. 1000 corresponds to 0.1 percent. The choice is low enough to keep swaps cheap and high enough to feed the buyback and creator revenue after bonding. # Creator Earnings Source: https://docs.inkyswap.com/token-creation/creator-earnings Where creator fees come from, how the split works, and how to withdraw. When you launch a token on V2, you become eligible for a share of the variable fee on every trade against your token, both buys and sells. This is the only creator revenue stream on the curve. There is no separate creator royalty. ## Where the earnings come from Every trade pays a 2 percent fee. Of that 2 percent: * 1 percent goes to the protocol * 1 percent is the variable fee, split between the creator and the buyback module You control how much of the 1 percent variable fee goes to you. The remainder goes to a buyback that buys and burns your token from the curve. ## Setting your split At launch you set `creatorFeeSplitBps`, a number from 0 to 10000. | `creatorFeeSplitBps` | Creator per trade | Buyback per trade | | -------------------- | ----------------- | ----------------- | | 0 | 0 percent | 1 percent | | 2500 | 0.25 percent | 0.75 percent | | 5000 | 0.5 percent | 0.5 percent | | 7500 | 0.75 percent | 0.25 percent | | 10000 | 1 percent | 0 percent | Higher split means more revenue to you. Lower split means more buyback pressure on your token, which can support price. ## Changing the split after launch You can update the split any time after launch by calling `updateCreatorFeeSplit(uint256 launchId, uint16 newSplitBps)`. Only the launch creator can call this. There is no cooldown. The new split applies to all trades from that block onwards. Past accruals are not affected. ## How earnings accrue Each trade increments your accrued balance on the hook contract. The balance is held in ETH. There is no token wrapping or unwrapping involved. ## Withdrawing Call `withdrawFees()` on the InkyPump V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`. The function sends your accrued balance to the caller and emits a `FeeWithdrawn` event. There is no time lock and no minimum balance. The InkyPump UI also has a withdraw button on your token's trade page after you connect with the creator wallet. ## After bonding When your token bonds to Uniswap V4, the 2 percent fee stops applying. From that point on, trading happens through the V4 pool and the only fee is the 0.1 percent V4 swap fee. The V4 pool routes fees back through the InkyPump hook. The same `creatorFeeSplitBps` continues to apply to post bond fees, so you keep earning from V4 swaps the same way you earned from curve trades. The buyback portion still goes to buying and burning your token from the V4 pool. ## How to track your earnings The trade page for your token shows live accrued earnings broken down into creator earnings and buyback earnings. The figures update on every new trade as soon as it gets indexed. You can also read accrued balances on chain by calling the relevant getter on the hook with your wallet address. # Fees and Economics Source: https://docs.inkyswap.com/token-creation/fees-and-economics How the 2 percent fee works on InkyPump V2 and where it goes. InkyPump V2 charges a flat 2 percent on every buy and every sell. There is no creation fee. The 2 percent stays constant for the full lifetime of the bonding curve. ## How the 2 percent breaks down Every trade is split two ways at the contract level. | Slice | Bps | Goes to | | ------------ | --------------- | -------------------------------------------- | | Protocol fee | 100 (1 percent) | InkyPump treasury | | Variable fee | 100 (1 percent) | Split between creator and buyback per launch | The protocol fee is fixed. The variable fee is what the creator earns from. The split between creator and buyback is set at launch time and the creator can update it later. ## How the variable fee is split The variable fee is divided by `creatorFeeSplitBps`. This is a number between 0 and 10000 chosen by the creator. If the split is 5000 bps (50 percent to creator): * Creator gets 0.5 percent of the trade * Buyback gets 0.5 percent of the trade If the split is 10000 bps (100 percent to creator): * Creator gets the full 1 percent variable fee * Nothing goes to buyback If the split is 0 bps (0 percent to creator): * All of the variable fee goes to buyback * The token gets deflationary pressure but the creator earns nothing on trades ## When creators get paid Creator fees accrue on the hook contract and can be withdrawn at any time by calling `withdrawFees()` on the InkyPump V2 hook. There is no time lock and no minimum balance. ## Pool fee after bonding Once a token raises its target and bonds to Uniswap V4, the V4 pool charges its own 0.1 percent fee on swaps (1000 in V4 fee units). The 2 percent protocol and variable fees no longer apply. From that point on, all trading happens through the V4 pool and the 0.1 percent swap fee is the only fee. ## What is not charged * No creation fee * No fees on viewing balances or previewing trades * No protocol fee on the post bond V4 pool * No exit fee or graduation fee at bonding * No time based fee changes. The 2 percent is constant from the first trade to the last on the curve * No anti-snipe fee. Anti-snipe is a [captcha gate](/token-creation/anti-snipe), not a fee ## The math, in code For a buy with `ethIn` ETH: ```solidity theme={null} protocolFee = ethIn * 100 / 10000 // 1 percent variableFee = ethIn * 100 / 10000 // 1 percent netForCurve = ethIn - protocolFee - variableFee // 98 percent creatorShare = variableFee * creatorFeeSplitBps / 10000 buybackShare = variableFee - creatorShare ``` The same math runs in reverse on a sell, with fees deducted from the gross payout before sending ETH to the seller. ## Where the fees are defined In `LaunchSharedState.sol`: ```solidity theme={null} uint256 public constant PROTOCOL_FEE_BPS = 100; // 1 percent uint256 public constant VARIABLE_FEE_BPS = 100; // 1 percent uint256 public constant BPS_DENOMINATOR = 10_000; uint24 public constant POOL_FEE = 1_000; // 0.1 percent on V4 pool ``` These constants are baked into the deployed implementation. They cannot change without an upgrade. # Create Your Token Source: https://docs.inkyswap.com/token-creation/getting-started Launch a token on InkyPump V2 on Ink mainnet. All new tokens launch on InkyPump V2. V2 runs on Ink mainnet (chain 57073) and bonds to a Uniswap V4 pool after the curve fills. For the deprecated V1 system, see [Legacy](/legacy/overview). ## What you need before you start | Item | Required | Notes | | --------------------- | -------- | ----------------------------------------------- | | Ink mainnet wallet | Yes | Any wallet that supports Ink. ETH for gas. | | Token name | Yes | Any string. | | Token ticker | Yes | Any string. | | Description | Yes | Any string. | | Image | Yes | jpg, png, svg, or webp. Up to 5 MB. | | Target raise in ETH | Yes | Between 1 and 5 ETH. | | Prebuy ETH | Optional | Buys tokens for the creator at launch. | | Curve gain multiplier | Optional | Between 1x and 21x. Default is moderate. | | Creator fee split | Optional | 0 to 100 percent of the 1 percent variable fee. | | Anti-snipe window | Optional | 0, 20, 40, or 60 seconds. | | Scheduled start | Optional | Future date and time. | | Social links | Optional | Telegram, X, website. | ## Launch flow Visit [InkyPump](https://inkypump.com), connect a wallet, and switch to Ink mainnet. Go to [inkypump.com/create](https://inkypump.com/create). Name, ticker, description, image. The image uploads to InkyPump storage. Add Telegram, X, and website if you have them. Pick any number between 1 and 5 ETH. Decimals up to two places. This is how much the curve has to raise before the token bonds to Uniswap V4. Curve gain (how steep the price grows along the curve), creator fee split (how much of the 1 percent variable fee comes to you), anti-snipe window (captcha gate against bots), and an optional prebuy. InkyPump uses Cloudflare Turnstile to prevent automated launches. The contract is `createLaunch` on the InkyPump V2 hook. If you have a referral code in your URL or local storage, the call switches to `createLaunchWithReferral` automatically. After the transaction confirms, you land on the trade page. If you set a scheduled start, trading opens at that time. Otherwise it opens immediately. ## What it costs There is no creation fee. You pay: * Gas for the `createLaunch` transaction * Any prebuy ETH you opted into (this buys tokens for you at launch price, and is subject to the 2 percent trade fee) ## What happens next Tokens trade on the bonding curve until the curve raises the target. After that the token bonds to a Uniswap V4 pool and trading moves to that pool. See [Bonding to Uniswap V4](/token-creation/bonding-to-uniswap-v4) for what changes at the bond. ## Learn more The flat 2 percent and how creator earnings work. How price grows on the curve and what the gain multiplier does. The captcha gate against bots during launch. Where your fees come from and how to withdraw. Launch from your editor with the InkyPump MCP server. How referral codes attach to trades on your token. # King of the Ink Source: https://docs.inkyswap.com/token-creation/koti Learn about InkyPump's King of the Ink feature - highlighting the top performing token closest to the bonding curve The King of the Ink is awarded to the token showing the strongest performance relative to its bonding curve progress. ## How It Works System monitors: * Current supply vs total supply (1B) * Progress through bonding curve * Trading volume in ETH Updates with each new block Progress = (currentSupply / totalSupply) \* 100 All tokens in bonding phase are continuously evaluated * Highest bonding curve progress * Valid contract state Selection updates automatically based on bonding curve progress * Token name and symbol * Current price from bonding curve * Supply progress percentage * Contract address Homepage featured section ## Display Elements Visual indicator of King of the Ink status * Token name and symbol * Contract address * Current price (ETH) Visual representation of bonding curve progress * Trade: Direct access to bonding curve trading * View Contract: Etherscan verification ## Trading Benefits Being crowned King of the Ink often leads to: * Increased visibility * Higher trading volume * Faster bonding curve progress ## Verification 1. Visit the InkyPump homepage 2. Look for the crowned token display 3. Verify contract and trading status 1. Track bonding curve progress 2. Monitor supply changes 3. Check trading activity King of the Ink status can change as token performance fluctuates. Always conduct your own research before making investment decisions. # Rankings Source: https://docs.inkyswap.com/token-creation/rankings How the InkyPump rankings page surfaces tokens by performance and market cap. The Rankings page on InkyPump groups tokens by where they are in their lifecycle and how they are performing. Two sections. ## The two sections | Section | What it shows | | ------------- | ------------------------------------------------------------------------ | | Bonding phase | V2 tokens still on the bonding curve, ordered by progress toward bonding | | Market cap | Tokens that have bonded, ordered by current market cap | V1 tokens that have not yet bonded are also visible. V1 tokens that have bonded trade through their original Uniswap V2 pair and appear in the market cap section. ## What each row shows | Field | Where it comes from | | --------------------- | -------------------------------------------------------------- | | Token name and ticker | The launch metadata | | Contract address | The deployed token address | | Market cap | Current price multiplied by total supply (1 billion tokens) | | Bonding progress | For V2 tokens on the curve, percentage of target raise reached | | Trading status | Live on curve, live on pool, or scheduled | ## How prices are computed For V2 tokens on the curve, the current price comes from the linear bonding curve. See [Bonding Curve](/token-creation/bonding-curve) for the formula and the gain multiplier. For tokens that have bonded, the current price comes from the live Uniswap V4 pool (V2 tokens) or Uniswap V2 pair (V1 tokens). The InkyPump UI fetches these prices through the relevant view contracts and refreshes them as new trades land. ## Update cadence Rankings update as new trades are indexed. There is no manual refresh required. ## Direct access The Rankings page is at [inkypump.com/rankings](https://inkypump.com/rankings). It is also accessible from the home page. ## Related How the curve sets the price during the bonding phase. Different from rankings: shows users ranked by points, not tokens by market cap. # Referrals (for creators) Source: https://docs.inkyswap.com/token-creation/referrals How referral codes attach to trades on V2 tokens at the contract level. This page covers referrals from a token creator's perspective. For how to share your own referral link and earn from it, see [Rewards & Referrals](/rewards/referral). ## What gets recorded on chain When a buyer or seller passes a referral code with their trade, the V2 hook emits a separate `Referral` event: ```solidity theme={null} event Referral( uint256 indexed launchId, address indexed trader, string referralCode ); ``` The event is emitted from three entry points: * `createLaunchWithReferral` (referral code recorded at launch creation) * `buyWithReferral` (referral code recorded on a buy) * `sellWithReferral` (referral code recorded on a sell) The plain `createLaunch`, `buy`, and `sell` functions do not emit `Referral`. The UI calls the `*WithReferral` variant only when a referral code is present in the user's browser. ## What does not happen on chain * No fee discount. The 2 percent fee is the same with or without a referral code * No on chain rewards. The contract only records the code in the event log * No validation of the code. The contract accepts any string as the referral code Attribution and rewards are handled off chain by InkyPump backend services that index the `Referral` events. ## What this means for your token If you launch a token on V2, trades against your token can carry referral codes. Those codes show up in the indexer alongside the trade. You do not have to do anything to enable this. It is on by default for every V2 launch. If you want to track which referrers bring volume to your token, the InkyPump indexer captures referral attribution per trade and exposes it through the InkyPump API. See [Referral API](/api-reference/inkypump/referral) for the available endpoints. ## How users get a referral code attached When a user opens any inkypump.com URL with `?ref=` or visits `/join/`, the site stores the code in browser local storage. From that point on, every trade and every launch by that user uses the `*WithReferral` variant of the contract call and emits the `Referral` event. The user does not see any difference in the UI. Referrals are invisible to the trader. ## Reading referral events directly If you index the chain yourself, the topic hash for the `Referral` event is: ``` keccak256("Referral(uint256,address,string)") = 0x796dfbc4bdc1de15340f520a4b17fb287a10b2f6c50e702ee8dc9fa2c714dfc5 ``` Listen for this topic on the V2 hook at `0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`. Join it to the `Trade` event by `(launchId, trader)` and the block number to attribute the trade. # Emperor of the INK (EOTI) Source: https://docs.inkyswap.com/trading/boosted-token Become the Emperor of the INK and get premium homepage visibility through competitive daily auctions **Become the Emperor of the INK (EOTI) - gain premium visibility on InkyPump's homepage through a 24-hour reign, earned via competitive daily auctions.** ## What is Emperor of the INK? The Emperor of the INK (EOTI) system allows token projects to claim the throne and gain **prominent placement** on InkyPump's homepage through a competitive auction mechanism. The reigning Emperor receives 24 hours of enhanced visibility with an eye-catching animated display that drives trading volume and community engagement. Featured placement with animated EMPEROR banner, crown icons, and gradient styling for maximum visibility Full day of premium visibility until the next daily reset - maximize your exposure window Real-time competitive bidding with countdown timers and instant updates for fair competition Pay with ETH directly or any token (automatically converted to ETH) ## How to Participate Look for the **"Claim the Throne"** or **"Become Emperor"** button on the InkyPump homepage to start your bidding journey for the EOTI crown. * **Token Contract Address**: Must be a valid, deployed token * **Token Validation**: System automatically fetches token name, symbol, and details * **Trading Status**: Token must have trading enabled * **View Current Bid**: See the minimum amount needed to win * **Choose Payment Method**: ETH or select from available tokens * **Automatic Conversion**: Non-ETH tokens are quoted and swapped instantly * **Wallet Connection**: Connect your wallet and confirm the transaction * **Live Updates**: Real-time bid tracking and countdown timer * **Next Boost Timer**: Shows time remaining until next auction period * **Winning Confirmation**: Successful bidders see immediate confirmation * **Homepage Feature**: Token appears with BOOSTED styling within minutes ## Auction Mechanics **Dutch Auction System**: The Emperor of the INK uses a unique Dutch auction mechanism where prices start high and decrease over time until someone bids. ### Dutch Auction System * **Starting Price**: Each auction begins at **0.1 ETH** * **Daily Decay**: Price decreases by **0.05 ETH per day** * **Minimum Price**: Cannot go below **0.05 ETH** (floor price) * **Bid Doubling**: When someone bids, the next auction starts at **2x** that bid amount * **Reset Mechanism**: After winning, next day's auction resets to standard Dutch auction * **Early Bird**: Bid early at 0.1 ETH to secure the throne immediately * **Value Hunter**: Wait for price decay to get better value (risk being outbid) * **Day 1**: 0.1 ETH starting price * **Day 2**: 0.05 ETH (if no bids on Day 1) * **Day 2+**: Remains at 0.05 ETH floor until someone bids * **After Bid**: Next auction starts at 2x the winning bid * ETH Direct: Pay directly with ETH from your wallet * Token Swaps: Use any ERC-20 token with automatic conversion * Live Quotes: Real-time pricing for non-ETH payments * Slippage Protection: Built-in safeguards for token swaps * 24-Hour Cycles: Each Emperor reign lasts exactly 24 hours * Daily Price Decay: Price drops by 0.05 ETH each day without bids * Countdown Timers: Live tracking of remaining time and current price * Instant Activation: Winners become Emperor immediately upon winning ### Price Examples **Example Scenarios**: Understanding how the Dutch auction pricing works in practice. * **Day 1**: Auction opens at 0.1 ETH * **Day 2**: If no bids, price drops to 0.05 ETH * **Day 3+**: Price remains at 0.05 ETH floor * **Winner Bids**: Someone bids at 0.05 ETH and becomes Emperor * **Previous Bid**: Someone won at 0.05 ETH * **Next Auction**: Starts at 0.1 ETH (2x the 0.05 ETH bid) * **If No Bids**: Decays to 0.05 ETH the next day * **New Winner**: Someone bids at current price * **Previous Bid**: Someone won at 0.08 ETH * **Next Auction**: Starts at 0.16 ETH (2x the 0.08 ETH bid) * **Day 2**: Decays to 0.11 ETH * **Day 3**: Decays to 0.06 ETH * **Day 4**: Reaches floor at 0.05 ETH * **Previous Bid**: Someone won at 0.1 ETH (starting price) * **Next Auction**: Starts at 0.2 ETH (2x the 0.1 ETH bid) * **Daily Decay**: -0.05 ETH per day * **Days to Floor**: Takes 4 days to reach 0.05 ETH floor ## Benefits of Being Emperor **Pro Tip**: Emperor tokens typically see **3-10x increase** in trading activity during their 24-hour reign! ### Enhanced Visibility Homepage Hero Section * Top-of-page positioning * Animated EMPEROR banner * Crown and royal visual effects * Gradient background styling Token Details Display * Token name and ticker symbol * Current market capitalization * Funding progress visualization * Social media links integration Direct trade access * Integrated "Trade Now" button * Direct link to token's trading page * No additional steps for users * Instant liquidity access Community Engagement * Contract address display * Social media link buttons * Easy sharing capabilities * Enhanced discoverability ### Marketing Impact Emperor tokens typically see **3-10x increase** in trading activity during their reign due to prominent homepage placement and enhanced visibility. The eye-catching display attracts new users to your token's community, often resulting in increased social media followers and engagement. Being featured builds credibility and market recognition, positioning your token as a serious project worth attention. Stand out from thousands of tokens with premium positioning that captures user attention immediately upon visiting InkySwap. ## Best Practices ### Timing Your Bid **Strategic Timing**: Maximize your chances of winning while optimizing cost efficiency with smart bidding strategies. Track daily reset times and current bid levels to identify optimal bidding windows for maximum value. Ensure your token has updated social links, descriptions, and community engagement before bidding. Time your Emperor reign to coincide with major announcements, launches, or community events for maximum impact. Plan your bidding budget considering the progressive pricing model and potential competition. ### Maximizing Your Emperor Reign Announce your Emperor status across all social channels to drive maximum traffic during your 24-hour reign Encourage your community to visit and trade during your Emperor reign to maximize visibility benefits Have announcements ready: graphics, and promotional content to deploy immediately upon winning Ensure adequate liquidity is available to handle increased trading volume from Emperor exposure ## API Integration **For Developers**: Access current Emperor data programmatically through our API endpoint. **GET** `https://inkypump.com/api/eoti` Returns the current Emperor of the INK token data including: * Token details (name, symbol, address) * Market metrics (price, volume, market cap) * Bidding information (with `includeBidData=true` parameter) [View Full API Documentation →](/api-reference/inkypump/emperor) ## Frequently Asked Questions The Emperor auction uses a **Dutch auction system**: * **Starting Price**: 0.1 ETH for new auctions * **Daily Decay**: Price drops by 0.05 ETH each day without bids * **Minimum Price**: 0.05 ETH floor * **After a Bid**: Next auction starts at 2x the winning bid Monitor the current auction to see the exact price at any moment. **Yes!** The system accepts any ERC-20 token and automatically converts it to ETH at current market rates. You'll see the exact token amount required before confirming your bid. If someone places a higher bid during the auction period, they become the new leader. You can **place a new, higher bid** to regain the lead, or wait for the next auction cycle. Each Emperor reign lasts **exactly 24 hours** from the time you win the auction. Your token will rule the homepage until the next daily reset. Your token must have a **valid contract address** and **trading must be enabled**. The system automatically validates token eligibility when you enter the contract address. Auctions follow a **daily reset schedule**. Check the "Next Emperor In" countdown timer to see exactly when the current reign ends and a new auction for the throne begins. **Ready to claim the throne?** Visit [InkyPump](https://inkypump.com) and look for the "Become Emperor" option to participate in the next auction for the EOTI crown! # Trading on InkyPump Source: https://docs.inkyswap.com/trading/getting-started How to trade V2 tokens on the bonding curve and on the post-bond Uniswap V4 pool. All new tokens on InkyPump are V2. V2 tokens trade in two phases: on the bonding curve while they raise their target, and on a Uniswap V4 pool after they bond. For trading the older V1 tokens, see [Legacy](/legacy/overview). ## Two phases of trading | Phase | Where it happens | Fee | Counterparty | | ----- | ---------------------------------- | ----------- | ----------------------------------- | | Curve | InkyPump V2 hook (`buy` / `sell`) | 2 percent | The bonding curve | | Pool | Uniswap V4 pool with InkyPump hook | 0.1 percent | Other traders and the pool reserves | A token starts in the curve phase and moves to the pool phase when it raises its target ETH. The InkyPump UI shows both phases through the same trade page and the same Buy / Sell buttons. The contract calls underneath are different. ## Curve phase While a token is on the curve, the price moves along the linear bonding curve set at launch. Every buy moves the price up. Every sell moves it down. The 2 percent trade fee is taken from the ETH side of every trade. You trade by calling `buy` or `sell` on the InkyPump V2 hook. The UI handles this for you. See [Buy and Sell](/trading/swap-tokens) for the inputs and how the preview works. ## Bond event When the cumulative raise reaches the target, the next buy that pushes it over the line triggers the bond. The contract automatically creates the V4 pool, seeds it with the raised ETH and the liquidity portion of the token supply, and routes future trades to the pool. This happens in a single transaction. There is no creator action required at bonding. It is automatic. ## Pool phase After bonding, the token trades on a Uniswap V4 pool. The pool fee is 0.1 percent. The 2 percent curve fee no longer applies. Swaps happen through the Uniswap Universal Router. The InkyPump UI keeps the same trade page, but underneath it now routes through the router and the V4 pool. See [Post-Bond Pool](/trading/post-bond-pool) for how the pool works and how to swap against it. ## What you pay in fees | Phase | Fee | Goes to | | ----- | --------------------------------------- | ------------------------------------------------------- | | Curve | 1 percent protocol + 1 percent variable | Treasury, creator, buyback (depending on creator split) | | Pool | 0.1 percent | Routes through the hook to creator and buyback | Both phases pay gas for the transaction on top of the trade fee. ## What you need * A wallet on Ink mainnet * ETH for gas * ETH to buy with, or tokens to sell from ## Trade flow Go to `inkypump.com/trade/` or click the token from the home page. The trade box has a tab for each. Enter the amount. The box shows expected tokens out (on buy) or expected ETH out (on sell), the fee, and the price impact. Default slippage is set in the app. You can tighten or loosen it before confirming. See [Slippage](/trading/slippage). Sign in your wallet. The trade lands in the next block. ## Learn more Inputs, previews, what each value means. minTokensOut and minEthOut, default values, when to tighten. How V4 pool trading works after bonding. Browse all tokens and filter by status. # Post-Bond Pool Source: https://docs.inkyswap.com/trading/post-bond-pool How a V2 token trades after it bonds to its Uniswap V4 pool. When a V2 token bonds, trading moves from the bonding curve to a Uniswap V4 pool. This page covers what changes from a trader's perspective. ## The V4 pool After bonding, every V2 token has a single Uniswap V4 pool. The pool params are: | Field | Value | | ------------ | --------------------------------------------------------------- | | Token A | The launched token | | Token B | WETH (`0x4200000000000000000000000000000000000006`) | | Fee | 0.1 percent (1000 in V4 fee units) | | Tick spacing | 60 | | Hook | InkyPump V2 hook (`0x4cC8F6d5B7cE150CCC0A9B7664532B1283b96AC4`) | The pool is permissionless. Anyone can swap against it through the Uniswap Universal Router. ## How to trade Through the UI, nothing changes. The same Buy and Sell buttons on the token's trade page now route through the V4 pool instead of the curve. Through contracts, swaps go through the Universal Router at `0x551134e92e537cEAa217c2ef63210Af3CE96a065`. You construct a swap command targeting the pool's `PoolKey` and submit it through the router. The hook on the pool intercepts the swap to route fees back through InkyPump. ## Fees on the pool The 2 percent curve fee no longer applies. The only fee is the 0.1 percent V4 pool fee. The hook splits this fee the same way the curve did. `creatorFeeSplitBps` continues to apply. Creators keep earning. The buyback portion continues to buy and burn the token from the pool reserves. ## Slippage on the pool V4 pools can have tighter spreads than the curve when liquidity is concentrated near the price. The UI uses the same slippage percentage default, so the experience should feel similar. Tighten slippage if you want stricter execution. See [Slippage](/trading/slippage). ## Quotes Off chain quoting uses the Uniswap V4 Quoter at `0x3972C00f7ed4885e145823eb7C655375d275A1C5`. The InkyPump UI uses this for the trade page preview after bonding. ## Liquidity The initial pool liquidity comes from the bond event. The contract pairs the raised ETH with the liquidity supply of tokens (calculated by `SaleSplitCalculator` at launch) and seeds the pool. There is no creator action required. After the initial seed, anyone can add liquidity to the pool through the Uniswap V4 Position Manager at `0x1b35d13a2E2528f192637F14B05f0Dc0e7dEB566` if they want LP exposure. ## State queries To read pool state from your own code, use the StateView contract at `0x76Fd297e2D437cd7f76d50F01AfE6160f86e9990`. It exposes price, liquidity, and tick data for any V4 pool. To check whether a token has bonded yet, call `getLaunchState(launchId)` on the InkyPump V2 hook and check the finalized flag. # Liquidity Provision Source: https://docs.inkyswap.com/trading/provide-liquidity How liquidity works on InkyPump V2: automatic at bonding, optional add-ons after. InkyPump V2 does not need you to provide liquidity for a new token. Liquidity is created automatically when the token bonds. If you want to LP after bonding, you can add positions to the V4 pool through the Uniswap V4 Position Manager. ## Curve phase: no LPs While a token is on the bonding curve, there is no liquidity pool. The InkyPump V2 hook holds all ETH paid in and mints tokens out according to the curve. The price comes from the curve formula, not from a reserve ratio. This means: * No impermanent loss * No LP tokens to mint * No LP fees to earn * You cannot add liquidity to a curve. There is nothing to add to. ## Bond event: liquidity is created automatically When the curve fills, the contract creates a Uniswap V4 pool, pairs the raised ETH with the liquidity supply of tokens, and seeds the pool. This happens in one transaction. The full initial position belongs to the InkyPump hook, not to any individual LP. This pool seed is permanent. The contract does not later withdraw it. There is no separate burn step. The seed is held by the hook. ## Pool phase: you can add LP positions After bonding, anyone can add concentrated liquidity positions to the V4 pool through the Position Manager at `0x1b35d13a2E2528f192637F14B05f0Dc0e7dEB566`. Standard Uniswap V4 mechanics apply. * You earn the 0.1 percent pool fee on swaps that hit your range * You take impermanent loss if the price moves outside your range * You can withdraw your position any time This is optional. The pool works fine on the initial seed alone. LP positions are for users who want fee income or who want to support tighter spreads on a token they hold. ## Why V2 changed this V1 used Uniswap V2 LP and permanently burned the LP tokens at bonding. This made the liquidity permanent but inflexible. There was no way to add concentrated liquidity, no way to vary fee tiers, and no way for the protocol to keep collecting fees on swaps. V4 with the InkyPump hook keeps the same "no rug" property (the protocol does not pull the initial seed) and adds the flexibility of concentrated liquidity and ongoing hook fees that route back to creators and buyback. ## V1 liquidity for context For how V1 handled liquidity, see [Permanent Liquidity (V1)](/legacy/lp-burning). # Slippage Source: https://docs.inkyswap.com/trading/slippage How slippage works on the curve and on the V4 pool, and when to tighten it. Slippage is the maximum difference between the expected output you saw in the preview and the actual output you accept. If the chain state changes between your preview and your transaction landing, the contract checks the floor you set and reverts if the actual output drops below it. ## What you set On every trade, the InkyPump UI passes a minimum output to the contract: | Trade | Min field | Contract param | | ----- | -------------- | --------------------------------------------- | | Buy | Min tokens out | `minTokensOut` on `buy` and `buyWithReferral` | | Sell | Min ETH out | `minEthOut` on `sell` and `sellWithReferral` | If less than this would come out, the transaction reverts with a slippage error. You pay gas but you do not lose the trade amount. ## What the UI does by default The UI applies a default slippage percentage to the preview value and uses the result as the minimum. The default is a moderate setting suitable for normal trading on the curve. You can adjust slippage in the trade settings before confirming. Lower values are tighter (more likely to revert if the price moves). Higher values are looser (more likely to fill but you accept a worse rate). ## When to tighten slippage * The curve is quiet and you do not expect concurrent trades * You are doing a small trade where price impact is low * You want to protect against a sudden mempool spike ## When to loosen slippage * The token has high trading activity and concurrent buys are likely * You are doing a large trade with high price impact * The token just bonded and the pool is finding its level ## Slippage on the post-bond V4 pool After bonding, slippage works the same way but the call goes through the Uniswap Universal Router. The router takes a `minimumAmountOut` (or `minimumAmountIn` for exact-out swaps). The UI converts your slippage percentage into that value before signing. V4 pools can have tighter spreads than the curve, so the same percentage slippage tolerates less drift. If you keep your default value, the experience should feel similar. ## Why slippage matters on the curve Every buy moves the curve price up. Every sell moves it down. If someone else's transaction lands between your preview and your trade, the price you see is no longer the price you get. Slippage is the buffer that decides whether your trade still makes sense at the new price. The bigger your trade relative to remaining curve supply, the more your own trade moves the price. The preview already accounts for this through `previewBuy` and `previewSell`. Slippage only protects you against other people's trades and reordering. # Buy and Sell Source: https://docs.inkyswap.com/trading/swap-tokens How to buy and sell V2 tokens on the curve, with the preview values explained. The Buy and Sell tabs on a token's trade page submit different contract calls depending on whether the token is still on the bonding curve or has bonded to its Uniswap V4 pool. The UI hides this. The inputs you see and what they mean are the same either way. ## Buying You enter an ETH amount. The UI shows: | Field | What it means | | ------------------- | ----------------------------------------------------------------------------- | | Expected tokens out | Tokens you receive at the current curve price | | Price impact | How much your buy moves the curve price | | Fee | 2 percent of your ETH input on the curve, 0.1 percent on the pool | | Min received | The slippage floor. If less than this would come out, the transaction reverts | The contract call on the curve is `buy(launchId, minTokensOut, captcha)`. With a referral code in local storage, the UI calls `buyWithReferral(launchId, minTokensOut, captcha, referralCode)` instead. The minimum buy is `MIN_BUY_ETH = 0.00001 ether` per the contract. After bonding, buys route through the Uniswap Universal Router. ## Selling You enter a token amount. The UI shows: | Field | What it means | | ---------------- | ----------------------------------------------------------------------------- | | Expected ETH out | ETH you receive net of the fee | | Price impact | How much your sell moves the curve price | | Fee | 2 percent of the gross ETH on the curve, 0.1 percent on the pool | | Min received | The slippage floor. If less than this would come out, the transaction reverts | The contract call on the curve is `sell(launchId, tokenAmount, minEthOut, captcha)`. With a referral code, it switches to `sellWithReferral`. The minimum sell is `MIN_SELL_TOKENS = 1 ether` (1 token). After bonding, sells route through the Uniswap Universal Router. ## How the preview works The UI calls a view function on the V2 hook to compute the expected output before you sign: * For buys: `previewBuy(launchId, ethIn)` returns tokens out, cost, refund, and tokens remaining on the curve * For sells: `previewSell(launchId, tokenAmount)` returns the net payout and the fee breakdown These functions are read only and free. They reflect the current curve state. After bonding, the preview comes from the Uniswap V4 Quoter at `0x3972C00f7ed4885e145823eb7C655375d275A1C5`. ## Anti-snipe behaviour During the anti-snipe window (0 to 60 seconds after launch, set by the creator), buys and sells require a captcha signature. The InkyPump UI gets this signature automatically. Direct contract calls without the signature revert with `CaptchaRequired()`. See [Anti-Snipe](/token-creation/anti-snipe). ## Refund on a partial fill If you submit a buy that would push the curve past the bond target, the contract fills as much as it can on the curve and refunds any unused ETH in the same transaction. The bond happens as part of the same call. You end up with tokens at the curve price plus a refund. The UI shows this as a single combined buy. The transaction trace shows the refund. # Vision Source: https://docs.inkyswap.com/trading/vision Discover promising new tokens through InkySwap sophisticated token discovery and lifecycle tracking system **Inky Vision is a sophisticated token discovery tool designed to help users find promising new tokens through a curated three-stage lifecycle view.** ## What is Inky Vision? Inky Vision presents a curated view of tokens, categorizing them into a three-stage lifecycle: from brand new creations to fully funded and tradable assets. The goal is to provide users with the data they need to identify high-potential tokens at any point in their early development. Brand new tokens with low market caps just beginning their funding journey on the bonding curve Tokens close to completing their funding goal with strong community interest and momentum Successfully funded tokens now actively trading on InkySwap with proven market demand ## Token Lifecycle Stages * Brand New Tokens: Very latest tokens launched on the platform * Low Market Caps: Just beginning their funding journey * Bonding Curve Phase: Early-stage pricing and discovery * Fresh Opportunities: First chance to discover new projects * Near Completion: Close to completing initial funding goal * High Progress: Strong funding progress indicating community interest * Pre-DEX Trading: On the cusp of becoming fully tradable * Proven Interest: Demonstrated market validation * 100% Funded: Successfully reached funding goals * Active Trading: Now trading on InkySwap and other DEXs * Real-Time Data: Live market data from DexScreener * Established Assets: Proven tokens with trading history ## Key Features ### Advanced Filtering System **Independent Filters**: Each lifecycle stage has its own independent filtering system for precise token discovery. Filter tokens based on the presence of social links including Telegram, Twitter, and official websites. Set specific funding progress percentages to find tokens at your preferred development stage. Filter by number of holders and developer holding percentages for decentralization insights. Sort and filter by 24-hour trading volume in USD to identify active tokens. ### Data-Rich Token Cards Time since creation, holder distribution, volume data, and market capitalization all in one view Intelligently displays relevant metrics based on token lifecycle stage with real-time updates One-click purchasing with preset amounts, automatically choosing bonding curve or DEX trading Top 10 holder percentages and developer holdings for informed investment decisions ## How to Use Vision ### Getting Started **Pro Tip**: Set your default purchase amount in the header widget to enable quick buying across all token cards. Select the lifecycle stage that matches your investment strategy and risk tolerance. Use the filter popover to narrow down tokens based on your specific criteria and preferences. Review the comprehensive metrics on each token card to identify promising opportunities. Use the quick buy feature or navigate to detailed trading interfaces for your selected tokens. ### Advanced Discovery Strategies Focus on **New Creations** with strong social presence and growing holder counts. Look for tokens with active communities and clear development roadmaps. Monitor **About to Graduate** tokens with high funding progress and increasing volume. These tokens often see significant price movements upon graduation. Explore **Graduated** tokens with consistent trading volume and healthy holder distribution for more stable investment opportunities. Use Vision to build a diversified portfolio across all three stages, balancing high-risk early opportunities with proven assets. ## Technical Features ### Responsive Design Three-column layout displaying all lifecycle stages side-by-side for comprehensive market overview Tabbed interface for easy navigation between stages on smaller screens Live data integration from multiple sources including DexScreener and blockchain explorers Efficient loading with skeleton screens and optimized data fetching for smooth user experience ### Data Sources and Integration * Token creation timestamps and funding progress * Holder counts and distribution analysis * Developer holding percentages * Social media link verification * DexScreener: Real-time volume and market cap data * Block Explorers: Detailed holder analysis and transaction history * Price Feeds: Live pricing data for accurate valuations * Social APIs: Verification of community links and presence ## Frequently Asked Questions Vision data is updated in **real-time** for graduated tokens and every few minutes for new and graduating tokens to ensure accuracy. A token graduates when it reaches **100% of its funding goal** on the bonding curve and becomes available for trading on decentralized exchanges. Yes, your filter settings are **automatically saved** for each lifecycle stage and persist across browser sessions. Holder data is sourced directly from **blockchain explorers** and updated regularly to provide the most accurate decentralization metrics. **Bonding curve** buying is for new/graduating tokens with algorithmic pricing. **DEX buying** is for graduated tokens with market-driven prices. Look for tokens with **strong social presence**, **growing holder counts**, **reasonable dev holdings**, and **increasing trading volume** across stages. **Ready to discover the next big token?** Visit [InkySwap](https://inkyswap.com) and explore Vision to find promising opportunities across all lifecycle stages!