Launchpad Quickstart

This is the supported first integration for launchpads such as Fomo: create a native-quoted token with the user’s connected wallet, prove the result from the transaction receipt, then poll the read API until the indexer publishes it.

Verified against production on September 21, 2026. Fetch Capabilities at runtime. Do not copy a hook address from an old guide.

The whole flow

Your server fetches the active deployment for the selected chain.
The user’s wallet simulates and signs createLaunch on that exact hook.
Your app records the transaction hash before it waits for a receipt.
Your app accepts the launch only after it decodes one valid LaunchCreated event from that hook.
Your server polls GET /api/token until the token is indexed.

The caller becomes the creator and fee recipient. Let the creator’s wallet call the hook directly. If your backend or a wrapper contract submits the transaction, that address becomes the creator.

1. Resolve the current deployment

Call this from your server. InkyPump read APIs do not currently promise cross-origin browser access.

const chainId = 57073

const response = await fetch(
  `https://inkypump.com/api/capabilities?chainId=${chainId}`,
  { cache: "no-store" },
)

if (!response.ok) throw new Error(`Capabilities failed: ${response.status}`)

const capabilities = await response.json()
if (!capabilities.flags.create) throw new Error("Creation is disabled")

const deployment = capabilities.activeCreationDeployment
if (!deployment || deployment.status !== "active") {
  throw new Error("No active creation deployment")
}

// Send only this allowlisted data to your browser.
const launchConfig = {
  chainId: capabilities.chainId,
  releaseCommit: capabilities.releaseCommit,
  hook: deployment.hook,
  hookRuntimeHash: deployment.hookRuntimeHash,
}

Use chain 57073 for Ink or 4663 for Robinhood. Always send chainId; never rely on a default.

2. Use the creation ABI

export const CREATE_LAUNCH_ABI = [
  {
    type: "function",
    name: "createLaunch",
    stateMutability: "payable",
    inputs: [
      {
        name: "params",
        type: "tuple",
        components: [
          { name: "name", type: "string" },
          { name: "ticker", type: "string" },
          { name: "description", type: "string" },
          { name: "imageUrl", type: "string" },
          { name: "telegram", type: "string" },
          { name: "twitter", type: "string" },
          { name: "website", type: "string" },
          { name: "creatorFeeSplitBps", type: "uint16" },
          { name: "gainBps", type: "uint32" },
          { name: "targetRaise", type: "uint96" },
          { name: "antiSnipeDuration", type: "uint32" },
          { name: "startTime", type: "uint64" },
        ],
      },
    ],
    outputs: [{ name: "launchId", type: "uint256" }],
  },
  {
    type: "event",
    name: "LaunchCreated",
    anonymous: false,
    inputs: [
      { name: "launchId", type: "uint256", indexed: true },
      { name: "creator", type: "address", indexed: true },
      { name: "token", type: "address", indexed: false },
      { name: "targetRaise", type: "uint96", indexed: false },
    ],
  },
] as const

3. Simulate, sign, and prove the receipt

This browser example uses viem and an injected wallet.

import {
  createPublicClient,
  createWalletClient,
  custom,
  http,
  isAddressEqual,
  keccak256,
  parseEther,
  parseEventLogs,
} from "viem"

const chains = {
  57073: {
    id: 57073,
    name: "Ink",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: { default: { http: ["https://rpc-gel.inkonchain.com"] } },
  },
  4663: {
    id: 4663,
    name: "Robinhood Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: {
      default: { http: ["https://rpc.mainnet.chain.robinhood.com"] },
    },
  },
} as const

const chain = chains[launchConfig.chainId as keyof typeof chains]
if (!chain || chain.id !== launchConfig.chainId) {
  throw new Error("Unsupported or mismatched capability chain")
}

const publicClient = createPublicClient({ chain, transport: http() })
const walletClient = createWalletClient({
  chain,
  transport: custom(window.ethereum),
})

if ((await publicClient.getChainId()) !== chain.id) {
  throw new Error("RPC returned the wrong chain")
}
if ((await walletClient.getChainId()) !== chain.id) {
  throw new Error("Connect the wallet to the selected chain")
}

const [account] = await walletClient.requestAddresses()
const hook = launchConfig.hook as `0x${string}`

const code = await publicClient.getCode({ address: hook })
if (!code || code === "0x") throw new Error("Creation hook has no code")
if (keccak256(code).toLowerCase() !== launchConfig.hookRuntimeHash.toLowerCase()) {
  throw new Error("Creation hook does not match the published runtime")
}

