Smart Contract Guide

// fractal_token/src/lib.rs
#![no_std]
use fractal_sdk::prelude::*;

#[fractal_contract]
pub struct FractalToken {
    name: String,
    symbol: String,
    total_supply: u64,
    balances: StorageMap<Address, u64>,
    allowances: StorageMap<(Address, Address), u64>,
}

#[fractal_methods]
impl FractalToken {
    /// Initialize the token with a name, symbol, and supply
    pub fn init(&mut self, name: String, symbol: String, initial_supply: u64) {
        self.name = name;
        self.symbol = symbol;
        self.total_supply = initial_supply;

        let caller = env::caller();
        self.balances.insert(caller, initial_supply);

        env::emit_event("Transfer", &(Address::zero(), caller, initial_supply));
    }

    /// Transfer tokens to another address
    pub fn transfer(&mut self, to: Address, amount: u64) -> bool {
        let from = env::caller();
        let from_balance = self.balances.get(&from).unwrap_or(0);

        require!(from_balance >= amount, "Insufficient balance");

        self.balances.insert(from, from_balance - amount);
        let to_balance = self.balances.get(&to).unwrap_or(0);
        self.balances.insert(to, to_balance + amount);

        env::emit_event("Transfer", &(from, to, amount));
        true
    }

    /// Get the balance of an address
    pub fn balance_of(&self, owner: Address) -> u64 {
        self.balances.get(&owner).unwrap_or(0)
    }

    /// Get the fractal score bonus for this block
    pub fn fractal_bonus(&self) -> u64 {
        let score = env::fractal_score(); // returns fixed-point
        // Golden ratio bonus: score approaching 1.618 gets max bonus
        let phi = 1_618_034; // phi * 1e6
        let diff = if score > phi { score - phi } else { phi - score };
        let max_bonus = 1000;
        if diff < 100_000 {
            max_bonus - (diff * max_bonus / 100_000)
        } else {
            0
        }
    }
}