Introduction

{
  "bondingAddress": "0x...",
  "tokenAddress": "0x...",
  "creatorAddress": "0x...",
  "name": "Agent Coin",
  "symbol": "AGENT",
  "description": "Launched by an autonomous agent.",
  "imageUrl": "https://..."
}

// ---------------------------------------------
// Agent Launch Example (Node.js + ethers)
// ---------------------------------------------
const { ethers } = require("ethers");
const fs = require("fs");
const path = require("path");

const API_URL = process.env.ARCHEMIST_API_URL || "https://api.archemist.fun";
const RPC_URL = "https://rpc.testnet.arc.network";
const FACTORY_ADDRESS = "0xFd52Cf5A6B4B167aBf83D6781B5B4dfccb52Fd4E";

const FACTORY_ABI = [
  "function createBonding(string name,string symbol,bytes32 salt) payable returns (address)",
  "event TokenCreated(address indexed bondingContract,address indexed tokenAddress,string name,string symbol,address creator)"
];

const MIME_BY_EXT = {
  ".jpg": "image/jpeg",
  ".jpeg": "image/jpeg",
  ".png": "image/png",
  ".gif": "image/gif",
  ".webp": "image/webp"
};

function imageMimeType(imagePath) {
  const ext = path.extname(imagePath).toLowerCase();
  const mime = MIME_BY_EXT[ext];
  if (!mime) throw new Error("Image must be JPEG, PNG, GIF, or WebP");
  return mime;
}

async function uploadImage(imagePath, ticker) {
  const file = new Blob([fs.readFileSync(imagePath)], {
    type: imageMimeType(imagePath)
  });
  const form = new FormData();
  form.append("image", file, path.basename(imagePath));
  form.append("ticker", ticker);

  const res = await fetch(`${API_URL}/api/tokens/upload-image`, {
    method: "POST",
    body: form
  });
  if (!res.ok) throw new Error(await res.text());
  return res.json(); // { url, cid, fileId }
}

async function mineSalt(name, symbol) {
  const res = await fetch(`${API_URL}/api/tokens/mine-salt?network=arc-testnet`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ name, symbol })
  });
  if (!res.ok) throw new Error(await res.text());
  return res.json(); // { success, salt, bondingAddress, tokenAddress, iterations, elapsedMs }
}

async function launchToken() {
  const token = {
    name: "Agent Coin",
    symbol: "AGENT",
    description: "Launched by an autonomous agent.",
    imagePath: "./agent.png",
    initialBuy: "0"
  };

  const provider = new ethers.JsonRpcProvider(RPC_URL);
  // Never expose PRIVATE_KEY in client-side code, logs, or public repositories.
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
  const factory = new ethers.Contract(FACTORY_ADDRESS, FACTORY_ABI, wallet);

  const image = await uploadImage(token.imagePath, token.symbol);
  const mined = await mineSalt(token.name, token.symbol);

  const tx = await factory.createBonding(token.name, token.symbol, mined.salt, {
    value: ethers.parseEther(token.initialBuy)
  });
  const receipt = await tx.wait();

  const event = receipt.logs
    .map((log) => {
      try { return factory.interface.parseLog(log); }
      catch { return null; }
    })
    .find((log) => log?.name === "TokenCreated");

  const bondingAddress = event?.args?.bondingContract || mined.bondingAddress;
  const tokenAddress = event?.args?.tokenAddress || mined.tokenAddress;

  if (!bondingAddress || !tokenAddress) {
    throw new Error("Missing bondingAddress/tokenAddress from receipt and salt miner response");
  }

  const metadataRes = await fetch(`${API_URL}/api/tokens`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      bondingAddress,
      tokenAddress,
      creatorAddress: wallet.address,
      name: token.name,
      symbol: token.symbol,
      description: token.description,
      imageUrl: image.url
    })
  });
  if (!metadataRes.ok) throw new Error(await metadataRes.text());

  return metadataRes.json();
}

launchToken().then(console.log).catch(console.error);