From JavaScript to Rust: Smart Contract Development

// Token rewards system - earn and spend tokens
class TokenRewards {
    constructor() {
        this.balances = new Map();          // user → balance
        this.userItems = new Map();         // user → items[]
        this.totalSupply = 10000;
        this.owner = "admin";
    }

    // Users earn tokens for completing tasks
    earnTokens(user, amount) {
        if (amount <= 0) throw new Error("Amount must be positive");
        if (amount > 100) throw new Error("Max 100 tokens per earn");
        if (amount > this.totalSupply) throw new Error("Not enough supply");

        const currentBalance = this.balances.get(user) || 0;
        this.balances.set(user, currentBalance + amount);
        this.totalSupply -= amount;

        console.log(`${user} earned ${amount} tokens`);
    }

    // Users spend tokens to buy items
    spendTokens(user, amount, item) {
        if (amount <= 0) throw new Error("Amount must be positive");
        if (!item) throw new Error("Item name required");

        const balance = this.balances.get(user) || 0;
        if (balance < amount) throw new Error("Insufficient balance");

        this.balances.set(user, balance - amount);

        if (!this.userItems.has(user)) {
            this.userItems.set(user, []);
        }
        this.userItems.get(user).push(item);

        console.log(`${user} bought ${item} for ${amount} tokens`);
    }

    // Read-only functions
    getBalance(user) { return this.balances.get(user) || 0; }
    getTotalSupply() { return this.totalSupply; }
    getUserItems(user) { return this.userItems.get(user) || []; }
}

// Usage Example
const rewards = new TokenRewards();
rewards.earnTokens("alice", 50);           // Alice earns 50 tokens
rewards.spendTokens("alice", 20, "Coffee"); // Alice spends 20 tokens
console.log(rewards.getBalance("alice"));   // Shows: 30 tokens

#![no_std]
klever_sc::imports!();

#[klever_sc::contract]
pub trait TokenRewards {

    #[init]  // Like constructor() but called once on deploy
    fn init(&self) {
        let caller = self.blockchain().get_caller();
        self.owner().set(caller);
        self.total_supply().set(BigUint::from(10_000u64));
    }

    // ENDPOINTS = Functions that CHANGE data (cost gas like database writes)

    #[endpoint(earnTokens)]
    fn earn_tokens(&self, amount: BigUint) {
        let caller = self.blockchain().get_caller();  // Who called this?

        // Same validation as JavaScript!
        require!(amount > 0, "Amount must be positive");
        require!(amount <= BigUint::from(100u64), "Max 100 tokens per earn");

        let supply = self.total_supply().get();
        require!(amount <= supply, "Not enough tokens in supply");

        // Update user balance (like this.balances.set(user, newBalance))
        let current_balance = self.balances(&caller).get();
        self.balances(&caller).set(&current_balance + &amount);

        // Reduce total supply
        self.total_supply().set(&supply - &amount);

        // Log event (instead of console.log)
        self.earn_event(&caller, &amount);
    }

    #[endpoint(spendTokens)]
    fn spend_tokens(&self, amount: BigUint, item: ManagedBuffer) {
        let caller = self.blockchain().get_caller();

        // Same validation!
        require!(amount > 0, "Amount must be positive");
        require!(!item.is_empty(), "Item name required");

        let balance = self.balances(&caller).get();
        require!(balance >= amount, "Insufficient balance");

        // Deduct tokens (like JavaScript Map.set)
        self.balances(&caller).set(&balance - &amount);

        // Add item to user's list (like JavaScript array.push)
        self.user_items(&caller).push(&item);

        // Log the purchase
        self.spend_event(&caller, &amount, &item);
    }

    // VIEWS = Functions that only READ data (FREE, like getters)

    #[view(getBalance)]
    fn get_balance(&self, user: ManagedAddress) -> BigUint {
        self.balances(&user).get()  // Same as JS: this.balances.get(user) || 0
    }

    #[view(getTotalSupply)]
    fn get_total_supply(&self) -> BigUint {
        self.total_supply().get()
    }

    #[view(getUserItems)]
    fn get_user_items(&self, user: ManagedAddress) -> MultiValueEncoded<ManagedBuffer> {
        let items = self.user_items(&user);
        let mut result = MultiValueEncoded::new();

        for i in 1..=items.len() {
            result.push(items.get(i));
        }

        result
    }

    // EVENTS = Like console.log but for blockchain (searchable logs)
    #[event("earn")]
    fn earn_event(&self, #[indexed] user: &ManagedAddress, #[indexed] amount: &BigUint);

    #[event("spend")]
    fn spend_event(&self, #[indexed] user: &ManagedAddress, #[indexed] amount: &BigUint, item: &ManagedBuffer);

    // STORAGE = Like class properties but PERSISTENT on blockchain
    #[storage_mapper("balances")]
    fn balances(&self, user: &ManagedAddress) -> SingleValueMapper<BigUint>;

    #[storage_mapper("totalSupply")]
    fn total_supply(&self) -> SingleValueMapper<BigUint>;

    #[storage_mapper("userItems")]
    fn user_items(&self, user: &ManagedAddress) -> VecMapper<ManagedBuffer>;

    #[storage_mapper("owner")]
    fn owner(&self) -> SingleValueMapper<ManagedAddress>;
}

// JavaScript
class TokenRewards {
    constructor() { /* setup */ }
    earnTokens(user, amount) { /* logic */ }
    getBalance(user) { return this.balances.get(user); }
}

// Rust
#[klever_sc::contract]
pub trait TokenRewards {
    #[init] fn init(&self) { /* setup */ }
    #[endpoint] fn earn_tokens(&self, amount: BigUint) { /* logic */ }
    #[view] fn get_balance(&self, user: ManagedAddress) -> BigUint { /* return */ }
}

// JavaScript - Lives in RAM, dies when app stops
this.balances = new Map();
this.totalSupply = 10000;

// Rust - Lives FOREVER on blockchain, persists between calls
#[storage_mapper("balances")]
fn balances(&self, user: &ManagedAddress) -> SingleValueMapper<BigUint>;

// JavaScript - All functions are "the same"
earnTokens(user, amount) { /* changes data */ }
getBalance(user) { /* reads data */ }

// Rust - Two types with VERY different costs!
#[endpoint] fn earn_tokens() { /* COSTS GAS - changes blockchain */ }
#[view] fn get_balance() { /* FREE - only reads */ }

// JavaScript
if (amount <= 0) throw new Error("Amount must be positive");

// Rust - Built for blockchain
require!(amount > 0, "Amount must be positive");

// JavaScript - Just prints to console
console.log(`${user} earned ${amount} tokens`);

// Rust - Permanent searchable blockchain logs
#[event("earn")]
fn earn_event(&self, #[indexed] user: &ManagedAddress, #[indexed] amount: &BigUint);