Clawncher Documentation

Clawncher is a token launcher on Base that deploys ERC-20 tokens with Uniswap V4 liquidity pools, MEV protection, and configurable fee distribution.

Version: 0.1.0 Chain: Base License: MIT

Agent Skill (Quick Start) | Raw Markdown

Architecture Overview

Clawncher v0.1.0 wraps Clanker internally — the SDK translates your deploy options into Clanker's approved Uniswap V4 infrastructure. The Clawncher API surface stays the same.

User calls ClawnchDeployer.deploy(options)
  1. SDK validates config and translates to Clanker format
  2. Clanker SDK deploys via approved Uniswap V4 infrastructure
  3. Pool initialized with MEV protection and fee distribution
  4. Extensions execute (vault lockup, dev buy)
  5. Token is immediately tradeable on Uniswap

> Note: v0.1.0 uses Clanker's approved Uniswap V4 hook. Same Clawncher API, approved infrastructure.

Contract relationships:

ClawnchFactory (orchestrator)
  |-- ClawnchToken (ERC-20, deployed via CREATE2)
  |-- ClawnchHookStaticFeeV2 (Uniswap V4 hook, deployed via CREATE2)
  |     |-- ClawnchMevDescendingFees (MEV module, called by hook)
  |     +-- ClawnchPoolExtensionAllowlist (extension gating)
  |-- ClawnchLpLockerFeeConversion (LP position manager + fee distributor)
  |     |-- ClawnchLpLockerLib (external library for swap logic)
  |     +-- ClawnchFeeLocker (fee escrow, recipients claim from here)
  +-- Extensions (optional)
        |-- ClawnchVault (token lockup + vesting)
        |-- ClawncherAirdropV2 (merkle-based airdrop with vesting)
        |-- ClawncherUniv4EthDevBuy (instant dev buy at launch)
        +-- ClawncherVestedDevBuy (dev buy with lockup + vesting)

Contract Addresses

Base Mainnet (via Clanker v4)

Base Sepolia (via Clanker v4)

Base Mainnet (v2 Direct - Legacy)

Base Sepolia (v2 Direct - Legacy)

Deprecated (v1)

Smart Contracts

> Note: These contracts are part of Clanker's v4 infrastructure. Clawncher wraps them via the SDK — Clawncher does not deploy its own Uniswap hook or factory contracts.

ClawnchFactory

Source: contracts/src/ClawnchFactory.sol Inherits: OwnerAdmins, ReentrancyGuard, IClawnch

The factory is the main entry point for deploying tokens. It orchestrates token creation, pool initialization, LP position minting, MEV module setup, and extension execution.

Constants:

• TOKEN_SUPPLY: 100,000,000,000 tokens (100B with 18 decimals)
• BPS: 10,000 (basis points)
• MAX_EXTENSIONS: 10
• MAX_EXTENSION_BPS: 9,000 (90% max for extensions)

Storage:

// Deploy a token with full infrastructure (pool, LP, MEV, extensions)
function deployToken(DeploymentConfig memory config) external payable returns (address tokenAddress);

// Deploy a token with zero initial supply (cross-chain)
function deployTokenZeroSupply(TokenConfig memory config) external returns (address tokenAddress);

// Read deployment info for a token
function tokenDeploymentInfo(address token) external view returns (DeploymentInfo memory);

// Admin: enable/disable modules
function setHook(address hook, bool enabled) external onlyOwner;
function setLocker(address locker, address hook, bool enabled) external onlyOwner;
function setMevModule(address mevModule, bool enabled) external onlyOwner;
function setExtension(address extension, bool enabled) external onlyOwner;
function setVaultExtension(address vaultExtension) external onlyOwner;
function setTeamFeeRecipient(address recipient) external onlyOwner;
function setDeprecated(bool deprecated) external onlyOwner;

Deployment Config Structs:

struct DeploymentConfig {
    TokenConfig tokenConfig;
    PoolConfig poolConfig;
    LockerConfig lockerConfig;
    MevModuleConfig mevModuleConfig;
    ExtensionConfig[] extensionConfigs;
}

struct TokenConfig {
    address tokenAdmin;
    string name;
    string symbol;
    bytes32 salt;          // CREATE2 salt (for vanity addresses)
    string image;
    string metadata;       // JSON string
    string context;        // JSON string
    uint256 originatingChainId;
}

struct PoolConfig {
    address hook;
    address pairedToken;   // Typically WETH
    int24 tickIfToken0IsClawnch;  // Starting price tick
    int24 tickSpacing;
    bytes poolData;        // Encoded PoolInitializationData
}

struct LockerConfig {
    address locker;
    address[] rewardAdmins;
    address[] rewardRecipients;
    uint16[] rewardBps;    // Must sum to 10000
    int24[] tickLower;
    int24[] tickUpper;
    uint16[] positionBps;  // Must sum to 10000
    bytes lockerData;      // Encoded LpFeeConversionInfo
}

struct MevModuleConfig {
    address mevModule;
    bytes mevModuleData;   // Encoded (startingFee, endingFee, secondsToDecay)
}

struct ExtensionConfig {
    address extension;
    uint256 msgValue;      // ETH to send (for dev buy)
    uint16 extensionBps;   // % of supply to allocate
    bytes extensionData;
}

Events:

event TokenCreated(
    address msgSender,
    address indexed tokenAddress,
    address indexed tokenAdmin,
    string tokenImage,
    string tokenName,
    string tokenSymbol,
    string tokenMetadata,
    string tokenContext,
    int24 startingTick,
    address poolHook,
    PoolId poolId,
    address pairedToken,
    address locker,
    address mevModule,
    uint256 extensionsSupply,
    address[] extensions
);
event SetDeprecated(bool deprecated);
event SetVaultExtension(address oldVaultExtension, address newVaultExtension);
event SetTeamFeeRecipient(address oldRecipient, address newRecipient);

ClawnchToken

Source: contracts/src/ClawnchToken.sol

ERC-20 token deployed via CREATE2 from the factory. Includes on-chain metadata storage.

Key Functions:

function admin() external view returns (address);
function originalAdmin() external view returns (address);
function imageUrl() external view returns (string memory);
function metadata() external view returns (string memory);
function context() external view returns (string memory);
function allData() external view returns (
    address originalAdmin, address admin, string memory image,
    string memory metadata, string memory context
);
function setAdmin(address newAdmin) external;        // Only current admin
function setImageUrl(string memory image) external;  // Only admin

ClawnchHookStaticFeeV2

Source: contracts/src/hooks/ClawnchHookStaticFeeV2.sol Inherits: ClawnchHookV2