const params = {
  name: "My Token",
  ticker: "MINE",
  description: "Created through my launchpad",
  imageUrl: "https://cdn.example.com/mine.png",
  telegram: "",
  twitter: "",
  website: "",
  creatorFeeSplitBps: 5_000,
  gainBps: 50_000,
  targetRaise: parseEther("1"),
  antiSnipeDuration: 0,
  startTime: 0n,
} as const

const prebuy = 0n // Set a native amount, such as parseEther("0.01"), if wanted.

const { request } = await publicClient.simulateContract({
  account,
  address: hook,
  abi: CREATE_LAUNCH_ABI,
  functionName: "createLaunch",
  args: [params],
  value: prebuy,
})

const transactionHash = await walletClient.writeContract(request)

// Save transactionHash now. A page reload must resume this transaction, not send a new one.
const receipt = await publicClient.waitForTransactionReceipt({
  hash: transactionHash,
  confirmations: 1,
})
if (receipt.status !== "success") throw new Error("Launch reverted")

const created = parseEventLogs({
  abi: CREATE_LAUNCH_ABI,
  eventName: "LaunchCreated",
  logs: receipt.logs,
}).filter((log) => isAddressEqual(log.address, hook))

if (created.length !== 1) throw new Error("Expected one LaunchCreated event")

const launch = created[0].args
if (!isAddressEqual(launch.creator, account)) {
  throw new Error("Receipt creator does not match the connected wallet")
}
if (launch.targetRaise !== params.targetRaise) {
  throw new Error("Receipt target does not match the signed launch")
}

const result = {
  chainId: chain.id,
  hook,
  launchId: launch.launchId,
  tokenAddress: launch.token,
  transactionHash,
}

Persist all five identity fields. A token address without its chain, hook, and launch ID is not enough to route future reads and trades safely.

4. Wait for discovery

The receipt is the launch truth. The API is an indexed view and may appear shortly after the receipt.

async function waitForToken(chainId: number, address: string) {
  const delays = [500, 1_000, 2_000, 4_000, 8_000]

  for (const delay of delays) {
    const response = await fetch(
      `https://inkypump.com/api/token?chainId=${chainId}&address=${address}`,
      { cache: "no-store" },
    )
    if (response.ok) return response.json()
    if (response.status !== 404) {
      throw new Error(`Token lookup failed: ${response.status}`)
    }
    await new Promise((resolve) => setTimeout(resolve, delay))
  }

  return null // Confirmed on-chain, still indexing. Do not resubmit the launch.
}

Run this on your server and return the result to your frontend. While it returns null, show Confirmed — indexing with the transaction link.

5. Link to the token

const chainSlug = result.chainId === 57073 ? "ink" : "robinhood"
const tradeUrl = `https://inkypump.com/${chainSlug}/trade/${result.tokenAddress}`

Native launch limits

Field	Current native rule
`targetRaise`	1 to 5 ETH
`gainBps`	0 to 200,000
`creatorFeeSplitBps`	0 to 10,000
`startTime`	`0` for immediate, or a future Unix timestamp
`msg.value`	Optional creator prebuy in native wei
Total token supply	1,000,000,000 tokens with 18 decimals

Read contract limits from the selected deployment before exposing them in a long-lived client. For xStocks launches, the limits and units are per asset; use the xStocks guide.

Do not do these things

Do not hardcode the deprecated Ink hook 0x4cC8…6AC4 for new launches.
Do not retry createLaunch because receipt waiting timed out. Resume by hash.
Do not treat an API 404 just after confirmation as a failed launch.
Do not submit from a shared backend wallet unless that wallet should own the creator fees.
Do not guess a post-bond pool. Use getLaunchPoolKey on corrected/current hooks and complete indexed fields on ink-legacy, then validate the computed pool ID.
Do not expose a private key in a browser or partner API.

Deployments

Runtime discovery, active hooks, and legacy routing.

Production checklist

Failure cases and release gates before you ship.

​The whole flow

​1. Resolve the current deployment

​2. Use the creation ABI

​3. Simulate, sign, and prove the receipt

​4. Wait for discovery

​5. Link to the token

​Native launch limits

​Do not do these things

Deployments

Production checklist

The whole flow

1. Resolve the current deployment

2. Use the creation ABI

3. Simulate, sign, and prove the receipt

4. Wait for discovery

5. Link to the token

Native launch limits

Do not do these things