Documentation.

Launch Validation

Creating a new local market preview requires specific field formatting for the SOL-first launch direction. These checks do not submit a Solana transaction.

Commodity Modes

The launch interface allows pairing the community token with either a single commodity reference or a basket. The catalog contains various items across Metals, Energy, Agriculture, Livestock, Fast food, CS2, Game gold, Trading cards, Water, Cars, and Currencies. These commodity and SOL/USD values are informational references only; the launch quote asset is native SOL, represented as WSOL where an SPL token account is required.

Buy & Sell Steps

Interacting with a local market preview follows these strict deterministic operations. The target quote asset is native SOL/WSOL.

1. Select Operation: Choose to Buy (spending local SOL to receive tokens) or Sell (burning local tokens to receive SOL).
2. Input Amount: Enter the desired gross SOL or token amount. The preview applies the observed 0.25% Raydium protocol fee plus the proposed fixed 0.50% Elementa platform fee (0.75% total in the current model).
3. Curve Guardrails: The trade is calculated against the constant-product curve. If a buy crosses the curve's 800,000,000 token limit, it is capped at the exact remaining curve supply and the unused SOL stays in your browser-local wallet. Buys are rejected only when your browser-local SOL balance is insufficient. Graduation is not enabled in the preview.
4. Local Execution: Click to execute. The interface applies the math, updates your browser's local ledger, and adjusts the local quote reserve. No signature or onchain transaction takes place.

Local Wallet Integration

The connected wallet interface acts only as a display layer. Under the hood, a browser-local practice wallet initializes with exactly 100 SOL of illustrative local SOL.

• Storage Risk: Balances, tokens, and history exist strictly in your browser's localStorage. Clearing site data permanently deletes these local preview records.
• Initial Buy: Launching a market requires an initial SOL buy. The amount cannot exceed your current browser-local SOL balance; if it would cross the 800,000,000 token limit, the first buy is capped at the exact remaining curve supply and the unused SOL remains in your local wallet.
• No Transactions: Approving a launch or trade explicitly costs no blockchain transaction fees and requires no wallet signatures.

Supply Constants

• TOTAL_SUPPLY = 1,000,000,000
• CURVE_SUPPLY = 800,000,000
• RESERVED_SUPPLY = 200,000,000
• MAINNET_GLDX_NET_TARGET = 8 GLDx
• MAINNET_GLDX_OPENING_FDV = 2.5 GLDx
• MAINNET_GLDX_GRADUATION_FDV = 40 GLDx
• MAINNET_NATIVE_SOL_NET_TARGET = 30.361538483 SOL (30,361,538,483 lamports)
• MAINNET_NATIVE_SOL_GROSS_TARGET = 30.590970764 SOL (ceil at 75 bps)
• DEVNET_TEMPLATE = 16 SOL net target (deliberately unchanged)

Pricing Equations

Virtual Start and Initial Reserve

With zero migration fee, 1 billion supply and the 800M/200M allocation, valuations scale directly with the pool's quote-denominated net target. The native target is fixed from the finalized GLDx/WSOL baseline at slot 448085028 (3.795192310333775942 SOL per GLDx): ceil(8 × rate × 10⁹) = 30,361,538,483 lamports. Gross input is ceil(net × 10,000 / 9,925) = 30,590,970,764 lamports. These are curve parameters, not deposited funds or a liquidity guarantee.

const migrationSupply = totalSupply - curveSupply; // 200M
const openingFDV = netTarget * totalSupply * migrationSupply / curveSupply ** 2;
const graduationFDV = netTarget * totalSupply / migrationSupply;
const feeRate = 0.0075; // 0.25% Raydium + 0.50% Elementa
const grossRequired = netTarget / (1 - feeRate);

Buy Logic

Buys use a constant-product formula. Gross input in the pool's actual quote asset is reduced by the unchanged 0.75% fee to determine net curve input.

const netQuote = grossQuote * (1 - feeRate);
const tokenOut = tokenReserve - (tokenReserve * quoteReserve) / (quoteReserve + netQuote);

Sell Logic

Sells calculate the gross SOL output, then apply the modeled fee. Fees are not added back to reserves.

const grossQuoteSOL = quoteReserve - (tokenReserve * quoteReserve) / (tokenReserve + tokenAmount);
const feeSOL = grossQuoteSOL * feeRate;
const netQuoteSOL = grossQuoteSOL - feeSOL;

Worked Numerical Example

For the future 8 GLDx mainnet policy, the unchanged 80/20 construction gives a 2.5 GLDx opening FDV and 40 GLDx graduation FDV. Completing an 8 GLDx net target requires approximately 8.060453 GLDx of gross buys at a 0.75% fee.

Fees and Allocations

The current model uses a fixed 0.75% total fee: 0.25% is the observed Raydium protocol fee and 0.50% is the proposed fixed Elementa platform fee. This is not a holder-reward or treasury-allocation schedule.

• 0.25% observed Raydium protocol fee
• 0.50% proposed fixed Elementa platform fee

The public API provides system health, quote routing, and image storage services. No authentication keys are required. All responses use JSON unless otherwise specified.

