Developer Documentation

{
  "name": "My Token",
  "symbol": "MYT",
  "description": "Your token description",
  "image": "https://example.com/logo.png",
  "website": "https://mytoken.com",
  "twitter": "https://x.com/mytoken",
  "telegram": "https://t.me/mytoken"
}

// Random bytes32 (browser)
const salt = '0x' + Array.from(crypto.getRandomValues(new Uint8Array(32)))
  .map(b => b.toString(16).padStart(2, '0'))
  .join('');

// Random bytes32 (Node / ethers)
const salt = ethers.hexlify(ethers.randomBytes(32));

function deployCoin(
  string calldata name,
  string calldata symbol,
  string calldata metadataUri,
  bytes32 salt,
  uint256 configId
) external payable;

function collectFees(address tokenAddress)
  external
  returns (uint256 ethCollected);

import { ethers } from 'ethers';

const FACTORY_ADDRESS = '0x254Bf550657040f78608476cE9AaD820aB2266ad'; // Ethereum
const TOKEN_ADDRESS   = '0xYourKlikTokenAddress';

const FACTORY_ABI = [
  'function collectFees(address tokenAddress) returns (uint256 ethCollected)'
];

const provider = new ethers.JsonRpcProvider('https://rpc.mevblocker.io/fast');
const wallet   = new ethers.Wallet('0xyour_creator_private_key', provider);

const factory = new ethers.Contract(FACTORY_ADDRESS, FACTORY_ABI, wallet);

const tx = await factory.collectFees(TOKEN_ADDRESS);
console.log('Broadcasted:', tx.hash);
const receipt = await tx.wait();
console.log('Confirmed in block:', receipt.blockNumber);

from web3 import Web3

FACTORY_ADDRESS = '0x254Bf550657040f78608476cE9AaD820aB2266ad'
TOKEN_ADDRESS   = '0xYourKlikTokenAddress'

FACTORY_ABI = [
    {
        'type': 'function',
        'name': 'collectFees',
        'stateMutability': 'nonpayable',
        'inputs': [{'name': 'tokenAddress', 'type': 'address'}],
        'outputs': [{'name': 'ethCollected', 'type': 'uint256'}],
    }
]

w3 = Web3(Web3.HTTPProvider('https://rpc.mevblocker.io/fast'))
account = w3.eth.account.from_key('0xyour_creator_private_key')

factory = w3.eth.contract(
    address=Web3.to_checksum_address(FACTORY_ADDRESS),
    abi=FACTORY_ABI,
)

tx = factory.functions.collectFees(
    Web3.to_checksum_address(TOKEN_ADDRESS)
).build_transaction({
    'from': account.address,
    'nonce': w3.eth.get_transaction_count(account.address),
})

signed = account.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
print('Broadcasted:', tx_hash.hex())

receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print('Confirmed in block:', receipt.blockNumber)

const claimable = await provider.getBalance(TOKEN_ADDRESS);
console.log('Claimable creator ETH:', ethers.formatEther(claimable));

{
  "cid": "QmXyz...",
  "url": "QmXyz...",
  "imageCid": "QmAbc...",
  "salt": "0xdeadbeef...",
  "saltAddress": "0x69ab12...",
  "targetPrefix": "69",
  "hasTargetPrefix": true
}

{ "cid": "QmAbc...", "url": "QmAbc..." }

{
  "name": "My Token",
  "symbol": "MYT",
  "description": "Your token description",
  "image": "ipfs://QmAbc...",
  "website": "https://mytoken.com",
  "twitter": "https://x.com/mytoken",
  "telegram": "https://t.me/mytoken"
}

{ "cid": "QmXyz...", "url": "QmXyz..." }

{
  "factory": "0x254Bf550657040f78608476cE9AaD820aB2266ad",
  "target_prefix": "69",
  "total_attempts": 4821,
  "has_target_prefix": true,
  "results": [
    { "salt": "0xdeadbeef...", "address": "0x69ab12..." }
  ]
}

{
  "error": "Rate limit exceeded",
  "message": "Too many requests per second. Please slow down.",
  "resetIn": 1,
  "type": "second"
}

import { ethers } from 'ethers';

const FACTORY_ABI = [
  'function deployCoin(string name, string symbol, string metadataUri, bytes32 salt, uint256 configId) payable'
];

const RPC_URL = 'https://rpc.mevblocker.io/fast';
const PRIVATE_KEY = '0xyour_private_key_here';
const CHAIN_ID = '1';
const FACTORY_ADDRESS = '0x254Bf550657040f78608476cE9AaD820aB2266ad';

const TOKEN_NAME = 'My Token';
const TOKEN_SYMBOL = 'MYT';
const TOKEN_DESCRIPTION = 'Your token description';
const CONFIG_ID = 1n;
const CREATOR_BUY_ETH = '0';

