Cubicle is the everything protocol. It builds whatever is capturing volume, attention and revenue on Solana right now, ships it, and moves on to the next thing when the market does. Every product it runs turns its fees into yield for the people holding it, and sends a share to the desks, which are the one asset that captures all of it.

Every trade on chain pays a fee to somebody. On almost every venue that somebody is the team, and holders get a token and a roadmap. We route it the other way. Fees are claimed automatically and spent on assets that go straight to holders, usually within the hour they were earned.

The products that do that today.

The launcher. Coins launched here convert their creator fees into tokenised stock for their holders. We claim the fees about once a minute and spend 67.5% of every one buying the coin’s reward asset on the open market, then send it out pro rata. A coin can pay a single stock or rotate through a basket of them.

The desks.A desk is an NFT with a vault attached. A share of every product’s revenue, half of what $CUBE earns from its own trading, and most of what every new desk pays to mint go into a shared pot. When the pot fills it buys one stock and credits every live desk the same amount. You collect whenever you want, and the stock waits in your vault until you do.

Different products, same rule. Revenue arrives, and holders are what it gets spent on. Products come and go; the desks capture all of them.

Every fee this protocol claims passes through one of these, and all of them are public. Nothing below is a claim you have to take on trust — open any of them and the transactions are the record.

The addresses the program itself runs on — the config, the collection, the rotation — are at the bottom of this page, read live from the chain.

Desks and the launcher are what we run today. Neither of them is what Cubicle is.

Nothing on chain stays busy forever. Whatever has volume this month will have less in six, and a protocol built around one product has an expiry date whether it admits it or not. Plenty of them are, and they spend the whole decline saying volume is temporarily soft.

So we did not build it that way. Cubicle is the machine that turns revenue into holder rewards. A product is just whatever is feeding it at the time. When one slows down we build the next one and plug it into the same claim, the same split, and the same wallets. We do not sit and wait for the first one to come back.

The desks came first and still run, still buying stock every time the pot fills. The launcher came second and is where the volume is now. Whatever is third works the same way, because that part was built to outlast any single product.

That is why the revenue page is the one worth reading. It measures the machine, and the machine is what carries over.

$CUBE is our token. It is not a governance badge and it is not a fee discount. It does three things.

Revenue buys it and burns it. A fixed 10% of every creator fee we claim goes to a wallet that buys $CUBE on the open market and burns what it buys, every five minutes. The buy and the burn are two separate transactions on purpose, so you can see the purchase on chain instead of it cancelling out against the burn.

It is what a desk costs. Minting a desk burns $CUBE. No purchase, the tokens are just gone. That has destroyed far more supply than the buybacks have, and it cost us nothing, because the person minting paid for it.

Its own trading fees pay the desks. $CUBE is a coin that trades, so it earns creator fees like any other, and they are split 50% desk pot · 50% protocol. The pot’s half is spent on stock for desk holders. The other half is protocol revenue. It bought $CUBE back and burned it for a while, which was the same job twice: every launched coin already sends 10% of its fees to the buyback and nothing else.

All of it is on the revenue page, listed separately. Spending revenue and destroying supply are two different claims and they should not be added together.

A launch is an ordinary pump.fun coin. We do not run the market, hold the liquidity, or take custody of anything. The coin trades on pump.fun exactly like any other, and you are its creator there.

The one thing that differs is set at the moment of creation and can never be changed: the coin’s creator fees are assigned to our reward wallet instead of to you. That assignment is what funds everything below.

You stay the creator on pump.fun and the coin is credited to you normally. What you give up is the fee stream, and what your holders get for it is below.

Every trade on a launched coin pays a creator fee. A worker claims those fees roughly once a minute and splits them in the same transaction that claims them, so nothing sits unsplit.

Everything below the holders’ share comes out of the protocol’s side, never out of theirs. The buyback is funded by the protocol taking less.

A coin paired against a stock earns that stock rather than SOL, so its holders are paid in the asset the coin already trades against and nothing is swapped for them. The rest of the fee is swapped to SOL once and split four ways in a single transaction, because the desk pot holds lamports and the buyback exists to spend them.

The buyback is bought and burned in two separate transactions, so a burn that fails leaves the CUBE in the wallet to be burned next cycle rather than losing the purchase with it. Every buy and every burn is recorded as it happens.

The holders’ 67.5% accumulates as SOL against the coin. Once it reaches 0.1 SOL a round swaps the whole balance into the coin’s chosen stock and credits every holder their share.

The threshold exists because a swap costs a transaction fee and gives up slippage. Below a tenth of a SOL those costs are a real fraction of the trade, so a coin waits rather than paying them repeatedly on small amounts. A coin under the line is not being skipped. Its balance sits and grows until it crosses.

Shares are strictly proportional to how much of the coin you hold at the moment the round runs. There is no minimum and no rounding you out. A wallet holding a thousandth of a percent is credited a thousandth of a percent.

Credits are cumulative. Nothing expires, nothing is forfeited for not paying attention, and a wallet that never looks accrues exactly as much as one that checks daily.