Uniswap V4 hook deployed via CREATE2. The address must end in 0x28CC to encode the required hook permission bits:

• BEFORE_INITIALIZE (bit 13)
• BEFORE_ADD_LIQUIDITY (bit 11)
• BEFORE_SWAP (bit 7)
• AFTER_SWAP (bit 6)
• BEFORE_SWAP_RETURNS_DELTA (bit 3)
• AFTER_SWAP_RETURNS_DELTA (bit 2)

Constructor:

constructor(
    IPoolManager poolManager_,
    address factory_,
    address poolExtensionAllowlist_,
    address weth_
)

Key Functions:

// Pool initialization (called by factory via initializePool)
function initializePool(
    PoolKey memory poolKey,
    int24 startingTick,
    bytes calldata initData
) external returns (PoolKey memory);

// MEV module
function initializeMevModule(PoolKey calldata poolKey, bytes calldata data) external;
function mevModuleEnabled(PoolId poolId) external view returns (bool);
function poolCreationTimestamp(PoolId poolId) external view returns (uint256);
function MAX_MEV_MODULE_DELAY() external view returns (uint256); // 120 seconds

// Fee reads
function clawnchFee(PoolId poolId) external view returns (uint24);
function pairedFee(PoolId poolId) external view returns (uint24);
function protocolFee() external view returns (uint24); // Uses transient storage

Protocol Fee (Transient Storage):

The protocolFee is stored in EVM transient storage (Cancun tstore/tload) to prevent a shared-state vulnerability where reentrant fee collection swaps could read stale protocol fee values. Each _setFee() call writes to transient storage before _afterSwap() reads from it.

bytes32 private constant PROTOCOL_FEE_SLOT = keccak256("clawncher.hook.protocolFee");

function _setProtocolFee(uint24 lpFee) internal {
    uint24 fee = uint24(uint256(lpFee) * PROTOCOL_FEE_NUMERATOR / uint128(FEE_DENOMINATOR));
    bytes32 slot = PROTOCOL_FEE_SLOT;
    assembly { tstore(slot, fee) }
}

function _getProtocolFee() internal view returns (uint24 fee) {
    bytes32 slot = PROTOCOL_FEE_SLOT;
    assembly { fee := tload(slot) }
}

ClawnchLpLockerFeeConversion

Source: contracts/src/lp-lockers/ClawnchLpLockerFeeConversion.sol Inherits: IClawnchLpLockerFeeConversion, ReentrancyGuard, Ownable

Manages LP positions and distributes trading fees to reward recipients. Supports up to 7 recipients with configurable fee preferences (receive in token, WETH, or both).

Constants:

• MAX_REWARD_PARTICIPANTS: 7
• MAX_LP_POSITIONS: 7
• BASIS_POINTS: 10,000

Immutables:

• positionManager, poolManager, permit2, feeLocker, universalRouter, factory

Key State:

• maxSlippageBps: Slippage protection for fee conversion swaps (default 500 = 5%, max 5000 = 50%)

Key Functions:

// Place liquidity for a newly deployed token (called by factory)
function placeLiquidity(
    IClawnch.LockerConfig memory lockerConfig,
    IClawnch.PoolConfig memory poolConfig,
    PoolKey memory poolKey,
    uint256 poolSupply,
    address token
) external onlyFactory returns (uint256 positionId);

// Collect and distribute fees (anyone can call)
function collectRewards(address token) external;
function collectRewardsWithoutUnlock(address token) external;

// Reward management (only reward admin for that index)
function updateRewardRecipient(address token, uint256 rewardIndex, address newRecipient) external;
function updateRewardAdmin(address token, uint256 rewardIndex, address newAdmin) external;
function updateFeePreference(address token, uint256 rewardIndex, FeeIn newPreference) external;

// Read reward info
function tokenRewards(address token) external view returns (TokenRewardInfo memory);
function feePreferences(address token, uint256 index) external view returns (FeeIn);

// Owner admin
function setMaxSlippageBps(uint16 bps) external onlyOwner;
function withdrawETH(address recipient) external onlyOwner;
function withdrawERC20(address token, address recipient) external onlyOwner;

Fee Preference Enum:

enum FeeIn {
    Both,    // 0 - Receive in both tokens
    Paired,  // 1 - Receive in paired token (WETH)
    Clawnch  // 2 - Receive in the launched token
}

Fee Collection Flow:

1. collectRewards / collectRewardsWithoutUnlock called (by hook on every swap, or manually)
2. LP fees collected from all positions via PositionManager
3. For each fee token (token0, token1):

• Recipients wanting the other token get their share swapped
• Recipients wanting this token get direct distribution

1. All fees deposited into ClawnchFeeLocker for recipient claiming

ClawnchLpLockerLib

Source: contracts/src/lp-lockers/ClawnchLpLockerLib.sol

External library containing swap logic for fee conversion when the pool is locked. Deployed as a separate contract and called via delegatecall from the locker.

library ClawnchLpLockerLib {
    function uniSwapLocked(
        IPermit2 permit2,
        IUniversalRouter universalRouter,
        PoolKey memory poolKey,
        address tokenIn,
        address tokenOut,
        uint128 amountIn,
        uint16 maxSlippageBps
    ) public returns (uint256);
}

This was made external (from internal) to reduce ClawnchLpLockerFeeConversion bytecode from ~25.5KB to ~24.5KB, staying under the EVM 24,576-byte code size limit.

ClawnchFeeLocker

Source: contracts/src/ClawnchFeeLocker.sol Inherits: IClawnchFeeLocker, ReentrancyGuard, Ownable

Escrow contract that holds accumulated LP fees per (recipient, token) pair. Recipients claim their fees from here.

// Deposit fees (only allowed depositors - the LP locker)
function storeFees(address feeOwner, address token, uint256 amount) external;

// Claim fees (by the fee owner themselves)
function claim(address feeOwner, address token) external;

// Read available fees
function availableFees(address feeOwner, address token) external view returns (uint256);

// Admin
function addDepositor(address depositor) external onlyOwner;

ClawnchMevDescendingFees

Source: contracts/src/mev-modules/ClawnchMevDescendingFees.sol

MEV protection module that implements a descending fee curve. At token launch, the swap fee starts high (default 80%) and decays linearly to a low fee (default 5%) over a configurable period (default 30 seconds). This prevents sandwich attacks and sniper bots from extracting value at launch.

Key Functions:

// Initialize for a pool (called by hook)
function initialize(PoolKey calldata poolKey, bytes calldata data) external;

// Called before each swap to compute current fee
function beforeSwap(
    PoolKey calldata poolKey,
    SwapParams calldata swapParams,
    bool clawnchIsToken0,
    bytes calldata mevModuleSwapData
) external returns (bool disableMevModule);

