Build on 1000X

// npm i viem   ·   RPC_URL=… PRIVATE_KEY=0x… npx tsx launch.ts
import {
  concat, createPublicClient, createWalletClient, encodeAbiParameters, http, keccak256,
  parseAbi, parseEther, parseEventLogs, slice, toHex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { bsc } from "viem/chains";

const FACTORY = "0x027ad1Bc0C4fdA010566d4535A00eAFb19798f22";
const WBNB = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c";

const factoryAbi = parseAbi([
  "function launchFee() view returns (uint256)",
  "function tokenInitCodeHash() view returns (bytes32)",
  "function predictToken(address creator, bytes32 salt) view returns (address)",
  "struct LaunchParams { bytes32 salt; string name; string symbol; string metadataURI; address quote; uint8 mode; address feeRecipient; uint256 firstBuy; uint256 minMemeOut; address[] quoteRoute; }",
  "function launch(LaunchParams p) payable returns (address token)",
  "event TokenLaunched(address indexed token, address indexed creator, address indexed quote, address pool, uint8 mode, address feeRecipient, uint256 positionId, bytes32 salt, int24 initialTick)",
]);

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

// 1. Mine a salt: the token address must end in 1000. The salt is bound to the creator (msg.sender).
function mineSalt(creator: `0x${string}`, initCodeHash: `0x${string}`) {
  let n = BigInt(keccak256(toHex(`${creator}${Date.now()}`))) >> 32n; // random start
  for (;;) {
    const salt = toHex(n++, { size: 32 });
    const inner = keccak256(encodeAbiParameters([{ type: "address" }, { type: "bytes32" }], [creator, salt]));
    const token = slice(keccak256(concat(["0xff", FACTORY, inner, initCodeHash])), 12);
    if (token.endsWith("1000")) return { salt, token };
  }
}

const [launchFee, initCodeHash] = await Promise.all([
  pub.readContract({ address: FACTORY, abi: factoryAbi, functionName: "launchFee" }),
  pub.readContract({ address: FACTORY, abi: factoryAbi, functionName: "tokenInitCodeHash" }),
]);
const { salt, token } = mineSalt(account.address, initCodeHash);
const predicted = await pub.readContract({
  address: FACTORY, abi: factoryAbi, functionName: "predictToken", args: [account.address, salt],
});
if (predicted.toLowerCase() !== token) throw new Error("salt check failed");

// 2. Launch: BNB pair, Dev mode, 0.01 BNB first buy in the same transaction.
const firstBuy = parseEther("0.01");
const { request } = await pub.simulateContract({
  account, address: FACTORY, abi: factoryAbi, functionName: "launch",
  value: launchFee + firstBuy, // BNB pair: launch fee + first buy
  args: [{
    salt, name: "My Coin", symbol: "MYCOIN", metadataURI: "",
    quote: WBNB, mode: 0, feeRecipient: account.address,
    firstBuy, minMemeOut: 0n, quoteRoute: [],
  }],
});
const hash = await wallet.writeContract({ ...request, gas: 8_000_000n }); // estimates can fall short
const receipt = await pub.waitForTransactionReceipt({ hash });

// 3. Read the new token and its pool from the event.
const [ev] = parseEventLogs({ abi: factoryAbi, eventName: "TokenLaunched", logs: receipt.logs });
console.log("token", ev.args.token, "pool", ev.args.pool, "tx", hash);

// Pair with a BEP-20 instead of BNB (here USDT). Reuses pub / wallet / factoryAbi / mineSalt from the BNB sample.
const QUOTE = "0x55d398326f99059fF775485246999027B3197955";

// 1. Ask the API for a route the factory will accept (read-only; the factory re-checks it on-chain).
const report = await fetch("https://1000x.family/api/preflight/quote", {
  method: "POST", headers: { "content-type": "application/json" },
  body: JSON.stringify({ quote: QUOTE, creator: account.address }),
}).then((r) => r.json());
if (!report.ok) throw new Error(report.reasons.join("; "));
const quoteRoute = report.route.via; // [] for a direct quote/WBNB pool, else 1–2 tokens

// 2. Approve the probe (a tiny round-trip transfer that proves "no tax") + the first buy.
const erc20 = parseAbi(["function approve(address,uint256) returns (bool)"]);
const probe = await pub.readContract({
  address: FACTORY, abi: parseAbi(["function quoteProbeAmount(address) view returns (uint256)"]),
  functionName: "quoteProbeAmount", args: [QUOTE],
});
const firstBuy = 5n * 10n ** BigInt(report.decimals); // 5 USDT, ≥ report.min_first_buy
await pub.waitForTransactionReceipt({
  hash: await wallet.writeContract({ address: QUOTE, abi: erc20, functionName: "approve", args: [FACTORY, probe + firstBuy] }),
});

// 3. Launch: msg.value is only the launch fee; the first buy is pulled in the quote.
const hash = await wallet.writeContract({
  address: FACTORY, abi: factoryAbi, functionName: "launch", value: launchFee, gas: 8_000_000n,
  args: [{ salt, name: "My Coin", symbol: "MYCOIN", metadataURI: "", quote: QUOTE, mode: 1 /* Burn */,
           feeRecipient: account.address, firstBuy, minMemeOut: 0n, quoteRoute }],
});

# Optional artwork → CID
curl -F [email protected] https://1000x.family/api/uploads/image
# → {"cid":"Qm…","uri":"ipfs://Qm…","gatewayUrl":"…","size":48211}

# Metadata JSON → the URI you pass as metadataURI
curl -X POST https://1000x.family/api/uploads/metadata -H 'content-type: application/json' \
  -d '{"name":"My Coin","symbol":"MYCOIN","imageCid":"Qm…","description":"gm","twitter":"https://x.com/mycoin"}'
# → {"cid":"Qm…","uri":"ipfs://Qm…","metadata":{"name":"My Coin","symbol":"MYCOIN","description":"gm","image":"ipfs://Qm…","socials":{"twitter":"https://x.com/mycoin"}}}

import { createPublicClient, http, parseAbiItem } from "viem";
import { bsc } from "viem/chains";

const pub = createPublicClient({ chain: bsc, transport: http(process.env.RPC_URL) });
const launched = parseAbiItem(
  "event TokenLaunched(address indexed token, address indexed creator, address indexed quote, address pool, uint8 mode, address feeRecipient, uint256 positionId, bytes32 salt, int24 initialTick)",
);

pub.watchEvent({
  address: "0x027ad1Bc0C4fdA010566d4535A00eAFb19798f22",
  event: launched,
  onLogs: (logs) => {
    for (const { args, transactionHash } of logs) {
      // args.pool is a PancakeSwap V3 pool, fee 10000 (1%), token/quote. Trade it with any V3 router.
      console.log(args.token, args.quote, args.pool, ["dev", "burn", "holders"][args.mode!], transactionHash);
    }
  },
});

# Collect a token's LP fees and pay everyone (permissionless; recipients are fixed on-chain).
cast send 0x79a7CAc0e1ed7CcF18b39B4C0954BCb1c2c63d99 "collect(address)" 0xToken --rpc-url $RPC_URL --account my-keystore

# Burn / Holders tokens: the Distributor exists after the token's first collect (0x0 before).
D=$(cast call 0xcf7E9883A57eBd26af57ddA051B4165D777facf0 "distributorOf(address)(address)" 0xToken --rpc-url $RPC_URL)
# Buyback-and-burn (Burn) or start an epoch (Holders). Reverts KickCooldown / BelowMinKick when early.
[ "$D" != 0x0000000000000000000000000000000000000000 ] && \
  cast send $D "kick()" --rpc-url $RPC_URL --account my-keystore

curl 'https://1000x.family/api/tokens?sort=new&limit=20'
curl 'https://1000x.family/api/tokens/0xToken'
curl 'https://1000x.family/api/tokens/0xToken/trades?limit=100'
curl 'https://1000x.family/api/tokens/0xToken/ohlcv?interval=1m&since=1790000000'