use-clanker-sdk

name: use-clanker-sdk description: Deploy ERC-20 tokens with Uniswap V4 liquidity using the Clanker SDK. Use when the user asks to deploy a token, create a coin, launch a token, configure liquidity pools, claim rewards, set up airdrops, presales, vaults, or interact with Clanker contracts.

Using the Clanker SDK

Overview

Clanker SDK (clanker-sdk) deploys ERC-20 tokens with automatic Uniswap V4 liquidity pools on multiple EVM chains. It handles token creation, pool setup, fee hooks, vesting vaults, airdrops, presales, and reward distribution in a single transaction.

Installation

npm install clanker-sdk viem

Supported Chains

Import chains from viem/chains except Monad (import from clanker-sdk).

Quick Start

import { Clanker } from 'clanker-sdk/v4';
import { createPublicClient, createWalletClient, http, type PublicClient } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

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

const clanker = new Clanker({ wallet, publicClient });

const { txHash, waitForTransaction, error } = await clanker.deploy({
  name: 'My Token',
  symbol: 'TKN',
  image: 'ipfs://...',
  tokenAdmin: account.address,
  chainId: base.id,
  vanity: true,
});
if (error) throw error;

const { address } = await waitForTransaction();

Imports

// V4 SDK (primary)
import { Clanker } from 'clanker-sdk/v4';

// Constants and helpers
import { FEE_CONFIGS, POOL_POSITIONS, WETH_ADDRESSES } from 'clanker-sdk';

// Extensions
import { createAirdrop, fetchAirdropProofs, registerAirdrop, getClaimAirdropTransaction } from 'clanker-sdk/v4/extensions';
import { startPresale, buyIntoPresale, endPresale, claimTokens } from 'clanker-sdk/v4/extensions';

// Types
import type { ClankerTokenV4 } from 'clanker-sdk';

Token Configuration Reference

Required Fields

Optional Fields with Defaults

Pool Configuration

Defaults to WETH pair with Standard positions if omitted.

pool: {
  pairedToken: 'WETH',           // or a specific token address
  tickIfToken0IsClanker: -230400, // starting tick
  tickSpacing: 200,
  positions: POOL_POSITIONS.Standard,
}

Pool position presets (POOL_POSITIONS):

• Standard — single full-range position (simplest)
• Project — 5 positions for better liquidity distribution
• TwentyETH — starts at ~20 ETH market cap

For custom paired tokens (not WETH), pass the token address directly:

import { WBNB_ADDRESS, BSC_USDT_ADDRESS } from 'clanker-sdk';

pool: { pairedToken: BSC_USDT_ADDRESS }

Fee Configuration

Use presets from FEE_CONFIGS:

fees: FEE_CONFIGS.StaticBasic   // 1% flat fee on both tokens
fees: FEE_CONFIGS.DynamicBasic  // 1-5% volatility-based
fees: FEE_CONFIGS.Dynamic3      // 1-3% volatility-based

Or define custom fees:

// Static
fees: { type: 'static', clankerFee: 100, pairedFee: 100 }

// Dynamic
fees: {
  type: 'dynamic',
  baseFee: 100,
  maxFee: 500,
  referenceTickFilterPeriod: 30,
  resetPeriod: 120,
  resetTickFilter: 200,
  feeControlNumerator: 500000000,
  decayFilterBps: 7500,
}

Monad only supports static fees.

Sniper Fees (MEV Protection)

Default enabled on v4.1+ chains. Units are "uniBps" (bps * 100).

sniperFees: {
  startingFee: 666_777,  // 66.6777%
  endingFee: 41_673,     // 4.1673%
  secondsToDecay: 15,
}

Vault (Token Vesting)

Lock a percentage of supply with optional linear vesting.

vault: {
  percentage: 10,              // 0-90% of supply
  lockupDuration: 2592000,     // minimum 7 days (in seconds)
  vestingDuration: 2592000,    // linear vesting after lockup
  recipient: account.address,  // defaults to tokenAdmin
}

Dev Buy

Buy tokens in the same deployment transaction.

devBuy: {
  ethAmount: 0.01,              // ETH to spend
  recipient: account.address,   // defaults to tokenAdmin
}

Rewards

Split LP fee rewards among recipients. Must sum to 10000 bps (100%).

rewards: {
  recipients: [
    { admin: addr1, recipient: addr1, bps: 5000, token: 'Both' },
    { admin: addr2, recipient: addr2, bps: 5000, token: 'Paired' },
  ],
}

token options: 'Both', 'Paired', 'Clanker'. If rewards is omitted, 100% goes to tokenAdmin.

Airdrop

Distribute tokens via Merkle tree with lockup.

import { createAirdrop } from 'clanker-sdk/v4/extensions';

const { tree, airdrop } = createAirdrop([
  { account: '0x...', amount: 200_000_000 },
  { account: '0x...', amount: 50_000_000 },
]);

// In deploy config:
airdrop: {
  ...airdrop,
  lockupDuration: 86_400,   // minimum 1 day (in seconds)
  vestingDuration: 86_400,
}

After deploy, register with registerAirdrop(tokenAddress, tree) so users can claim via the Clanker service.

Presale

presale: { bps: 2000 }  // 20% of supply allocated to presale

Deploy via presale extension functions: startPresale, buyIntoPresale, endPresale, claimTokens.

Context (Social Provenance)

context: {
  interface: 'My App',
  platform: 'farcaster',
  messageId: '0x...',
  id: '12345',
}

Post-Deployment Operations

Claim Rewards

const { txHash, error } = await clanker.claimRewards({
  token: '0x...',
  rewardRecipient: '0x...',
});

Check Available Rewards

const rewards = await clanker.availableRewards({
  token: '0x...',
  rewardRecipient: '0x...',
});

Claim Vaulted Tokens

const { txHash, error } = await clanker.claimVaultedTokens({ token: '0x...' });

Update Token Image

await clanker.updateImage({ token: '0x...', newImage: 'ipfs://...' });

Update Token Metadata

await clanker.updateMetadata({
  token: '0x...',
  metadata: { description: 'Updated description' },
});

Update Reward Recipient / Admin

await clanker.updateRewardRecipient({ token: '0x...', rewardIndex: 0, newRecipient: '0x...' });
await clanker.updateRewardAdmin({ token: '0x...', rewardIndex: 0, newAdmin: '0x...' });

Error Handling Pattern

All SDK methods return { txHash?, error?, waitForTransaction? }. Always check error:

const { txHash, waitForTransaction, error } = await clanker.deploy(config);
if (error) {
  console.error(error.message);
  throw error;
}
const { address, error: txError } = await waitForTransaction();
if (txError) throw txError;

Environment Variables

Additional Resources

• For full examples, see the examples/v4/ directory in the repo
• For presale lifecycle, see examples/v4/presale/
• For V3 (legacy), import from clanker-sdk/v3