e/curve, documentation

The state account laid out byte by byte.

The full program follows. It is the same code that is deployed.

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Burn, Mint, Token, TokenAccount};

declare_id!("REPLACE_WITH_DEPLOYED_PROGRAM_ID");

pub const PUMP_PROGRAM: Pubkey = pubkey!("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
pub const PUMPSWAP_PROGRAM: Pubkey = pubkey!("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
pub const RESERVE_FLOOR_LAMPORTS: u64 = 50_000_000;

#[program]
pub mod ecurve {
    use super::*;

    pub fn initialize(ctx: Context<Initialize>, anchor_cap_micro: u64) -> Result<()> {
        let s = &mut ctx.accounts.state;
        s.mint = ctx.accounts.mint.key();
        s.vault = ctx.accounts.vault.key();
        s.anchor_cap_micro = anchor_cap_micro;
        s.burned_raw = 0;
        s.steps_fired = 0;
        s.spent_lamports = 0;
        s.bump = ctx.bumps.state;
        Ok(())
    }

    pub fn step(ctx: Context<Step>, max_lamports: u64, min_tokens_raw: u64, evaluation_id: u64) -> Result<()> {
        let vault_balance = ctx.accounts.vault.lamports();
        require!(vault_balance > RESERVE_FLOOR_LAMPORTS, EcurveError::BelowFloor);
        let spend = max_lamports.min(vault_balance - RESERVE_FLOOR_LAMPORTS);
        require!(spend > 0, EcurveError::NothingToSpend);

        let venue = ctx.accounts.venue_program.key();
        require!(venue == PUMP_PROGRAM || venue == PUMPSWAP_PROGRAM, EcurveError::WrongVenue);

        let before = ctx.accounts.program_token.amount;
        let mint_key = ctx.accounts.mint.key();
        let seeds: &[&[u8]] = &[b"vault", mint_key.as_ref(), &[ctx.accounts.state.vault_bump]];
        crate::venue::buy_with_vault(&ctx, spend, min_tokens_raw, &[seeds])?;
        ctx.accounts.program_token.reload()?;
        let received = ctx.accounts.program_token.amount.checked_sub(before).unwrap();
        require!(received >= min_tokens_raw, EcurveError::TooFewTokens);

        token::burn(
            CpiContext::new_with_signer(
                ctx.accounts.token_program.to_account_info(),
                Burn {
                    mint: ctx.accounts.mint.to_account_info(),
                    from: ctx.accounts.program_token.to_account_info(),
                    authority: ctx.accounts.state.to_account_info(),
                },
                &[&[b"state", mint_key.as_ref(), &[ctx.accounts.state.bump]]],
            ),
            received,
        )?;

        let s = &mut ctx.accounts.state;
        s.burned_raw = s.burned_raw.checked_add(received).unwrap();
        s.steps_fired = s.steps_fired.checked_add(1).unwrap();
        s.spent_lamports = s.spent_lamports.checked_add(spend).unwrap();

        let r = &mut ctx.accounts.step_record;
        r.evaluation_id = evaluation_id;
        r.step_index = s.steps_fired;
        r.spend_lamports = spend;
        r.burned_raw = received;
        Ok(())
    }

    pub fn record_fee(ctx: Context<RecordFee>) -> Result<()> {
        msg!("vault {}", ctx.accounts.vault.lamports());
        Ok(())
    }
}

#[account]
pub struct State {
    pub mint: Pubkey,
    pub vault: Pubkey,
    pub anchor_cap_micro: u64,
    pub burned_raw: u64,
    pub steps_fired: u64,
    pub spent_lamports: u64,
    pub bump: u8,
    pub vault_bump: u8,
}

#[account]
pub struct StepRecord {
    pub evaluation_id: u64,
    pub step_index: u64,
    pub spend_lamports: u64,
    pub burned_raw: u64,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = authority, space = 8 + 32 + 32 + 8 + 8 + 8 + 8 + 1 + 1, seeds = [b"state", mint.key().as_ref()], bump)]
    pub state: Account<'info, State>,
    /// CHECK: system owned PDA that only receives lamports
    #[account(seeds = [b"vault", mint.key().as_ref()], bump)]
    pub vault: UncheckedAccount<'info>,
    pub mint: Account<'info, Mint>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
#[instruction(max_lamports: u64, min_tokens_raw: u64, evaluation_id: u64)]
pub struct Step<'info> {
    #[account(mut, seeds = [b"state", mint.key().as_ref()], bump = state.bump)]
    pub state: Account<'info, State>,
    /// CHECK: the reserve
    #[account(mut, seeds = [b"vault", mint.key().as_ref()], bump = state.vault_bump)]
    pub vault: UncheckedAccount<'info>,
    #[account(mut)]
    pub mint: Account<'info, Mint>,
    #[account(mut, associated_token::mint = mint, associated_token::authority = state)]
    pub program_token: Account<'info, TokenAccount>,
    #[account(init, payer = keeper, space = 8 + 8 + 8 + 8 + 8, seeds = [b"step", mint.key().as_ref(), &evaluation_id.to_le_bytes()], bump)]
    pub step_record: Account<'info, StepRecord>,
    #[account(mut)]
    pub keeper: Signer<'info>,
    /// CHECK: checked against the two allowed venue ids in the handler
    pub venue_program: UncheckedAccount<'info>,
    pub token_program: Program<'info, Token>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct RecordFee<'info> {
    /// CHECK: read only
    pub vault: UncheckedAccount<'info>,
}

#[error_code]
pub enum EcurveError {
    #[msg("reserve is at or below the floor")]
    BelowFloor,
    #[msg("nothing to spend")]
    NothingToSpend,
    #[msg("venue program not allowed")]
    WrongVenue,
    #[msg("received fewer tokens than required")]
    TooFewTokens,
}

• The vault balance never goes below the floor as a result of a step.
• burned_raw never decreases.
• steps_fired equals the number of StepRecord accounts for the mint.
• spent_lamports equals the sum of spend_lamports across all StepRecord accounts.
• Every token the program receives in a step is burned in the same transaction.
• No instruction transfers SOL or tokens from the vault or the program's token account to any address.
• The anchor cap is written once and never rewritten.
• One evaluation id produces at most one step, enforced by the StepRecord seed.

The program must show its name on Solana explorers. These steps are part of the deployment and are not optional.

• The crate is named ecurve in Cargo.toml, the module is pub mod ecurve, and Anchor.toml declares ecurve under [programs.mainnet] with the deployed id.
• Build with anchor build using the verifiable flag (written as two hyphens then verifiable on the command line) so the binary is reproducible.
• After deploy, publish the IDL on chain with anchor idl init, passing the filepath flag pointing at target/idl/ecurve.json and the deployed program id. Explorers read the program name from the IDL.
• Include the solana-security-txt crate and add a security_txt block with name set to ecurve, project_url and policy set to the site url, contacts set to a link to the site docs page, and source_code set to the repo url. Explorers render the name field from it.
• Run solana-verify build, then solana-verify verify-from-repo with the remote flag set to the repo url and the program-id flag set to the deployed id, so the verified build registry lists the program under its name.
• Confirm on Solscan that the program page shows ecurve as its name and a verified badge before configuring the mint on the site.

Anything shown here can be checked without trusting this site. The state account can be read with any RPC. The vault balance is a system account balance. Each step's transaction is on Solscan with its burn instruction visible. The market cap is Birdeye's own figure.