Build on Sterling

The coin object

Every list returns coins in this shape. New fields may be added; the ones here won't be renamed or removed in v1.

Launching from code

A launch is three calls. The pad builds the transactions, your wallet signs them, and the pad sends them. Sterling never holds keys or funds. These endpoints take POST with a JSON body, and are meant for servers and scripts, not other sites' browsers.

1. Check it. POST /api/check with name, symbol, description, optional x, telegram and website links, image as a data URL (PNG, JPEG, WebP or GIF, under 4 MB), and your launcher wallet. It answers original, vamp (with the original and the reason) or full, and an id. The links you give are shown on the coin's Sterling page; the website in the coin's own metadata is that page.
2. Build it. POST /api/build with verdict (that id), launcher and an optional firstBuySol. An original gets one transaction. A vamp gets two: the tribute buy, then its launch, which burns what the tribute bought.
3. Sign and send, in order. Sign each transaction with the launcher's wallet and POST /api/send it as base64, adding mint for the launch so the pad lists the coin when it lands.

import { VersionedTransaction } from '@solana/web3.js';

const pad = (path, body) => fetch('https://www.sterlingpad.fun' + path, {
  method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
}).then(async r => { const j = await r.json(); if (!r.ok) throw Object.assign(new Error(j.error), j); return j; });

const launcher = wallet.publicKey.toBase58();
const verdict = await pad('/api/check', { name, symbol, description, image, launcher });
if (verdict.kind === 'full') throw new Error('That family is full.');
// A vamp's launch also buys verdict.tribute_sol SOL of verdict.original and burns it.

const built = await pad('/api/build', { verdict: verdict.id, launcher, firstBuySol: 0.1 });
for (const t of built.txs) {
  const signed = await wallet.signTransaction(VersionedTransaction.deserialize(Buffer.from(t.tx, 'base64')));
  await pad('/api/send', { tx: Buffer.from(signed.serialize()).toString('base64'),
                           mint: t.kind === 'launch' ? built.mint : undefined });
}

The check that counts happens at build. Two people can check the same idea at the same moment and both be told it's an original. Build decides one launch at a time against every coin that has landed and every launch being signed right now. The first to build gets the idea for the two minutes it takes to sign. Anyone after that gets a 409: either recheck is true because a coin like it has landed, so check again and launch as its vamp, or someone else is signing it and you can try again shortly.

If launchesOpen is ever false, check and build return 403.

Checking it on-chain

You don't have to take the API's word for any of this.

• Every launch Sterling approves carries a memo, sterling:v1:original or sterling:v1:vamp, signed by the approver key from /rules. A pool on Sterling's config without it was launched around the pad. It paid no tribute and never joins a family.
• A vamp's launch transaction contains an SPL Token burn of the original's mint, for the tokens its tribute bought. The original's total supply drops by exactly that much.
• Every coin launches on Meteora's Dynamic Bonding Curve with Sterling's config. Both addresses are in /rules.

Errors and limits

Errors come back as { "error": "…" } with a status that says what kind: 400 for a bad request, 403 while launches are closed, 404 for something that isn't on Sterling, 409 when the pad changed under you, 429 for too many requests, and 503 when the vamp check is briefly down. The message is written to show a person as-is.