async function main() {
  const provider = new ethers.JsonRpcProvider(RPC_URL);
  const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
  const creator = await wallet.getAddress();

  const metadataRes = await fetch('https://klik.finance/api/uploadMetadata', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      name: TOKEN_NAME,
      symbol: TOKEN_SYMBOL,
      description: TOKEN_DESCRIPTION,
      image: '',
      website: '',
      twitter: '',
      telegram: '',
    }),
  });
  if (!metadataRes.ok) throw new Error(await metadataRes.text());
  const { cid } = await metadataRes.json();

  const saltRes = await fetch('https://klik.finance/api/generate-salt', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      name: TOKEN_NAME,
      symbol: TOKEN_SYMBOL,
      creator,
      factory: FACTORY_ADDRESS,
      chainId: CHAIN_ID,
    }),
  });
  if (!saltRes.ok) throw new Error(await saltRes.text());
  const saltPayload = await saltRes.json();
  const salt = saltPayload.results[0].salt;

  const factory = new ethers.Contract(FACTORY_ADDRESS, FACTORY_ABI, wallet);
  const tx = await factory.deployCoin(
    TOKEN_NAME,
    TOKEN_SYMBOL,
    cid,
    salt,
    CONFIG_ID,
    { value: ethers.parseEther(CREATOR_BUY_ETH) }
  );

  console.log('Broadcasted tx:', tx.hash);
  const receipt = await tx.wait();
  console.log('Confirmed in block:', receipt.blockNumber);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

import requests
from web3 import Web3

FACTORY_ABI = [
    {
        "type": "function",
        "name": "deployCoin",
        "stateMutability": "payable",
        "inputs": [
            {"name": "name", "type": "string"},
            {"name": "symbol", "type": "string"},
            {"name": "metadataUri", "type": "string"},
            {"name": "salt", "type": "bytes32"},
            {"name": "configId", "type": "uint256"}
        ],
        "outputs": []
    }
]

RPC_URL = "https://rpc.mevblocker.io/fast"
PRIVATE_KEY = "0xyour_private_key_here"
CHAIN_ID = "1"
FACTORY_ADDRESS = "0x254Bf550657040f78608476cE9AaD820aB2266ad"

TOKEN_NAME = "My Token"
TOKEN_SYMBOL = "MYT"
TOKEN_DESCRIPTION = "Your token description"
CONFIG_ID = 1
CREATOR_BUY_ETH = "0"

w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = w3.eth.account.from_key(PRIVATE_KEY)
creator = account.address

metadata_res = requests.post(
    "https://klik.finance/api/uploadMetadata",
    json={
        "name": TOKEN_NAME,
        "symbol": TOKEN_SYMBOL,
        "description": TOKEN_DESCRIPTION,
        "image": "",
        "website": "",
        "twitter": "",
        "telegram": "",
    },
    timeout=60,
)
metadata_res.raise_for_status()
cid = metadata_res.json()["cid"]

salt_res = requests.post(
    "https://klik.finance/api/generate-salt",
    json={
        "name": TOKEN_NAME,
        "symbol": TOKEN_SYMBOL,
        "creator": creator,
        "factory": FACTORY_ADDRESS,
        "chainId": CHAIN_ID,
    },
    timeout=60,
)
salt_res.raise_for_status()
salt = salt_res.json()["results"][0]["salt"]

factory = w3.eth.contract(
    address=Web3.to_checksum_address(FACTORY_ADDRESS),
    abi=FACTORY_ABI,
)

deploy_call = factory.functions.deployCoin(
    TOKEN_NAME,
    TOKEN_SYMBOL,
    cid,
    bytes.fromhex(salt[2:]),
    CONFIG_ID,
)

value_wei = w3.to_wei(CREATOR_BUY_ETH, "ether")
tx = deploy_call.build_transaction(
    {
        "from": creator,
        "chainId": int(CHAIN_ID),
        "nonce": w3.eth.get_transaction_count(creator),
        "value": value_wei,
    }
)
tx["gas"] = deploy_call.estimate_gas({"from": creator, "value": value_wei})

latest_block = w3.eth.get_block("latest")
if latest_block.get("baseFeePerGas") is not None:
    tx["maxPriorityFeePerGas"] = w3.to_wei(1, "gwei")
    tx["maxFeePerGas"] = latest_block["baseFeePerGas"] * 2 + tx["maxPriorityFeePerGas"]
else:
    tx["gasPrice"] = w3.eth.gas_price

signed_tx = account.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
print("Broadcasted tx:", tx_hash.hex())

receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print("Confirmed in block:", receipt.blockNumber)