Launch a Token

import "dotenv/config";
import {
  getAddress,
  isAddress,
  parseEther,
  parseEventLogs,
  zeroAddress,
  type Address,
} from "viem";
import { publicClient, getWalletClient } from "./clients";
import { ROBINHOOD_LAUNCHPAD } from "./addresses";
import { bagsFactoryAbi, bagsBondingCurveAbi } from "./abi";

const TOTAL_BPS = 10_000;
const MAX_CLAIMERS = 100;

interface ClaimerAllocation {
  address: Address;
  bps: number;
}

/** Client-side mirror of the factory's claimer rules. Returns an error string, or null when valid. */
function validateClaimers(claimers: ClaimerAllocation[], partner?: Address): string | null {
  if (claimers.length === 0) return "Add at least one fee claimer.";
  if (claimers.length > MAX_CLAIMERS) return `At most ${MAX_CLAIMERS} claimers.`;

  // Only reject claimers matching a *real* partner — zeroAddress means "no partner".
  const partnerKey =
    partner && partner.toLowerCase() !== zeroAddress ? partner.toLowerCase() : null;

  const seen = new Set<string>();
  for (const c of claimers) {
    if (!isAddress(c.address)) return `"${c.address}" is not a valid address.`;
    const key = c.address.toLowerCase();
    if (key === zeroAddress) return "The zero address cannot be a claimer.";
    if (partnerKey && key === partnerKey) return "The partner cannot also be a claimer.";
    if (seen.has(key)) return "Claimer addresses must be unique.";
    seen.add(key);
    if (!Number.isInteger(c.bps) || c.bps < 1 || c.bps > TOTAL_BPS)
      return "Each claimer needs a whole bps share between 1 and 10000.";
  }
  const total = claimers.reduce((sum, c) => sum + c.bps, 0);
  if (total !== TOTAL_BPS)
    return `bps must sum to exactly 10000 (currently ${total}).`;
  return null;
}

async function launchToken(params: {
  name: string;
  symbol: string;
  metadataURI: string;
  claimers: ClaimerAllocation[];
  /** Optional partner, paid from the protocol half at the factory's snapshotted partnerFeeBps. */
  partner?: Address;
  /** ETH spent on an atomic initial buy. Use 0n for no buy. */
  initialBuyEth?: bigint;
}) {
  const { name, symbol, metadataURI, claimers } = params;
  const initialBuyWei = params.initialBuyEth ?? 0n;
  const partner = params.partner ?? zeroAddress;

  const claimersError = validateClaimers(claimers, partner);
  if (claimersError) throw new Error(claimersError);

  const walletClient = getWalletClient();
  const account = walletClient.account;

  // The creation fee is owner-settable — read it live right before signing.
  const creationFee = await publicClient.readContract({
    address: ROBINHOOD_LAUNCHPAD.factory,
    abi: bagsFactoryAbi,
    functionName: "creationFee",
  });

  // partner defaults to address(0) (no partner) unless one is passed in.
  const args = [
    name,
    symbol,
    metadataURI,
    partner,
    claimers.map((c) => getAddress(c.address)),
    claimers.map((c) => c.bps),
  ] as const;

  const value = creationFee + initialBuyWei;
  const functionName = initialBuyWei > 0n ? "createAndBuy" : "create";

  console.log(`Launching $${symbol} via ${functionName} (fee ${creationFee} wei)...`);

  // Simulate first so reverts surface as decoded custom errors before signing.
  const { request } = await publicClient.simulateContract({
    account,
    address: ROBINHOOD_LAUNCHPAD.factory,
    abi: bagsFactoryAbi,
    functionName,
    args,
    value,
  });

  const txHash = await walletClient.writeContract(request);
  const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
  if (receipt.status !== "success") {
    throw new Error("Launch transaction reverted on-chain. No token was created.");
  }

  // Clone addresses only exist in the TokenCreated event.
  const [created] = parseEventLogs({
    abi: bagsFactoryAbi,
    logs: receipt.logs,
    eventName: "TokenCreated",
  });
  if (!created) throw new Error("Launch confirmed but no TokenCreated event found.");

  // A large enough initial buy can graduate the token in the same tx.
  const migratedLogs = parseEventLogs({
    abi: bagsBondingCurveAbi,
    logs: receipt.logs,
    eventName: "Migrated",
  });

  const result = {
    txHash,
    token: created.args.token as Address,
    curve: created.args.curve as Address,
    feeShare: created.args.feeShare as Address,
    partner: created.args.partner as Address,
    poolId: created.args.poolId as `0x${string}`,
    migrated: migratedLogs.length > 0,
  };

  console.log("Token launched!");
  console.log("  token   :", result.token);
  console.log("  curve   :", result.curve);
  console.log("  feeShare:", result.feeShare);
  console.log("  partner :", result.partner);
  console.log("  poolId  :", result.poolId);
  console.log("  migrated:", result.migrated);
  console.log(`  explorer: https://robinhoodchain.blockscout.com/tx/${txHash}`);
  return result;
}

// Example: launch with all fees to the creator and a small initial buy.
launchToken({
  name: "My Token",
  symbol: "MTK",
  metadataURI: "https://ipfs.io/ipfs/YOUR_METADATA_CID",
  claimers: [
    { address: "0xYOUR_WALLET_ADDRESS", bps: 10000 }, // creator gets 100%
  ],
  initialBuyEth: parseEther("0.01"),
}).catch(console.error);