// Read current fee for a pool
function getFee(PoolId poolId) external view returns (uint24);

Fee Decay Formula:

elapsed = block.timestamp - poolStartTime
if elapsed >= secondsToDecay + delayGuard:
    fee = endingFee  (MEV module disables itself)
else:
    fee = startingFee - (startingFee - endingFee) * elapsed / secondsToDecay

The delayGuard (1 second) ensures the boundary condition is handled correctly (>= instead of >).

Errors:

• SameSecondAsDeployment() - Cannot swap in the same second the pool was created
• PoolAlreadyInitialized() - Pool already has MEV config
• TimeDecayLongerThanMaxMevDelay() - Decay period exceeds hook's MAX_MEV_MODULE_DELAY (120s)

ClawnchVault

Source: contracts/src/extensions/ClawnchVault.sol

Extension that allocates a percentage of token supply into a vault with lockup and optional vesting. Uses SafeERC20 for all transfers.

// Read allocation
function allocation(address token) external view returns (
    address token_, uint256 amountTotal, uint256 amountClaimed,
    uint256 lockupEndTime, uint256 vestingEndTime, address admin
);

// Claimable amount (respects lockup + linear vesting)
function amountAvailableToClaim(address token) external view returns (uint256);

// Claim vested tokens (only admin)
function claim(address token) external;

// Transfer admin (only current admin)
function editAllocationAdmin(address token, address newAdmin) external;

Lockup + Vesting:

• lockupDuration: Time before any tokens can be claimed (min 7 days)
• vestingDuration: Linear vesting period after lockup (0 = instant after lockup)
• Claimable: (amountTotal * elapsed_since_lockup / vestingDuration) - amountClaimed

ClawncherAirdropV2

Source: contracts/src/extensions/ClawncherAirdropV2.sol

Extension for merkle-tree-based token airdrops with lockup and vesting.

ClawncherUniv4EthDevBuy

Source: contracts/src/extensions/ClawncherUniv4EthDevBuy.sol

Extension that executes a token buy at launch using ETH. The purchased tokens are transferred immediately to the recipient. Requires sending ETH as msg.value in the deployment transaction.

ClawncherVestedDevBuy

Source: contracts/src/extensions/ClawncherVestedDevBuy.sol

Extension that executes a token buy at launch using ETH, then holds the purchased tokens in a vesting schedule. Combines dev buy with lockup + linear vesting.

// Read allocation
function allocation(address token) external view returns (...);
function amountAvailableToClaim(address token) external view returns (uint256);

// Claim vested tokens
function claim(address token) external;
function editAllocationAdmin(address token, address newAdmin) external;

Constraints:

• Lockup: minimum 7 days
• Vesting: minimum 30 days, maximum 365 days

ClawnchPoolExtensionAllowlist

Source: contracts/src/hooks/ClawnchPoolExtensionAllowlist.sol

Allowlist for pool extensions that can be used during token deployment. Only the owner can enable/disable extensions.

function setPoolExtension(address extension, bool allowed) external onlyOwner;
function enabledExtensions(address extension) external view returns (bool);

SDK Reference

Installation

npm install @clawnch/clawncher-sdk viem

The SDK requires viem as a peer dependency for chain interaction.

ClawnchDeployer

Deploy tokens on Base with Uniswap V4 pools.

