Automate launches and trades

import { parseAbi } from "viem";

export const launchpadAbi = parseAbi([
  "struct Curve { uint128 virtualEth; uint128 virtualToken; uint128 realEth; uint128 tokensSold; bool graduated; bool migrated; address creator; }",

  // write
  "function createToken(string name, string symbol, string metadataURI) payable returns (address token)",
  "function buy(address token, uint256 minTokensOut) payable returns (uint256 tokensOut)",
  "function sell(address token, uint256 tokenAmount, uint256 minEthOut) returns (uint256 ethOut)",

  // read
  "function quoteBuy(address token, uint256 ethAmount) view returns (uint256 tokensOut)",
  "function quoteSell(address token, uint256 tokenAmount) view returns (uint256 ethOut)",
  "function getPrice(address token) view returns (uint256 weiPerToken)",
  "function getCurve(address token) view returns (Curve)",
  "function creationFee() view returns (uint96)",
  "function POOL_SENTINEL_WETH_AMOUNT() view returns (uint256)",
  "function tokenCount() view returns (uint256)",
  "function allTokens(uint256 index) view returns (address)",

  // events
  "event TokenCreated(address indexed token, address indexed creator, string name, string symbol, string metadataURI, uint256 virtualEth, uint256 virtualToken)",
  "event Trade(address indexed token, address indexed trader, bool isBuy, uint256 ethAmount, uint256 tokenAmount, uint256 protocolFee, uint256 creatorFee, uint256 virtualEth, uint256 virtualToken, uint256 tokensSold)",
  "event Graduated(address indexed token, uint256 ethLiquidity, uint256 tokenLiquidity)",
  "event Migrated(address indexed token, address indexed pool, uint256 ethAdded, uint256 tokensAdded, uint256 migrationFee)",
]);

import { createPublicClient, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { launchpadAbi } from "./abi";

const LAUNCHPAD = "0x5640c62Fe43a64f9Ae0811114874E95A819dB744";

export const chain = {
  id: 4663,
  name: "Robinhood Chain",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
} as const;

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

{
  "name": "My Token",
  "symbol": "MYT",
  "description": "One or two sentences on what the token is.",
  "image": "https://your-host.example/logo.png",
  "website": "https://mytoken.example",
  "twitter": "https://x.com/mytoken",
  "telegram": "https://t.me/mytoken"
}

import { readFile } from "node:fs/promises";

// Bring your own hosting. Anything that returns a public https:// or ipfs://
// URL works: an IPFS pinning service (Pinata, web3.storage), S3, or your own
// server. Two uploads: the image first, then the JSON that references it.
async function upload(data: Uint8Array | string, contentType: string): Promise<string> {
  // ... send to your host, return the resulting public URL
  throw new Error("implement with your storage provider");
}

// 1. Host the image, get its URL. png, jpg, gif, or webp.
const image = await upload(await readFile("./logo.png"), "image/png");

// 2. Build the metadata and host it. The returned URL is your metadataURI.
const metadata = {
  name: "My Token",     // keep in sync with the on-chain name below
  symbol: "MYT",        // keep in sync with the on-chain symbol below
  description: "One or two sentences on what the token is.",
  image,                // url from step 1
  website: "https://mytoken.example",
  twitter: "https://x.com/mytoken",
  telegram: "https://t.me/mytoken",
};
const metadataURI = await upload(JSON.stringify(metadata), "application/json");

// 3. Pass metadataURI to createToken (next example).

import { readFile } from "node:fs/promises";
import { privateKeyToAccount } from "viem/accounts";

const BASE = "https://alpha.based.one";
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);

// Sign the upload authorization once (no gas). The message must match exactly.
const issued = Date.now();
const message = [
  "Based Alpha — authorize launch asset upload",
  "",
  "This lets alpha.based.one store your token's image and metadata.",
  "It does not move funds or approve transactions.",
  `Address: ${account.address.toLowerCase()}`,
  `Issued: ${new Date(issued).toISOString()}`,
].join("\n");
const signature = await account.signMessage({ message });
const auth = {
  "x-upload-address": account.address,
  "x-upload-issued": String(issued),
  "x-upload-signature": signature,
};

// 1. Upload the image (png/jpg/gif/webp, <= 4MB) -> { url }
const imageForm = new FormData();
imageForm.set("file", new Blob([await readFile("./logo.png")], { type: "image/png" }));
imageForm.set("symbol", "MYT");
const { url: image } = await fetch(`${BASE}/api/launch-assets?asset=image`, {
  method: "POST", headers: auth, body: imageForm,
}).then((r) => r.json());

// 2. Upload the metadata JSON -> { metadataUri } for createToken.
const { metadataUri } = await fetch(`${BASE}/api/launch-assets?asset=metadata`, {
  method: "POST",
  headers: { "content-type": "application/json", ...auth },
  body: JSON.stringify({
    name: "My Token", symbol: "MYT", description: "One or two sentences.",
    image, website: "https://mytoken.example", twitter: "https://x.com/mytoken",
  }),
}).then((r) => r.json());

import { parseEther, parseEventLogs } from "viem";
import { launchpadAbi } from "./abi";
import { publicClient, wallet, chain } from "./client";

