prebuilt.mdx

Pre-built Modules

Evolve includes ready-to-use modules for common functionality.

Token Module

Full-featured fungible token with mint/burn/transfer:

use evolve_extensions::token::{Token, TokenConfig};

// Register in STF
let stf = StfBuilder::new()
    .register_account::<Token>()
    .build();

// Genesis configuration
let token_genesis = TokenConfig {
    name: "My Token".to_string(),
    symbol: "MTK".to_string(),
    decimals: 18,
    initial_supply: 1_000_000_000,
    admin: admin_account_id,
};

Token Features

Feature	Description
transfer	Move tokens between accounts
transfer_from	Move tokens with allowance
approve	Set spending allowance
mint	Create new tokens (admin only)
burn	Destroy tokens
balance_of	Query account balance
total_supply	Query total supply
allowance	Query spending allowance

Token Events

// Emitted on transfers
Event::Transfer { from, to, amount }

// Emitted on approvals
Event::Approval { owner, spender, amount }

// Emitted on mint
Event::Mint { to, amount }

// Emitted on burn
Event::Burn { from, amount }

Scheduler Module

Block-level scheduling for begin/end block hooks:

use evolve_extensions::scheduler::{Scheduler, ScheduledTask};

// Register in STF
let stf = StfBuilder::new()
    .register_account::<Scheduler>()
    .with_begin_blocker::<Scheduler>()
    .with_end_blocker::<Scheduler>()
    .build();

Scheduler Features

Feature	Description
schedule	Schedule a task for future block
cancel	Cancel a scheduled task
get_pending	Query pending tasks

Usage Example

// Schedule a task for block 1000
let task = ScheduledTask {
    target: my_account_id,
    message: my_message,
    run_at_block: 1000,
};

env.call(scheduler_id, &ScheduleMsg { task }, funds)?;

Gas Service

Gas configuration and metering:

use evolve_extensions::gas::{GasService, GasConfig};

// Configuration
let gas_config = GasConfig {
    storage_read_per_byte: 10,
    storage_write_per_byte: 100,
    storage_remove_per_byte: 50,
    compute_per_unit: 1,
};

Using Pre-built Modules

1. Add dependency:

[dependencies]
evolve_extensions = { path = "crates/app/sdk/extensions" }

2. Register in STF:

use evolve_extensions::token::Token;
use evolve_extensions::scheduler::Scheduler;

let stf = StfBuilder::new()
    .register_account::<Token>()
    .register_account::<Scheduler>()
    .with_begin_blocker::<Scheduler>()
    .build();

3. Configure in genesis:

let genesis = Genesis {
    accounts: vec![
        (TOKEN_ID, token_config),
        (SCHEDULER_ID, scheduler_config),
    ],
};

Extending Pre-built Modules

Wrap or compose with your own logic:

#[account_impl(WrappedToken)]
pub mod wrapped_token {
    fn transfer_with_fee(
        env: &impl Env,
        to: AccountId,
        amount: u128,
    ) -> SdkResult<()> {
        let fee = amount / 100; // 1% fee

        // Transfer to recipient
        env.call(
            TOKEN_ID,
            &TransferMsg { to, amount: amount - fee },
            vec![],
        )?;

        // Transfer fee to treasury
        env.call(
            TOKEN_ID,
            &TransferMsg { to: TREASURY_ID, amount: fee },
            vec![],
        )?;

        Ok(())
    }
}