Learn MOVE with Real Code Examples

module 0x1::Counter {
    resource struct Counter { value: u64 }

    public fun create(): Counter {
        Counter { value: 0 }
    }

    public fun increment(counter: &mut Counter) {
        counter.value = counter.value + 1
    }

    public fun reset(counter: &mut Counter) {
        counter.value = 0
    }
}

Basic counter resource with increment and reset.

module 0x1::Bank {
    resource struct Account { balance: u64 }

    public fun create(): Account {
        Account { balance: 0 }
    }

    public fun deposit(acc: &mut Account, amount: u64) {
        acc.balance = acc.balance + amount
    }

    public fun withdraw(acc: &mut Account, amount: u64) {
        acc.balance = acc.balance - amount
    }
}

A simple bank account resource with deposit and withdraw.

module 0x1::NameStore {
    resource struct Name { value: vector<u8> }

    public fun set_name(name: vector<u8>): Name {
        Name { value: name }
    }

    public fun update(n: &mut Name, new_name: vector<u8>) {
        n.value = new_name
    }
}

A resource storing a user's name on-chain.

module 0x1::OwnedCounter {
    resource struct Counter { owner: address, value: u64 }

    public fun create(owner: address): Counter {
        Counter { owner, value: 0 }
    }

    public fun inc(c: &mut Counter, caller: address) {
        assert!(caller == c.owner, 1)
        c.value = c.value + 1
    }
}

Adds ownership to a counter resource.

module 0x1::Points {
    resource struct Score { value: u64 }

    public fun new(): Score {
        Score { value: 0 }
    }

    public fun add(score: &mut Score, pts: u64) {
        score.value = score.value + pts
    }
}

Simple reward points module.

module 0x1::Flag {
    resource struct Flag { enabled: bool }

    public fun new(): Flag {
        Flag { enabled: false }
    }

    public fun toggle(f: &mut Flag) {
        f.enabled = !f.enabled
    }
}

Stores and toggles a boolean value.

module 0x1::PairStore {
    resource struct Pair { a: u64, b: u64 }

    public fun create(a: u64, b: u64): Pair {
        Pair { a, b }
    }

    public fun update(p: &mut Pair, a: u64, b: u64) {
        p.a = a
        p.b = b
    }
}

Stores a pair of u64 values.

module 0x1::Token {
    resource struct Balance { amount: u64 }

    public fun mint(): Balance {
        Balance { amount: 100 }
    }

    public fun add(b: &mut Balance, amt: u64) {
        b.amount = b.amount + amt
    }
}

A minimal token balance resource.

module 0x1::Access {
    resource struct Data { owner: address, value: u64 }

    public fun create(owner: address): Data {
        Data { owner, value: 0 }
    }

    public fun set(d: &mut Data, caller: address, v: u64) {
        assert!(caller == d.owner, 2)
        d.value = v
    }
}

Move module enforcing owner-only updates.

module 0x1::Events {
    struct IncrementEvent has drop { amount: u64 }
    resource struct Counter { value: u64, events: event::EventHandle<IncrementEvent> }

    public fun create(): Counter {
        Counter { value: 0, events: event::new_event_handle<IncrementEvent>(0x1) }
    }

    public fun inc(c: &mut Counter) {
        c.value = c.value + 1
        event::emit_event(&mut c.events, IncrementEvent { amount: c.value })
    }
}

Module showing basic event emission.