1. Start: After listing on dex → 1 SOL distributed.
2. 100K Market Cap: Airdrop increases to 2 SOL.
3. 1M Market Cap: Airdrop rises to 10 SOL.
4. From 1M onward: Every time the Market Cap doubles, the Airdrop increases by 10 SOL.
5. Selection: 10 random holders from the TOP 100 are chosen every time the Market Cap doubles.
• 2M Market Cap → 20 SOL distributed
• 4M Market Cap → 30 SOL distributed
• 8M Market Cap → 40 SOL distributed
• …
• 1B Market Cap → 120 SOL distributed
• …
Over 780 SOL (>100K USD) will be distributed on the way to 1B Market Cap.
• Hold at least 100 $T100
• Be a follower on X and a Telegram Channel subscriber
• Be one of the first 100 to reply to the Airdrop post on X with a Solana wallet and Telegram username
• The winning wallets of each Airdrop will be published on the TOP 100 website
use anchor_lang::solana_program::system_instruction;
use anchor_lang::solana_program::program::invoke;
use std::cmp;
declare_id!("TOP100_INFINITE_AIRDROP");
#[program]
pub mod sol_airdrop {
use super::*;
pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
let state = &mut ctx.accounts.airdrop_state;
state.market_cap = 0;
state.airdrop_amount = 1;
Ok(())
}
pub fn update_market_cap(ctx: Context<UpdateMarketCap>, new_market_cap: u64) -> Result<()> {
let state = &mut ctx.accounts.airdrop_state;
if new_market_cap < 100_000 {
state.airdrop_amount = 1;
} else if new_market_cap < 1_000_000 {
state.airdrop_amount = 2;
} else {
let doubling_count = ((new_market_cap as f64) / 1_000_000.0).log2().floor() as u64;
state.airdrop_amount = 10 + (10 * cmp::max(0, doubling_count));
}
state.market_cap = new_market_cap;
msg!("Market Cap updated: {} → Airdrop: {} SOL", state.market_cap, state.airdrop_amount);
Ok(())
}
pub fn distribute_airdrop(ctx: Context<DistributeAirdrop>) -> Result<()> {
let state = &ctx.accounts.airdrop_state;
let system_program = &ctx.accounts.system_program;
let winners = &ctx.remaining_accounts;
require!(winners.len() >= 10, AirdropError::NotEnoughHolders);
for winner in winners.iter().take(10) {
invoke(
&system_instruction::transfer(
ctx.accounts.payer.key,
winner.key,
state.airdrop_amount * 1_000_000_000, // Convert SOL to lamports
),
&[ctx.accounts.payer.to_account_info(), winner.to_account_info(), system_program.to_account_info()],
)?;
}
msg!("🏆 Airdrop distributed to 10 holders!");
Ok(())
}
}
#[derive(Accounts)]
pub struct Initialize<'info> {
#[account(init, payer = payer, space = 8 + 16)]
pub airdrop_state: Account<'info, AirdropState>,
#[account(mut)]
pub payer: Signer<'info>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
pub struct UpdateMarketCap<'info> {
#[account(mut)]
pub airdrop_state: Account<'info, AirdropState>,
}
#[derive(Accounts)]
pub struct DistributeAirdrop<'info> {
#[account(mut)]
pub airdrop_state: Account<'info, AirdropState>,
#[account(mut)]
pub payer: Signer<'info>,
pub system_program: Program<'info, System>,
}
#[account]
pub struct AirdropState {
pub market_cap: u64,
pub airdrop_amount: u64,
}
#[error_code]
pub enum AirdropError {
#[msg("Not enough holders to perform the airdrop.")]
NotEnoughHolders,
}