GET /network/solana?cluster=mainnet-beta

Read-only Solana/Raydium readiness check. The server calls only the configured Solana JSON-RPC methods needed to verify genesis and the pinned LaunchLab/CPMM program accounts; it is not a general RPC proxy. The endpoint accepts devnet or mainnet-beta. HTTP 200 means network and program verification passed; it does not authorize mainnet activation. HTTP 503 means that read verification failed. Responses use no-store and private RPC URLs and upstream details are never returned. Mainnet activation fails closed until activationEligible is true.

const response = await fetch('/network/solana?cluster=mainnet-beta');
const body = await response.json();
const readiness = body.readiness;
// readiness.connected: boolean
 // readiness.networkReady: boolean
 // readiness.activationEligible: boolean
// readiness.activation: "eligible" | "not-eligible"
// readiness.blockers: string[]
// readiness.quoteAsset: { native: "SOL", wrapped: "WSOL", ... }
 // HTTP success proves network reads only; activation requires the explicit gate
 if (!response.ok || !readiness.activationEligible) throw new Error(readiness.blockers[0]);

Returns the current health status of the API server.

curl https://api.example.com/api/healthz

{
  "status": "ok"
}

Fetches combined commodity reference quotes from external free-tier public providers. These feeds, including priceUSD, are informational references only and do not replace native SOL/WSOL as the launch quote asset or provide backing, collateral, or a price guarantee. Upstream providers are not guaranteed and some catalogue symbols may return an "unavailable" status. Results are cached in-process for 30 seconds (even failures are cached to prevent flooding). HTTP responses use Cache-Control: no-store. Provider failures are represented in a 200 response with an unavailable quote status. Use /market-data/quotes on this app’s origin, not /api/market-data/quotes; health and storage use the /api prefix.

Quote Field Reference (CommodityQuote)

curl https://app.example.com/market-data/quotes

{
  "quotes": {
    "GLD": {
      "symbol": "GLD",
      "priceUSD": 2345.60,
      "changePercent": null,
      "changePeriod": null,
      "status": "current",
      "source": "Gold API",
      "sourceUrl": "https://gold-api.com/",
      "updatedAt": "2024-05-20T12:00:00Z",
      "message": "Latest indicative provider quote. Precious metals: USD per troy oz..."
    },
    "EUR": {
      "symbol": "EUR",
      "priceUSD": 1.085,
      "changePercent": -0.12,
      "changePeriod": "previous business day",
      "status": "daily",
      "source": "Frankfurter / ECB",
      "sourceUrl": "https://frankfurter.dev/",
      "updatedAt": "2024-05-19",
      "message": "Daily reference rate dated 2024-05-19, not a real-time FX quote."
    },
    "CORN": {
      "symbol": "CORN",
      "priceUSD": null,
      "changePercent": null,
      "changePeriod": null,
      "status": "unavailable",
      "source": null,
      "sourceUrl": null,
      "updatedAt": null,
      "message": "Feed not connected"
    }
  },
  "fetchedAt": "2024-05-20T12:00:05.000Z",
  "refreshAfterMs": 30000
}

Uploads a raw binary image for a token market. Required to be a direct file upload (no multipart wrapper). It employs a shared rate limit budget of 60 uploads per 15 minutes, shared by all callers only per process (does not use IP headers). Maximum size is 4 MiB.

// Example browser same-origin fetch
const fileInput = document.querySelector('input[type="file"]');
const file = fileInput.files[0];

const response = await fetch('/api/storage/token-images', {
  method: 'POST',
  headers: {
    'Content-Type': file.type // 'image/png', 'image/jpeg', or 'image/webp'
  },
  body: file // Raw bytes sent directly
});

const data = await response.json();
console.log(data.imageURL); // "/api/storage/token-images/<uuid>"

{
  "imageURL": "/api/storage/token-images/123e4567-e89b-12d3-a456-426614174000"
}

Retrieves previously uploaded raw image bytes by their UUID. The server streams the image directly, applies the correct Content-Type (PNG/JPEG/WebP) based on object metadata, and attaches a rigid X-Content-Type-Options: nosniff security header.

Caching: Image responses use public, max-age=31536000 (1 year). No authentication is required to view images.

curl -O -J https://api.example.com/api/storage/token-images/123e4567-e89b-12d3-a456-426614174000

Persistence & Privacy

The current environment emphasizes local data testing and strict network separation.

• Local Storage Isolation: All wallets, trades, generated market configurations, and portfolio states are stored entirely in the client's browser localStorage mechanism (e.g., cmc_curve_markets, cmc_curve_wallet). There is no server/database persistence. Clearing browsing data results in immediate, irreversible loss of all local preview progress.
• Image Upload Privacy: Image uploads via the API are immediately public through a public access policy. UUID paths are identifiers, not a privacy boundary; viewing requires no signed URL or login. Do not upload sensitive or identifying images.
• Data Rollbacks: To prevent corrupted state during a failure to write to the browser's localStorage quota limits, launch workflows perform manual rollback snapshots.

FAQ & Troubleshooting