Build on Lime

curl https://limefun.org/api/v1/tokens?sort=newest&limit=5
curl https://limefun.org/api/v1/launchlab/pricing
curl "https://limefun.org/api/v1/tokens/<mint>/quote?side=buy&amount=500000000"

// npm i @solana/web3.js bs58   (Node 20+)
import { Connection, Keypair, Transaction } from "@solana/web3.js";
import bs58 from "bs58";

export const API = "https://limefun.org/api/v1";
export const rpc = new Connection(process.env.RPC_URL, "confirmed");
export const wallet = Keypair.fromSecretKey(bs58.decode(process.env.WALLET_SECRET)); // stays on your machine

export async function api(path, body) {
  const r = await fetch(API + path, body && { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
  const j = await r.json();
  if (!r.ok) throw new Error(j.error);
  return j;
}

export async function signAndSend(prepared, signers = [wallet]) {
  const tx = Transaction.from(Buffer.from(prepared.transaction, "base64"));
  tx.sign(...signers);
  const sig = await rpc.sendRawTransaction(tx.serialize());
  await rpc.confirmTransaction({ signature: sig, blockhash: prepared.blockhash, lastValidBlockHeight: prepared.lastValidBlockHeight });
  return sig;
}

import { api, wallet, signAndSend } from "./lime.mjs";

const mint = "<coin mint>";
const me = wallet.publicKey.toBase58();

// price check: 0.5 SOL in
const q = await api(`/tokens/${mint}/quote?side=buy&amount=500000000`);
console.log("you get", q.amountOut, "fee", q.fee);

// buy 0.5 SOL, 1% slippage
const buy = await api("/trades/prepare", { wallet: me, mint, side: "buy", amount: "500000000", slippageBps: 100 });
console.log("buy", await signAndSend(buy));

// sell 1,000,000 coins (6 decimals)
const sell = await api("/trades/prepare", { wallet: me, mint, side: "sell", amount: "1000000000000", slippageBps: 100 });
console.log("sell", await signAndSend(sell));

import { PublicKey } from "@solana/web3.js";
import { api, rpc, wallet, signAndSend } from "./lime.mjs";

const me = wallet.publicKey.toBase58();
const buyFast = async (mint) =>
  signAndSend(await api("/trades/prepare", { wallet: me, mint, side: "buy", amount: "100000000", slippageBps: 500, prioritySol: 0.002 }));

// A. poll (3 s cache on our side)
const seen = new Set();
setInterval(async () => {
  for (const l of (await api("/launches/recent?limit=20")).launches) {
    if (seen.has(l.address)) continue;
    seen.add(l.address);
    console.log("new", l.symbol, l.address);
  }
}, 1000);

// B. watch the program on your own RPC — the pool exists the moment it lands
const pricing = await api("/launchlab/pricing");
const LIME = new Set(pricing.platforms.map((p) => p.address));
rpc.onLogs(new PublicKey(pricing.program), async ({ signature, logs }) => {
  if (!logs.some((l) => l.includes("Instruction: Initialize"))) return;
  const tx = await rpc.getTransaction(signature, { maxSupportedTransactionVersion: 255 });
  if (!tx || tx.meta?.err) return;
  const keys = tx.transaction.message.getAccountKeys({ accountKeysFromLookups: tx.meta?.loadedAddresses });
  // initialize / initialize_with_token_2022 accounts: 3 = PlatformConfig, 6 = coin mint
  const ix = tx.transaction.message.compiledInstructions.find((i) => keys.get(i.programIdIndex)?.toBase58() === pricing.program);
  if (!ix || !LIME.has(keys.get(ix.accountKeyIndexes[3]).toBase58())) return;
  console.log("sniped", await buyFast(keys.get(ix.accountKeyIndexes[6]).toBase58()));
}, "confirmed");

import { Keypair } from "@solana/web3.js";
import nacl from "tweetnacl";
import { api, wallet as creator, signAndSend } from "./lime.mjs";

const mint = Keypair.generate(); // yours; only its public key is sent
const sol = (await api("/launchlab/pricing")).quoteAssets.find((q) => q.symbol === "SOL");

const prep = await api("/launches/prepare", {
  creator: creator.publicKey.toBase58(),
  mint: mint.publicKey.toBase58(),
  name: "My Coin", symbol: "MINE",
  uri: "https://your.cdn/mine.json",   // { name, symbol, description, image, extensions: { website, twitter, telegram } }
  quoteMint: sol.mint,
  tierBps: 30000,                       // 3% trade fee
  allocation: "fair",                   // or { creator, holders, burn, liquidity } in bps = 10000
  firstBuy: "500000000",                // optional: 0.5 SOL bought by the creator in the same transaction
});
console.log("launched", prep.poolId, await signAndSend(prep, [creator, mint]));

// store the allocation: the creator signs one message
const signature = Buffer.from(nacl.sign.detached(new TextEncoder().encode(prep.record.message), creator.secretKey)).toString("base64");
await fetch("https://limefun.org" + prep.record.endpoint, {
  method: "POST", headers: { "content-type": "application/json" },
  body: JSON.stringify({ ...prep.record.body, issued: prep.record.issued, signature }),
});

// initialize_with_token_2022, no transfer fee — the instruction Lime itself sends
import { Keypair, PublicKey, SystemProgram, Transaction, TransactionInstruction } from "@solana/web3.js";
import { api, rpc, wallet as creator } from "./lime.mjs";

const pricing = await api("/launchlab/pricing");
const q = pricing.quoteAssets.find((x) => x.symbol === "SOL");
const tier = 30000;
const platform = new PublicKey(pricing.platforms.find((p) => p.tierBps === tier).address);
const config = new PublicKey(q.globalConfig);
const program = new PublicKey(pricing.program);
const mint = Keypair.generate();

const pda = (...seeds) => PublicKey.findProgramAddressSync(seeds, program)[0];
const pool = pda(Buffer.from("pool"), mint.publicKey.toBuffer(), new PublicKey(q.mint).toBuffer());
const vault = (m) => pda(Buffer.from("pool_vault"), pool.toBuffer(), m.toBuffer());
const u64 = (v) => { const b = Buffer.alloc(8); b.writeBigUInt64LE(BigInt(v)); return b; };
const str = (s) => { const b = Buffer.from(s); const n = Buffer.alloc(4); n.writeUInt32LE(b.length); return Buffer.concat([n, b]); };

const data = Buffer.concat([
  Buffer.from(pricing.instruction.discriminator),
  Buffer.from([pricing.curve.baseDecimals]), str("My Coin"), str("MINE"), str("https://your.cdn/mine.json"),
  Buffer.from([0]), u64(pricing.curve.supply), u64(pricing.curve.totalSellA), u64(q.raise.raw), Buffer.from([1]), // constant curve, CPMM
  u64(0), u64(0), u64(0), Buffer.from([0]),        // no vesting; creator fee in the quote token
  Buffer.from([0]), Buffer.alloc(10),               // transfer fee: None
]);
const ro = (pubkey) => ({ pubkey, isSigner: false, isWritable: false });
const rw = (pubkey) => ({ pubkey, isSigner: false, isWritable: true });
const keys = [
  { pubkey: creator.publicKey, isSigner: true, isWritable: true }, ro(creator.publicKey), ro(config), ro(platform),
  ro(new PublicKey(pricing.pdas.vaultAuthority)), rw(pool), { pubkey: mint.publicKey, isSigner: true, isWritable: true },
  ro(new PublicKey(q.mint)), rw(vault(mint.publicKey)), rw(vault(new PublicKey(q.mint))),
  ro(new PublicKey(pricing.baseTokenProgram)), ro(new PublicKey(q.tokenProgram)), ro(SystemProgram.programId),
  ro(new PublicKey(pricing.pdas.eventAuthority)), ro(program),
  ro(new PublicKey(q.curveRules[tier])),            // remaining account: the platform's curve rule
];
const tx = new Transaction().add(new TransactionInstruction({ programId: program, keys, data }));
console.log(await rpc.sendTransaction(tx, [creator, mint]));
// the pool is picked up by Lime within one indexer pass