About
the engine
Waves is a launchpad on Solana. Every token locks its liquidity the moment it launches and chooses one engine for its fees: deepen the pool, buy back and burn, pay stakers, or pay every holder.
Every five minutes the engine runs a cycle. Fees are collected, converted and sent exactly where the creator chose, and each step is recorded on chain in the token's public log.
Read the docsPicked once at launch. Nobody can switch it afterwards, including us.
[one cycle, example numbers]
Every cycle the fees are paired and added to the locked pool. The pool gets deeper, each trade moves the price less, and nobody can pull it out.
Sped up so you can watch it. A real cycle runs every five minutes and lands on chain, and anyone can start one for a small bounty.
Cycle log · example, not live
[under the hood]
One cycle, on chain
The four engines are one Solana program. This is how the money moves through it, the exact transaction a cycle sends, and the interface the program is built to. It is not deployed yet, so its address is published here at launch.
[program flow, schematic]
Deepen the pool · next cycle 5:00
[one run_cycle transaction]
Compute units are estimates from the spec, not measured on chain.
// waves_engine · spec v0.1 · not deployed yet use anchor_lang::prelude::*; #[program] pub mod waves_engine { use super::*; /// Called once by the launcher, in the same transaction /// that creates the token. The engine is fixed here. pub fn create_engine(ctx: Context<CreateEngine>, kind: EngineKind) -> Result<()> { .. } /// Permissionless. Any wallet can call it once 300 s have /// passed, and it pays that wallet a fixed bounty. pub fn run_cycle(ctx: Context<RunCycle>) -> Result<()> { let cfg = &mut ctx.accounts.config; let now = Clock::get()?.unix_timestamp; require!(now - cfg.last_cycle >= 300, WavesError::TooEarly); cfg.last_cycle = now; match cfg.kind { .. } // route the fee vault to the engine } } /// PDA, seeds = ["engine", mint] #[account] pub struct EngineConfig { pub mint: Pubkey, pub kind: EngineKind, // no instruction writes this again pub last_cycle: i64, pub cycles: u64, pub routed: u64, // lamports sent through the engine pub bump: u8, } pub enum EngineKind { Deepen, Burn, Staking, Holders }
[what you can verify at launch]
- The engine is written once. No instruction can change it afterwards, including ours.In the IDL
- The fee vault has no withdraw instruction. SOL only leaves it through run_cycle.In the IDL
- run_cycle fails until 300 seconds have passed since the last cycle.Program logs
- The wallet that calls run_cycle gets a fixed bounty and nothing else.Every cycle tx
- Mint and freeze authority are off, and the liquidity locks at graduation.Solscan, token page
[the numbers]
Tokenomics
[the whole supply, one square is one percent]
[cycle counter]
A cycle every five minutes, 288 a day, whether anyone is watching or not. Anyone can start one and earn the bounty, so it keeps going without us.
[get $WAVE]
How to buy
Waves, ticker $WAVE: the official token of this launchpad, live on Solana. It starts on a bonding curve and its liquidity locks once the curve graduates. Buying takes a few minutes if you already have a wallet.
Install a Solana wallet
A wallet holds your SOL and your tokens. Any of these three works with Waves. Write the recovery phrase down on paper and keep it offline. Nobody from Waves will ever ask you for it.
[takes]
Put SOL in it
Buy SOL on an exchange and withdraw it to your wallet's Solana address. Pick the Solana network, not a wrapped version on another chain. Keep around 0.01 SOL spare for network fees.
[network fee]
Solana fees are a fraction of a cent per transaction. The spare SOL is there so a swap never fails on fees.
Open the token
Use the link on this page only. Before graduation $WAVE trades on its bonding curve, after that on the open market. Connect the wallet you just funded.
[your wallet]
Connecting only reads your address. It cannot move anything, and every trade is still confirmed in your wallet.
Swap SOL for $WAVE
Choose how much SOL to spend, set slippage a few percent on the curve, and confirm in your wallet. The tokens land in the same wallet, usually in a second or two.
[contract]
The contract is published here and on our X the moment it exists.
[what your trade feeds]
Move the slider. The engine is the one you picked above.
The shape of a bonding curve: every buy makes the next token cost a little more. Your trade sits where the dot is. This is the shape, not a price chart for $WAVE.
Based on a planned one percent fee per trade. The real number is published before launch, and the same fee applies to every token on Waves.
[before you buy]
The $WAVE contract is published on this page and on our X the moment it exists. Any other address is not ours, however convincing it looks.
Early trading moves fast, so a few percent of slippage is normal on the curve. If a swap fails, raise it a little rather than a lot.
$WAVE is a memecoin. Its fees run an engine, they are not a promised return. Only use money you can afford to lose.
[the engines]
engines
Deepen the pool5:00next cycle
[live from the public api]
Read the APIThe four numbers above come straight from /api/v1/stats on this page, and they sit at zero until the first token launches. The chain line is live from Solana mainnet through /api/v1/chain.
[the api]
Check it yourself
Every number on this page is read from these endpoints, and so is every token page. They are public, read only and need no key. Run them here and see what the page sees.
/api/v1
Pick an endpoint and press Run.
Cross origin reads are open, so anyone can build on this. The launcher and the engines write nothing here, this API only ever reads.