import { ClawnchDeployer } from '@clawnch/clawncher-sdk';
import { createWalletClient, createPublicClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { baseSepolia } from 'viem/chains';

const account = privateKeyToAccount('0x...');
const wallet = createWalletClient({
  account,
  chain: baseSepolia,
  transport: http(),
});
const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

const deployer = new ClawnchDeployer({
  wallet,
  publicClient,
  network: 'sepolia', // or 'mainnet'
});

deploy(options)

Deploy a new token with full infrastructure.

const result = await deployer.deploy({
  // Required
  name: 'My Token',
  symbol: 'MYTKN',
  tokenAdmin: account.address,
  rewards: {
    recipients: [{
      recipient: account.address,
      admin: account.address,
      bps: 8000,  // 80% of fees
      feePreference: 'Clawnch', // Receive fees in launched token
    }, {
      recipient: '0xProtocolWallet...',
      admin: '0xProtocolAdmin...',
      bps: 2000,  // 20% of fees
      feePreference: 'Paired', // Receive fees in WETH
    }],
  },

  // Optional
  image: 'https://example.com/logo.png',
  metadata: { description: 'A token for testing' },
  context: { platform: 'my-app', messageId: '123' },

  // Vault allocation (optional)
  vault: {
    percentage: 10,          // 10% of supply
    lockupDuration: 604800,  // 7 days in seconds
    vestingDuration: 2592000, // 30 days vesting after lockup
    recipient: account.address,
  },

  // Dev buy at launch (optional, instant transfer)
  devBuy: {
    ethAmount: parseEther('0.01'),
    recipient: account.address,
  },

  // Vanity address (optional, default: enabled)
  vanity: true,

  // Dry run (optional, validate without deploying)
  dryRun: true,
});

// Wait for confirmation
const { address } = await result.waitForTransaction();
console.log('Token:', address);
console.log('Tx:', result.txHash);

DeployOptions:

ClawnchReader

Read on-chain token data from deployed contracts.

import { ClawnchReader } from '@clawnch/clawncher-sdk';
import { createPublicClient, http } from 'viem';
import { base } from 'viem/chains';

const publicClient = createPublicClient({
  chain: base,
  transport: http(),
});

const reader = new ClawnchReader({
  publicClient,
  network: 'mainnet',
});

Methods

// Full token details (combines all data in parallel)
const details = await reader.getTokenDetails('0xToken...');
// Returns: TokenDetails { address, name, symbol, decimals, totalSupply,
//   tokenAdmin, originalAdmin, image, metadata, context,
//   deployment, rewards, vault, vestedDevBuy, mev }

// Basic ERC20 info
const info = await reader.getTokenInfo('0xToken...');
// Returns: { name, symbol, decimals, totalSupply }

// Clawncher metadata (uses single allData() call)
const meta = await reader.getTokenMetadata('0xToken...');
// Returns: { tokenAdmin, originalAdmin, image, metadata, context }

// Factory deployment info
const deployment = await reader.getDeploymentInfo('0xToken...');
// Returns: { token, hook, locker, extensions } | null

// LP reward configuration
const rewards = await reader.getTokenRewards('0xToken...');
// Returns: TokenRewardInfo { token, poolKey, positionId, numPositions,
//   rewardBps, rewardAdmins, rewardRecipients } | null

// Vault allocation
const vault = await reader.getVaultAllocation('0xToken...');
// Returns: VaultAllocation { amountTotal, amountClaimed, lockupEndTime,
//   vestingEndTime, admin, amountAvailable, isUnlocked,
//   isFullyVested, percentVested } | null

// Vested dev buy allocation
const vested = await reader.getVestedDevBuyAllocation('0xToken...');
// Returns: VestedDevBuyAllocation (same shape as VaultAllocation) | null

// Available fees for a wallet
const fees = await reader.getAvailableFees('0xWallet...', '0xToken...');
// Returns: bigint

// Fees across multiple tokens
const walletFees = await reader.getWalletFees('0xWallet...', ['0xToken1...', '0xToken2...']);
// Returns: WalletFeeInfo { wallet, tokens: [...], totalWeth, formattedTotalWeth }

// MEV protection config (by poolId or token)
const mev = await reader.getMevConfig('0xPoolId...');
const mev2 = await reader.getMevConfigForToken('0xToken...');
// Returns: MevConfigInfo { startingFee, endingFee, secondsToDecay,
//   poolStartTime, decayEndTime, currentFee, isDecayComplete }

// Check if a token was deployed via Clawncher
const isClawnch = await reader.isClawnchToken('0xToken...');
// Returns: boolean

ClawncherClaimer

Claim fees, vault allocations, and vested dev buy allocations.

import { ClawncherClaimer } from '@clawnch/clawncher-sdk';

const claimer = new ClawncherClaimer({
  wallet,       // WalletClient
  publicClient, // PublicClient
  network: 'mainnet',
});

Methods

// Collect LP rewards (triggers fee collection from positions)
const tx1 = await claimer.collectRewards('0xToken...');
// Returns: { txHash }

// Claim fees from FeeLocker
const tx2 = await claimer.claimFees('0xWallet...', '0xToken...');
// Returns: { txHash }

// Claim vault allocation
const tx3 = await claimer.claimVault('0xToken...');
// Returns: { txHash }

// Claim vested dev buy allocation
// Note: Throws ClawnchDeployError (FEATURE_NOT_AVAILABLE). Use claimVault for lockup claims.
const tx4 = await claimer.claimVestedDevBuy('0xToken...');
// Returns: { txHash }

// Claim everything (collect + claim WETH fees + claim token fees)
const result = await claimer.claimAll('0xToken...', '0xFeeOwner...');
// Returns: { collectRewards: ClaimTxResult, claimFeesWeth: ClaimTxResult | null, claimFeesToken: ClaimTxResult | null }

Error Handling

The SDK exports structured error types for all failure modes.

import { ClawnchDeployError, ClawnchErrorCode } from '@clawnch/clawncher-sdk';

try {
  const result = await deployer.deploy(options);
  await result.waitForTransaction();
} catch (err) {
  if (err instanceof ClawnchDeployError) {
    console.error(err.code);    // ClawnchErrorCode enum
    console.error(err.message); // Human-readable message
    console.error(err.cause);   // Original error (optional)
  }
}

ClawnchErrorCode:

ClawnchPortfolio

Track tokens and claimable fees across a wallet.

import { ClawnchPortfolio } from '@clawnch/clawncher-sdk';

const portfolio = new ClawnchPortfolio({
  publicClient,
  network: 'mainnet',
});

// Discover tokens where wallet is admin, recipient, or deployer
const discovered = await portfolio.discoverTokens('0xWallet...');
// Returns: Address[]

// Get all Clawncher tokens with claimable fee details
const tokens = await portfolio.getTokensForWallet('0xWallet...', discovered);
// Returns: PortfolioToken[] { address, name, symbol, bps, claimableWeth, claimableToken, formattedWeth, formattedToken }

// Get total claimable across all tokens
const total = await portfolio.getTotalClaimable('0xWallet...', discovered);
// Returns: { weth: bigint, formattedWeth: string, tokens: [{ address, symbol, amount, formatted }] }

ClawnchWatcher

Watch for new token deployments in real-time.

import { ClawnchWatcher } from '@clawnch/clawncher-sdk';

const watcher = new ClawnchWatcher({
  publicClient,
  network: 'mainnet',
});

// Watch for new deployments (returns unsubscribe function)
const unwatch = watcher.watchDeployments(
  (event) => {
    console.log('New token:', event.tokenAddress, event.tokenName, event.tokenSymbol);
    console.log('Deployer:', event.deployer);
    console.log('Pool ID:', event.poolId);
  },
  { tokenAdmin: '0xOptionalFilter...' }, // optional: filter by token admin
);

// Stop watching
unwatch();

// Get historical deployments
const history = await watcher.getHistoricalDeployments({
  fromBlock: 12345678n,
  toBlock: 12999999n,
  tokenAdmin: '0xOptionalFilter...',
});
// Returns: NewTokenEvent[]

Batch Fee Claiming

Claim fees across multiple tokens in a single transaction.

import { ClawncherClaimer } from '@clawnch/clawncher-sdk';

const claimer = new ClawncherClaimer({
  wallet,
  publicClient,
  network: 'mainnet',
});

// Claim fees for multiple tokens at once
const result = await claimer.claimBatch(
  ['0xToken1...', '0xToken2...', '0xToken3...'],
  '0xFeeOwner...',
  {
    onProgress: (token, step) => console.log(`${token}: ${step}`),
  },
);
// Returns: BatchClaimResult { results: BatchClaimTokenResult[], successCount, failureCount }

console.log(`Claimed ${result.successCount} tokens, ${result.failureCount} failed`);
for (const r of result.results) {
  if (!r.success) console.error(`Failed ${r.token}: ${r.error?.message}`);
}

ClawnchSwapper

Swap tokens on Base via 0x aggregation routed through the Clawnch API. No 0x API key needed — the Clawnch server handles authentication and integrator fees.

import { ClawnchSwapper, NATIVE_TOKEN_ADDRESS } from '@clawnch/clawncher-sdk';
import { createWalletClient, createPublicClient, http, parseEther } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const account = privateKeyToAccount('0x...');
const wallet = createWalletClient({ account, chain: base, transport: http() });
const publicClient = createPublicClient({ chain: base, transport: http() });

const swapper = new ClawnchSwapper({ wallet, publicClient });

Methods

// Indicative price (no commitment, no taker required)
const price = await swapper.getPrice({
  sellToken: NATIVE_TOKEN_ADDRESS,
  buyToken: '0xTokenAddress...',
  sellAmount: parseEther('0.01'),
});
// Returns: SwapPriceResult { buyAmount, sellAmount, minBuyAmount, gas,
//   allowanceTarget, liquidityAvailable, route, fees, tokenMetadata }

// Firm quote (market makers commit, requires taker)
const quote = await swapper.getQuote({
  sellToken: NATIVE_TOKEN_ADDRESS,
  buyToken: '0xTokenAddress...',
  sellAmount: parseEther('0.01'),
});
// Returns: SwapQuoteResult { ...price fields, transaction: { to, data, gas, gasPrice, value } }

// Full swap: quote -> approve if needed -> send -> wait for confirmation
const result = await swapper.swap({
  sellToken: NATIVE_TOKEN_ADDRESS,
  buyToken: '0xTokenAddress...',
  sellAmount: parseEther('0.01'),
  slippageBps: 100,  // 1% (default)
});
// Returns: SwapResult { txHash, buyAmount, sellAmount, receipt, gasUsed, effectiveGasPrice }

// Token utilities
const allowance = await swapper.getAllowance(token, owner, spender);
const approveTx = await swapper.approveToken(token, spender);
const balance = await swapper.getBalance(token, owner);
const decimals = await swapper.getDecimals(token);
const symbol = await swapper.getSymbol(token);
const formatted = await swapper.formatAmount(token, amount);

SwapParams:

ClawnchLiquidity

Manage Uniswap V3 and V4 liquidity positions on Base. Supports reading positions, minting, adding/removing liquidity, and collecting fees.

import { ClawnchLiquidity } from '@clawnch/clawncher-sdk';

const liquidity = new ClawnchLiquidity({ wallet, publicClient });

V3 Methods

// Read a V3 position
const pos = await liquidity.v3GetPosition(tokenId);
// Returns: PositionInfo { tokenId, version: 'v3', token0, token1, fee,
//   tickLower, tickUpper, liquidity, unclaimedFees: { token0, token1 } }

// List all V3 positions for a wallet
const positions = await liquidity.v3GetPositionsForWallet(walletAddress);
// Returns: PositionInfo[]

// Get V3 positions filtered by a specific token
const filtered = await liquidity.getPositionsForToken(tokenAddress, walletAddress);

// Mint a new V3 position
const mint = await liquidity.v3MintPosition({
  token0: '0x...',
  token1: '0x...',
  fee: 3000,           // 0.3% fee tier
  tickLower: -887220,
  tickUpper: 887220,
  amount0Desired: parseEther('1000'),
  amount1Desired: parseEther('0.1'),
  recipient: account.address,  // optional, defaults to wallet
  deadline: 1200,              // optional, seconds from now (default: 20 min)
});
// Returns: MintResult { txHash, tokenId, amount0, amount1, liquidity, receipt }

// Add liquidity to existing position
const added = await liquidity.v3AddLiquidity(tokenId, {
  amount0Desired: parseEther('500'),
  amount1Desired: parseEther('0.05'),
});
// Returns: ModifyLiquidityResult { txHash, amount0, amount1, receipt }

// Remove liquidity (fractional: 0.0 to 1.0)
const removed = await liquidity.v3RemoveLiquidity(tokenId, {
  percentageToRemove: 0.5,   // 50%
  burnToken: false,           // burn NFT if removing 100%
});
// Returns: ModifyLiquidityResult { txHash, amount0, amount1, receipt }

// Collect unclaimed fees
const fees = await liquidity.v3CollectFees(tokenId, {
  recipient: account.address,  // optional
});
// Returns: CollectFeesResult { txHash, amount0, amount1, receipt }

V4 Methods

// Read V4 pool state
const state = await liquidity.v4GetPoolState(poolKey);
// Returns: V4PoolState { sqrtPriceX96, tick, liquidity, poolId }

// Read V4 position
const v4pos = await liquidity.v4GetPosition(tokenId);
// Returns: PositionInfo { tokenId, version: 'v4', ... }

// Execute V4 PositionManager multicall (use with @uniswap/v4-sdk calldata)
const { txHash, receipt } = await liquidity.v4ExecuteMulticall(calldata, value);

> Note: V4 mint/add/remove operations require @uniswap/v4-sdk for proper action encoding. Use V4PositionManager.addCallParameters() to generate calldata, then pass it to v4ExecuteMulticall().

ClawnchApiDeployer

Deploy tokens through the Clawnch API as a verified agent. Tokens deployed this way receive a verified badge on the Clawnch launchpad and appear in the dashboard.

Registration flow:

1. POST /api/agents/register — submit agent info, receive ECDSA challenge
2. Sign challenge with wallet
3. POST /api/agents/verify — submit signature, receive API key

Deploy flow:

1. Request captcha challenge from API
2. Solve: read on-chain storage slot, sign message, compute keccak proof
3. Submit solution + deploy params — server burns $CLAWNCH, deploys token

import { ClawnchApiDeployer } from '@clawnch/clawncher-sdk';

// One-time agent registration
const { apiKey } = await ClawnchApiDeployer.register({
  wallet,
  publicClient,
}, {
  name: 'MyAgent',
  wallet: account.address,
  description: 'An AI agent that launches tokens',
});

// Create deployer with API key
const apiDeployer = new ClawnchApiDeployer({
  apiKey,
  wallet,
  publicClient,
  apiBaseUrl: 'https://clawn.ch',  // default
});

Methods

// Check agent status (balance, verification, launch count)
const status = await apiDeployer.getStatus();
// Returns: AgentStatus { agentId, name, wallet, verified, clawnchAllowance, clawnchBalance, launchCount, registeredAt }

// One-time $CLAWNCH approval for the Clawnch deployer
const approval = await apiDeployer.approveClawnch();
// Returns: ApprovalResult { txHash, spender, amount }

// Check current allowance
const allowance = await apiDeployer.getClawnchAllowance(spenderAddress);

// Check $CLAWNCH balance
const balance = await apiDeployer.getClawnchBalance();

// Deploy a token (handles captcha automatically)
const result = await apiDeployer.deploy({
  name: 'My Token',
  symbol: 'MYTKN',
  image: 'https://example.com/logo.png',          // optional
  description: 'A token launched by my agent',     // optional
  // All standard deploy options supported
});
// Returns: ApiDeployResponse { txHash, tokenAddress, ... }

Requirements:

• Agent wallet must hold >= 100 $CLAWNCH (0xa1F72459dfA10BAD200Ac160eCd78C6b77a747be)
• One-time ERC20 approval for the Clawnch deployer wallet
• Captcha must be solved within 5 seconds (handled automatically by SDK)

ClawnchClient (API)

HTTP client for the Clawnch launchpad API at clawn.ch.

import { ClawnchClient } from '@clawnch/clawncher-sdk';

const client = new ClawnchClient({
  baseUrl: 'https://clawn.ch',   // default
  moltbookKey: 'secret-key',     // optional, for authenticated ops
  timeout: 30000,                // default 30s
});

Methods

// Tokens
const tokens = await client.getTokens();
const token = await client.getTokenBySymbol('MYTKN');

// Launches
const launches = await client.getLaunches({
  limit: 20, offset: 0, agent: 'agentName', source: 'moltbook'
});
const launch = await client.getLaunch('0xContractAddress...');

// Stats
const stats = await client.getStats();
// Returns: { totalTokens, totalVolume, clawnchPrice, clawnchMarketCap }

// Preview / validation
const preview = await client.preview('!clawnch\nname: Test\nsymbol: TST\n...');
// Returns: { valid, parsed, errors, warnings, checks }

// Fees
const fees = await client.getAvailableFees('0xWallet...', 'token1,token2');
const claim = await client.claimFees('0xTokenAddress...');

// Analytics
const tokenAnalytics = await client.getTokenAnalytics('0xAddress...');
const agentAnalytics = await client.getAgentAnalytics('agentName');
const leaderboard = await client.getLeaderboard('market_cap', 20);

// Utilities
const imageUrl = await client.uploadImage('base64data...');
const skill = await client.getSkill();
const spec = await client.getOpenAPISpec();

Types Reference

SDK exports these TypeScript types:

// Network
type NetworkName = 'mainnet' | 'sepolia';

// Deployer
interface DeployOptions { ... }
interface DeployResult { txHash, waitForTransaction, error }
interface DeployerConfig { wallet?, publicClient?, network? }
type FeePreference = 'Clawnch' | 'Paired' | 'Both';
interface RewardRecipient { recipient, admin, bps, feePreference? }
interface VaultConfig { percentage, lockupDuration, vestingDuration?, recipient }
interface AirdropConfig { percentage, admin, merkleRoot, lockupDuration, vestingDuration }
interface DevBuyConfig { ethAmount, recipient }
interface DryRunResult extends DeployResult { translatedConfig, valid, estimatedGas?, estimatedCostEth? }

// Reader
interface TokenDetails { address, name, symbol, ..., deployment, rewards, vault, vestedDevBuy, mev }
interface VaultAllocation { amountTotal, amountClaimed, ..., amountAvailable, isUnlocked, ... }
interface VestedDevBuyAllocation { ... } // Same shape as VaultAllocation
interface TokenRewardInfo { token, poolKey, positionId, numPositions, rewardBps, ... }
interface MevConfigInfo { startingFee, endingFee, secondsToDecay, currentFee, isDecayComplete }
interface WalletFeeInfo { wallet, tokens, totalWeth, formattedTotalWeth }

// Claiming
interface ClaimTxResult { txHash, wait: () => Promise<{ success }> }
interface ClaimAllResult { collectRewards: ClaimTxResult, claimFeesWeth: ClaimTxResult | null, claimFeesToken: ClaimTxResult | null }
interface BatchClaimResult { results: BatchClaimTokenResult[], successCount, failureCount }
interface BatchClaimTokenResult { token, success, collectRewards, claimFeesWeth, claimFeesToken, error? }

// Error handling
enum ClawnchErrorCode { INVALID_BPS, INVALID_NAME, INVALID_SYMBOL, INVALID_ADDRESS, WALLET_NOT_CONFIGURED, PUBLIC_CLIENT_NOT_CONFIGURED, DEPLOY_FAILED, TX_REVERTED, INSUFFICIENT_FUNDS, CLAIM_FAILED, NO_FEES_AVAILABLE, FEATURE_NOT_AVAILABLE, RPC_ERROR, TIMEOUT }
class ClawnchDeployError extends Error { code: ClawnchErrorCode, cause?: Error }

// Portfolio
interface PortfolioToken { address, name, symbol, bps, claimableWeth, claimableToken, formattedWeth, formattedToken }
interface TotalClaimable { weth, formattedWeth, tokens: [{ address, symbol, amount, formatted }] }

// Watcher
interface NewTokenEvent { tokenAddress, tokenAdmin, tokenName, tokenSymbol, tokenImage, deployer, poolHook, locker, poolId, blockNumber, txHash }

// API
interface Token { symbol, name, address, agent, launchedAt, source, ... }
interface Launch { id, symbol, name, contractAddress, txHash, ... }
interface Stats { totalTokens, totalVolume, clawnchPrice, clawnchMarketCap }
interface PreviewResponse { valid, parsed?, errors?, warnings?, checks }
interface FeesAvailable { wallet, weth: { available, formatted }, tokens: [...] }

// Addresses
interface ClawnchAddresses { factory, hook, locker, feeLocker, mevModule, vault, ... }
interface NetworkAddresses { clawnch: ClawnchAddresses, infrastructure: { poolManager, ... } }

// Swapper
interface SwapperConfig { wallet, publicClient, network?, apiBaseUrl? }
interface SwapParams { sellToken, buyToken, sellAmount, slippageBps?, taker?, ... }
interface SwapPriceResult { buyAmount, sellAmount, minBuyAmount, gas, allowanceTarget, liquidityAvailable, route, fees }
interface SwapQuoteResult extends SwapPriceResult { transaction: { to, data, gas, gasPrice, value } }
interface SwapResult { txHash, buyAmount, sellAmount, receipt, gasUsed, effectiveGasPrice }

// Liquidity
interface LiquidityConfig { wallet, publicClient, network? }
interface V4PoolKey { currency0, currency1, fee, tickSpacing, hooks }
interface V4PoolState { sqrtPriceX96, tick, liquidity, poolId }
interface PositionInfo { tokenId, version, token0, token1, fee, tickLower, tickUpper, liquidity, unclaimedFees }
interface MintResult { txHash, tokenId, amount0, amount1, liquidity, receipt }
interface ModifyLiquidityResult { txHash, amount0, amount1, receipt }
interface CollectFeesResult { txHash, amount0, amount1, receipt }

// API Deployer
interface ApiDeployerConfig { apiKey, wallet, publicClient, network?, apiBaseUrl? }
interface RegisterRequest { name, wallet, description }
interface RegisterResponse { registrationId, message }
interface VerifyResponse { apiKey, agentId, wallet }
interface AgentStatus { agentId, name, wallet, verified, clawnchAllowance, clawnchBalance, launchCount, registeredAt }
interface ApiDeployRequest { name, symbol, image?, description?, ... }
interface ApiDeployResponse { txHash, tokenAddress, ... }
interface ApprovalResult { txHash, spender, amount }

CLI Reference

CLI Installation

# Global install
npm install -g clawncher

# Or use npx
npx clawncher --help

CLI Configuration

Configuration is stored at ~/.clawncher/config.json (mode 0600).

# Set defaults
clawncher config --network mainnet
clawncher config --private-key 0x...
clawncher config --rpc-sepolia https://my-rpc.com
clawncher config --rpc-mainnet https://my-rpc.com

# Show current config
clawncher config --show

# Clear all config
clawncher config --clear

Environment variables:

• CLAWNCHER_PRIVATE_KEY - Deployer private key

CLI Commands

clawncher deploy

Deploy a new token with Uniswap V4 pool.

clawncher deploy --name <name> --symbol <symbol> [options]

Options:
  --name <name>                    Token name (required)
  --symbol <symbol>                Token symbol (required)
  --image <url>                    Token image URL
  --description <text>             Token description
  --recipient <address>            Fee recipient (defaults to deployer)
  --fee-preference <pref>          Clawnch | Paired | Both (default: Clawnch)
  --vault-percent <n>              Vault allocation % (1-90)
  --vault-lockup <days>            Vault lockup days (default: 7)
  --vault-vesting <days>           Vault vesting days after lockup (default: 0)
  --vault-recipient <address>      Vault recipient (defaults to deployer)
  --dev-buy <eth>                  ETH for instant dev buy
  --dev-buy-recipient <address>    Dev buy recipient (defaults to deployer)
  --no-vanity                      Disable 0xccc vanity mining
  --dry-run                        Validate config without deploying
  --network <network>              sepolia | mainnet
  --rpc <url>                      Custom RPC URL
  --private-key <key>              Private key
  --json                           Output as JSON

Example:

clawncher deploy --name "My Token" --symbol MYTKN \
  --description "A token for testing" \
  --fee-preference Paired \
  --vault-percent 10 \
  --vault-lockup 30 \
  --dev-buy 0.01 \
  --network sepolia \
  --private-key 0x...

clawncher info

Get full on-chain token details.

clawncher info 0xTokenAddress... --network mainnet

Displays: token metadata, deployment info, pool configuration, reward recipients, vault allocation, MEV protection state.

clawncher portfolio

View all Clawncher tokens for a wallet with claimable balances.

clawncher portfolio 0xWallet... --network mainnet --json

clawncher watch

Watch for new token deployments in real-time.

clawncher watch --network mainnet --json

clawncher fees check

Check claimable fees for a wallet directly from chain.

clawncher fees check 0xWallet... -t 0xToken1,0xToken2 --network mainnet

clawncher fees available

Check available fees via the Clawnch API.

clawncher fees available 0xWallet...

clawncher fees claim

Claim fees on-chain (collect LP rewards + claim from FeeLocker).

clawncher fees claim 0xToken... \
  --vault                 # Also claim vault allocation
  --collect-only          # Only collect LP rewards
  --skip-collect          # Skip LP collection, only claim FeeLocker
  --network mainnet \
  --private-key 0x...

clawncher fees batch-claim

Claim fees across multiple tokens at once.

clawncher fees batch-claim 0xToken1,0xToken2,0xToken3 \
  --vault                 # Also claim vault allocations
  --network mainnet \
  --private-key 0x...

clawncher config

Manage CLI configuration.

clawncher tokens

List all tokens launched via Clawncher (via API).

clawncher tokens --symbol MYTKN --limit 20 --json

clawncher launches

View launch history (via API).

clawncher launches --agent "my-agent" --source moltbook --limit 20

clawncher stats

Get market statistics (via API).

clawncher stats --json

clawncher addresses

Show contract addresses for a network.

clawncher addresses --network mainnet

clawncher about

Show Clawncher information and links.

clawncher swap

Swap tokens on Base via 0x aggregation.

clawncher swap --sell ETH --buy 0xToken... --amount 0.01 --network mainnet --private-key 0x...
clawncher swap --sell 0xToken... --buy ETH --amount 1000 --network mainnet

Options:
  --sell <token>       Token to sell (ETH or address)
  --buy <token>        Token to buy (ETH or address)
  --amount <value>     Amount of sell token
  --slippage <bps>     Slippage tolerance in bps (default: 100)
  --price-only         Only show price, don't execute
  --network <net>      mainnet | sepolia
  --private-key <key>  Private key (or use active wallet)
  --json               Output as JSON

Wallet Management

The CLI includes encrypted wallet storage using AES-256-GCM with scrypt KDF. Wallets are stored in ~/.clawncher/wallets/ with file permissions 0o600.

Security model:

• Private keys encrypted at rest with user-chosen password
• scrypt KDF (N=2^18, r=8, p=1) for key derivation
• AES-256-GCM authenticated encryption
• Directory permissions 0o700, file permissions 0o600
• Keys only decrypted on-demand, never cached in memory
• Mnemonic phrases encrypted alongside private key for recovery

clawncher wallet create

Create a new wallet with a fresh BIP-39 mnemonic phrase. Prompts for a password (min 8 characters).

clawncher wallet create my-wallet
# Outputs: address, mnemonic (write it down!)

clawncher wallet import

Import an existing wallet from a private key or mnemonic.

clawncher wallet import my-wallet --private-key 0x...
clawncher wallet import my-wallet --mnemonic "word1 word2 word3 ..."

clawncher wallet list

List all wallets with addresses and active status.

clawncher wallet list

clawncher wallet use

Set a wallet as the active default. When active, all commands use this wallet without needing --private-key.

clawncher wallet use my-wallet

clawncher wallet export

Export the private key (and mnemonic if available). Requires password.

clawncher wallet export my-wallet

clawncher wallet balance [name]

Check ETH and token balances for a wallet.

clawncher wallet balance my-wallet --network mainnet

clawncher wallet send

Send ETH from a wallet.

clawncher wallet send 0xRecipient... 0.1 --network mainnet

clawncher wallet password

Change wallet password.

clawncher wallet password my-wallet

clawncher wallet remove

Remove a wallet from storage.

clawncher wallet remove my-wallet

Deployment Guide

Prerequisites

• Foundry (forge, cast)
• Node.js >= 18
• Deployer wallet with ETH on Base

Deploying Contracts

The deployment process has two phases: contract deployment and initialization.

1. Deploy the external library first:

source .env.clawncher
cd contracts

# Deploy ClawnchLpLockerLib
forge create src/lp-lockers/ClawnchLpLockerLib.sol:ClawnchLpLockerLib \
  --private-key $CLAWNCHER_DEPLOYER_PRIVATE_KEY \
  --rpc-url https://mainnet.base.org \
  --broadcast

2. Get the hook init code hash (dry run without salt):

PRIVATE_KEY=$CLAWNCHER_DEPLOYER_PRIVATE_KEY \
forge script script/DeployClawnchMainnet.s.sol \
  --rpc-url https://mainnet.base.org -vvv

This prints the init code hash needed for CREATE2 salt mining.

3. Mine the hook salt:

cast create2 --ends-with 28CC \
  --deployer 0x4e59b44847b379578588920cA78FbF26c0B4956C \
  --init-code-hash <HASH_FROM_STEP_2>

The hook address must end in 0x28CC for the required Uniswap V4 permission bits.

4. Deploy all contracts:

PRIVATE_KEY=$CLAWNCHER_DEPLOYER_PRIVATE_KEY \
HOOK_SALT=<SALT_FROM_STEP_3> \
forge script script/DeployClawnchMainnet.s.sol \
  --rpc-url https://mainnet.base.org \
  --broadcast -vvv \
  --libraries src/lp-lockers/ClawnchLpLockerLib.sol:ClawnchLpLockerLib:<LIBRARY_ADDRESS>

Initialization

After deployment, run the initialization script to enable all modules:

PRIVATE_KEY=$CLAWNCHER_DEPLOYER_PRIVATE_KEY \
FACTORY=0x... HOOK=0x... LOCKER=0x... MEV_MODULE=0x... \
VAULT=0x... AIRDROP_V2=0x... DEV_BUY=0x... VESTED_DEV_BUY=0x... \
POOL_EXTENSION_ALLOWLIST=0x... FEE_LOCKER=0x... \
TEAM_FEE_RECIPIENT=0x... \
forge script script/InitializeClawnchMainnet.s.sol \
  --rpc-url https://mainnet.base.org --broadcast -vvv

Initialization steps (performed by the script):

1. Enable hook in factory
2. Enable locker for hook in factory
3. Enable MEV module in factory
4. Enable extensions (vault, airdropV2, devBuy, vestedDevBuy) in factory
5. Enable extensions in pool extension allowlist
6. Set vault extension address in factory
7. Add locker as allowed depositor in fee locker
8. Set team fee recipient
9. Undeprecate factory (enable deployments)

Building

# Build contracts (uses via_ir, slow)
cd contracts && forge build

# Run tests (64 tests)
cd contracts && forge test

# Build SDK + CLI
npm run build

# Publish
cd packages/sdk && npm publish --access public
cd packages/cli && npm publish --access public

Foundry config (contracts/foundry.toml):

• Solc: 0.8.28
• EVM: cancun (for transient storage)
• Optimizer: enabled, 1 run, via_ir

Fee Structure

Every swap through a Clawncher pool incurs a 1% LP Rewards (configurable, default 10000 pips).

Fee Distribution:

• 80% to deployer (or configured reward recipients)
• 20% protocol (collected via Clanker infrastructure)

The deployer's 80% can be split among up to 7 reward recipients, each with configurable fee preferences:

• Clawnch: Receive fees in the launched token (default)
• Paired: Receive fees in WETH
• Both: Receive fees as-is (no conversion)

Fee conversion swaps include slippage protection (default 5%, configurable by locker owner up to 50%).

Fee Collection Flow:

1. On every swap, the hook calls collectRewardsWithoutUnlock on the locker
2. LP fees are collected from all Uniswap V4 positions
3. Fees are split per recipient based on their rewardBps
4. Fee conversions are performed (token ↔ WETH swaps as needed)
5. Fees are deposited into ClawnchFeeLocker
6. Recipients claim from ClawnchFeeLocker at their convenience

MEV Protection

Clawncher uses a descending fee curve to protect against MEV attacks at token launch.

Default Configuration:

• Starting fee: 80% (800,000 pips)
• Ending fee: 5% (50,000 pips)
• Decay period: 30 seconds

How it works:

1. At t=0 (token deployment), the swap fee is 80%
2. The fee decays linearly: at t=15s it's ~42.5%
3. At t=30s, the fee reaches 5% and the MEV module disables itself
4. After that, only the normal LP Rewards (1%) applies

Safety features:

• SameSecondAsDeployment error prevents swaps in the same second as pool creation
• Maximum MEV module delay: 120 seconds (enforced by hook)
• delayGuard of 1 second prevents boundary condition issues in fee calculation

Security

Audit Fixes (v2)

The v2 deployment includes fixes for all issues identified in the security audit:

Transient Storage

The protocol fee fix uses EVM Cancun transient storage (tstore/tload) to isolate the protocol fee value per swap context. Transient storage is automatically cleared at the end of each transaction, and each write to PROTOCOL_FEE_SLOT correctly sets the fee for the subsequent _afterSwap read - even during reentrant fee collection swaps.

This requires the cancun EVM version, which Base supports since the Dencun upgrade.

v0.1.0 Migration Notes

Breaking Changes

• vestedDevBuy removed from DeployOptions: Use vault with a lockup for token lockup. claimVestedDevBuy() now throws ClawnchDeployError.
• vanity is now a boolean: Pass true/false instead of a config object. The SDK handles mining internally with the 0xccc prefix.
• deploy() command syntax changed: CLI now uses --name and --symbol flags instead of positional arguments.
• verifyToken() removed: Contract verification is handled automatically by Clanker infrastructure.
• Pool config options removed: startingTick, tickSpacing, lpFee, and mevConfig are no longer configurable — these are set by Clanker's approved infrastructure.
• airdrop optional in DeployOptions: Airdrop configuration uses AirdropConfig { percentage, admin, merkleRoot, lockupDuration, vestingDuration }.

New Features

• dryRun option: Validate deployment config without submitting a transaction. Returns DryRunResult with translatedConfig, valid, estimatedGas, and estimatedCostEth.
• ClawnchPortfolio: Discover and track all Clawncher tokens for a wallet.
• ClawnchWatcher: Real-time event streaming for new token deployments.
• claimBatch(): Claim fees across multiple tokens in one call.
• Structured errors: All SDK errors now use ClawnchDeployError with typed ClawnchErrorCode.

Upgrade Path

// v2
const result = await deployer.deploy({
  name: 'My Token',
  symbol: 'MYTKN',
  tokenAdmin: account.address,
  rewards: { recipients: [...] },
  vanity: { enabled: true, prefix: 'ccc', maxAttempts: 10_000_000 },
  startingTick: -196618,
  tickSpacing: 200,
  lpFee: 10000,
  mevConfig: { startingFee: 800000, endingFee: 50000, decaySeconds: 30 },
});

// v0.1.0
const result = await deployer.deploy({
  name: 'My Token',
  symbol: 'MYTKN',
  tokenAdmin: account.address,
  rewards: { recipients: [...] },
  vanity: true,
});