const LAUNCHPAD = "0x5640c62Fe43a64f9Ae0811114874E95A819dB744";

// 1. Host a metadata JSON anywhere reachable (IPFS or HTTPS). Shape:
//    { name, symbol, description, image, website, twitter, telegram }
const metadataURI = "https://your-host.example/my-token.json";

// 2. msg.value must cover creationFee + a 1 wei pool sentinel, plus any
//    optional dev buy (ETH spent buying your own token in the same tx).
const [creationFee, sentinel] = await Promise.all([
  publicClient.readContract({ address: LAUNCHPAD, abi: launchpadAbi, functionName: "creationFee" }),
  publicClient.readContract({ address: LAUNCHPAD, abi: launchpadAbi, functionName: "POOL_SENTINEL_WETH_AMOUNT" }),
]);
const devBuy = parseEther("0.01"); // 0n for no dev buy
const value = creationFee + sentinel + devBuy;

const hash = await wallet.writeContract({
  address: LAUNCHPAD,
  abi: launchpadAbi,
  functionName: "createToken",
  args: ["My Token", "MYT", metadataURI],
  value,
});
const receipt = await publicClient.waitForTransactionReceipt({ hash });

// 3. The new token address comes from the TokenCreated event.
const [created] = parseEventLogs({ abi: launchpadAbi, eventName: "TokenCreated", logs: receipt.logs });
const token = created.args.token;
console.log("launched", token);

import { parseEther } from "viem";
import { launchpadAbi } from "./abi";
import { publicClient, wallet } from "./client";

const LAUNCHPAD = "0x5640c62Fe43a64f9Ae0811114874E95A819dB744";
const token = "0xYourToken";

// Decide how much ETH to spend. The 1.25% trade fee comes out of this amount.
const spend = parseEther("0.05");

// Quote, then set a floor with your slippage tolerance.
const expected = await publicClient.readContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "quoteBuy", args: [token, spend],
});
const minTokensOut = (expected * 99n) / 100n; // 1% slippage

await wallet.writeContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "buy",
  args: [token, minTokensOut], value: spend,
});

import { parseAbi } from "viem";
import { launchpadAbi } from "./abi";
import { publicClient, wallet } from "./client";

const LAUNCHPAD = "0x5640c62Fe43a64f9Ae0811114874E95A819dB744";
const token = "0xYourToken";

// The token is a standard ERC20. Approve the launchpad to pull it, then sell.
const erc20 = parseAbi([
  "function approve(address spender, uint256 amount) returns (bool)",
  "function balanceOf(address owner) view returns (uint256)",
]);

const account = wallet.account.address;
const amount = await publicClient.readContract({
  address: token, abi: erc20, functionName: "balanceOf", args: [account],
});

await wallet.writeContract({ address: token, abi: erc20, functionName: "approve", args: [LAUNCHPAD, amount] });

const expectedEth = await publicClient.readContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "quoteSell", args: [token, amount],
});
const minEthOut = (expectedEth * 99n) / 100n; // 1% slippage

await wallet.writeContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "sell", args: [token, amount, minEthOut],
});

import { launchpadAbi } from "./abi";
import { publicClient } from "./client";

const LAUNCHPAD = "0x5640c62Fe43a64f9Ae0811114874E95A819dB744";
const token = "0xYourToken";

// Curve state. Once graduated is true, buy/sell on the curve revert and
// trading moves to the DEX pool (see below).
const c = await publicClient.readContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "getCurve", args: [token],
});
console.log({ graduated: c.graduated, migrated: c.migrated, tokensSold: c.tokensSold });

// Spot price in wei per whole token (1e18 base units).
const price = await publicClient.readContract({
  address: LAUNCHPAD, abi: launchpadAbi, functionName: "getPrice", args: [token],
});

// Stream trades in real time.
const unwatch = publicClient.watchContractEvent({
  address: LAUNCHPAD, abi: launchpadAbi, eventName: "Trade",
  onLogs: (logs) => logs.forEach((l) => console.log(l.args)),
});

LAUNCHPAD=0x5640c62Fe43a64f9Ae0811114874E95A819dB744
RPC=https://rpc.mainnet.chain.robinhood.com

# launch a token (creation fee is 0; 1 wei sentinel + a 0.01 ETH dev buy)
cast send $LAUNCHPAD "createToken(string,string,string)" \
  "My Token" "MYT" "https://your-host.example/my-token.json" \
  --value 10000000000000001 --private-key $PK --rpc-url $RPC

# quote and buy 0.05 ETH (set MIN_OUT to the quote minus your slippage)
cast call $LAUNCHPAD "quoteBuy(address,uint256)(uint256)" $TOKEN 50000000000000000 --rpc-url $RPC
cast send $LAUNCHPAD "buy(address,uint256)" $TOKEN $MIN_OUT \
  --value 0.05ether --private-key $PK --rpc-url $RPC

# sell: approve first, then sell (MIN_ETH = quoteSell minus slippage)
cast send $TOKEN "approve(address,uint256)" $LAUNCHPAD $AMOUNT --private-key $PK --rpc-url $RPC
cast send $LAUNCHPAD "sell(address,uint256,uint256)" $TOKEN $AMOUNT $MIN_ETH \
  --private-key $PK --rpc-url $RPC