On-chain contract.

Anchor Program — `lib.rs`

The Order's smart contract

Below is the canonical Anchor program governing the Order. It uses Metaplex Token Metadata to mint each medal as an SPL NFT, enforces a hard supply cap, designates the Order as sole mint authority, and encodes a 5% royalty (seller_fee_basis_points). Deploy with anchor build & anchor deploy.

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Mint, MintTo, Token, TokenAccount};
use anchor_spl::associated_token::AssociatedToken;
use mpl_token_metadata::instruction::create_metadata_accounts_v3;

declare_id!("OrderoftheSun11111111111111111111111111111");

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

    pub fn initialize_collection(
        ctx: Context<InitializeCollection>,
        max_supply: u64,
        mint_price_lamports: u64,
        royalty_bps: u16,
    ) -> Result<()> {
        let c = &mut ctx.accounts.collection;
        c.authority = ctx.accounts.authority.key();
        c.max_supply = max_supply;
        c.minted = 0;
        c.mint_price = mint_price_lamports;
        c.royalty_bps = royalty_bps;
        c.bump = *ctx.bumps.get("collection").unwrap();
        Ok(())
    }

    pub fn mint_medal(ctx: Context<MintMedal>, name: String, uri: String) -> Result<()> {
        let c = &mut ctx.accounts.collection;
        require!(c.minted < c.max_supply, OrderError::SupplyExhausted);

        // Tribute: transfer SOL to Order treasury
        let ix = anchor_lang::solana_program::system_instruction::transfer(
            &ctx.accounts.payer.key(),
            &c.authority,
            c.mint_price,
        );
        anchor_lang::solana_program::program::invoke(
            &ix,
            &[
                ctx.accounts.payer.to_account_info(),
                ctx.accounts.treasury.to_account_info(),
            ],
        )?;

        // Mint 1 token to buyer
        token::mint_to(
            CpiContext::new(
                ctx.accounts.token_program.to_account_info(),
                MintTo {
                    mint: ctx.accounts.mint.to_account_info(),
                    to: ctx.accounts.buyer_ata.to_account_info(),
                    authority: ctx.accounts.authority.to_account_info(),
                },
            ),
            1,
        )?;

        // Create Metaplex metadata (5% royalty, Order authority)
        let metadata_ix = create_metadata_accounts_v3(
            mpl_token_metadata::ID,
            ctx.accounts.metadata.key(),
            ctx.accounts.mint.key(),
            ctx.accounts.authority.key(),
            ctx.accounts.payer.key(),
            ctx.accounts.authority.key(),
            name,
            "ORDER".to_string(),
            uri,
            None,
            c.royalty_bps,
            true,
            true,
            None,
            None,
            None,
        );
        anchor_lang::solana_program::program::invoke(
            &metadata_ix,
            &[
                ctx.accounts.metadata.to_account_info(),
                ctx.accounts.mint.to_account_info(),
                ctx.accounts.authority.to_account_info(),
                ctx.accounts.payer.to_account_info(),
                ctx.accounts.system_program.to_account_info(),
                ctx.accounts.rent.to_account_info(),
            ],
        )?;

        c.minted = c.minted.checked_add(1).unwrap();
        emit!(MedalMinted {
            number: c.minted,
            owner: ctx.accounts.payer.key(),
        });
        Ok(())
    }
}

#[account]
pub struct Collection {
    pub authority: Pubkey,
    pub max_supply: u64,
    pub minted: u64,
    pub mint_price: u64,
    pub royalty_bps: u16,
    pub bump: u8,
}

#[derive(Accounts)]
pub struct InitializeCollection<'info> {
    #[account(init, payer = authority, space = 8 + 32 + 8 + 8 + 8 + 2 + 1, seeds = [b"order"], bump)]
    pub collection: Account<'info, Collection>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct MintMedal<'info> {
    #[account(mut, seeds = [b"order"], bump = collection.bump)]
    pub collection: Account<'info, Collection>,
    #[account(mut)]
    pub mint: Account<'info, Mint>,
    #[account(mut)]
    pub buyer_ata: Account<'info, TokenAccount>,
    /// CHECK: PDA metadata account
    #[account(mut)]
    pub metadata: AccountInfo<'info>,
    /// CHECK: Order treasury
    #[account(mut, address = collection.authority)]
    pub treasury: AccountInfo<'info>,
    pub authority: Signer<'info>,
    #[account(mut)]
    pub payer: Signer<'info>,
    pub token_program: Program<'info, Token>,
    pub associated_token_program: Program<'info, AssociatedToken>,
    pub system_program: Program<'info, System>,
    pub rent: Sysvar<'info, Rent>,
}

#[event]
pub struct MedalMinted {
    pub number: u64,
    pub owner: Pubkey,
}

#[error_code]
pub enum OrderError {
    #[msg("All medals have been struck. Reserve exhausted.")]
    SupplyExhausted,
}

Full project files: /app/solana_contract/ — see README for deploy steps.