Rewards arrive on their own, once. A round buys the coin’s reward stock and sends each holder their share in proportion to what they hold. There is nothing to claim and nothing to sign every round.

Solana charges a deposit for every token account, so a stock you have never held needs one opened before it can reach you. You open it from the coin page, once per stock, at about thirty-seven cents. The account is yours, the deposit stays in it, and closing it returns the deposit. A round divides among the holders who can receive it, so activating is worth doing before the next one.

One balance per stock, not per coin. Hold ten coins that all pay NKE and the NKE lands in one account.

Payouts are listed as they happen on the rewards page, one row per transaction, each linking to the transfer on chain.

A launch picks what its holders are paid in: a tokenised equity, a pre-IPO name, or a basket that rotates between several. There is also a curated list, and you can import any mint that passes an automated audit.

The audit refuses anything that cannot actually be paid out:

Rejections are recorded along with the measured figures, so a token that passes today and rots later leaves a trail rather than a stale verdict.

A desk is an NFT that owns a vault. The vault fills with tokenised stock over time, and whoever holds the NFT owns whatever is in it. It is the second product here. The launcher is the first.

Minting burns — CUBE and issues a Metaplex Core NFT with a vault address derived from it. The burn happens inside the mint instruction, before the NFT exists. Solana transactions are all-or-nothing, so there is no version of this where somebody gets a desk without the supply going down.

The vault is what makes it a desk rather than a picture: it holds real stock, it is owned by the NFT rather than by you, and it travels with the NFT when you sell.

A desk needs an open account for every stock in the rotation before it can be paid in them. Activating opens all of them in one press.

The rent for those accounts is yours and comes back if you ever close them.

When the pot crosses its threshold, a round converts the whole thing into one stock and credits every live desk equally. The rotation decides which:

Crediting is a single number. The program tracks how much of each stock has ever been paid per desk, and your desk tracks where it last collected. What you are owed is the difference. So a round writes one account no matter how many desks exist, and claiming yours does not move anybody else’s.

Selling the desk hands over everything: the NFT, its vault, the stock inside it, and anything credited but not yet collected. There is no exit instruction and no protocol marketplace. The vault is a PDA of the NFT, so ownership follows the NFT wherever it goes.

A royalty is set on the collection. It is a marketplace convention rather than something the chain enforces, so it is a behaviour, not a guarantee.

Two launchpads, and they need different amounts of help. A Meteora launch is built here, because its pool config is a fresh keypair this server holds. A pump launch is built entirely in your own code: the pump SDK does it, nothing is signed here, and the only call you make to this API is the one that lists the coin.

Pump

Nothing on this server decides whether a pump coin earns rewards. Its fee-sharing config does, on chain, and this protocol reads it rather than being told. A coin whose shares point at the reward wallet is paying holders whether or not anybody registered it.

Meteora

A Meteora launch here is three requests and two signatures. This site’s launcher makes exactly the same calls in the same order, so anything it can do, so can you. There is no key, no registration and no allow list.

What the API will not do is sign for you. It builds the two transactions and partially signs the parts only it holds — the pool config’s keypair, and the launchpad’s identity — and hands them back. The coin’s own key and the creator’s are yours to add, so a response leaving this server can do nothing on its own.

// 2. build
const res = await fetch("https://otcdesks.cash/api/meteora/launch", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    mint:      mintKeypair.publicKey.toBase58(),
    name:      "My Coin",
    symbol:    "MINE",
    uri:       metadataUri,
    creator:   wallet.publicKey.toBase58(),
    quoteMint: "XsbEhLAtcf6HdfpFZ5xEMdqW8nfAvcsP5bdudRLJzJp", // AAPLx
    mode:      "high",   // or "low"
    buy:       "0",      // optional opening buy, base units of the quote
  }),
});

const plan = await res.json();
// { transactions: [b64, b64], config, blockhash, lastValidBlockHeight, quoteUsd }

// 3. sign and send, in order
const txs = plan.transactions.map((t) =>
  Transaction.from(Buffer.from(t, "base64"))
);
txs[1].partialSign(mintKeypair);              // the coin's own key
const signed = await wallet.signAllTransactions(txs);

for (const tx of signed) {
  const sig = await connection.sendRawTransaction(tx.serialize());
  await confirm(sig, plan.lastValidBlockHeight); // wait before the next
}

Everything POST /api/meteora/launch takes. Strings unless said otherwise.

Recording it, if you want the coin on this site, is POST /api/coins. It needs mint, name, symbol, uri, creator and createTx — the signature of the transaction that created the pool — plus pairMint, pairSymbol, rewardMint, rewardSymbol (all four are the quote, on a Meteora launch), venue: "meteora" and meteoraConfig, the config address the build returned. Nothing is taken on trust: the route reads the transaction off the chain and checks it. A 409means the signature has not been indexed yet, so wait a second and send it again — every other status is final.

And what comes back from the build: transactions, two the order they must be sent; config, the pool config this launch created; blockhash and lastValidBlockHeight, which both transactions are already built against; and quoteUsd, the price the curve was sized from.

Every address this runs on, live from the chain.