Appendices

Syntax cheat sheet, keywords, standard library reference, version & history table, learning resources and suggested study plan (12 weeks).

Appendices

45.1 Syntax cheat sheet Reserved/keywords: abort acquires as break const continue copy else entry enum false friend fun if inline let loop match macro module move mut native package phantom public return script spec struct true use while for in has Abilities: copy drop store key

Spec language: aborts_if aborts_with ensures requires invariant modifies old result global exists forall pragma schema include apply assume assert emits

Built-in operations: move_to move_from borrow_global borrow_global_mut exists freeze assert! (global storage ops are not available on Sui)

Attributes: #[test] #[test_only] #[expected_failure] #[view] #[event] #[randomness] #[error] #[allow(...)] #[deprecated] #[resource_group_member] #[syntax(index)] #[random_test] #[lint_allow(...)] 45.3 Standard library reference

push_back pop_back length borrow borrow_mut swap remove swap_remove contains index_of reverse append + macros (Sui) / inline HOFs (Aptos)

some none is_some is_none borrow extract fill destroy_some destroy_none get_with_default std::string / std::ascii

utf8 try_utf8 append length sub_string index_of as_bytes / string try_string to_uppercase to_bytes (serialize any value) sha2_256 sha3_256

std::type_name / aptos_std::type_info Runtime type names Aptos (also in std) Canonical error categories std::u8... std::u256

max min pow sqrt diff to_string + loop macros UID ID new delete id id_address uid_to_inner

transfer public_transfer share_object freeze_object receive

sender epoch epoch_timestamp_ms digest sui::coin / sui::balance

Coin TreasuryCap create_currency mint burn split join take put / Balance Supply zero join split create_supply

sui::dynamic_field / dynamic_object_field add borrow borrow_mut remove exists_

sui::table, bag, object_table, linked_table, vec_map, vec_set sui::clock / sui::random

timestamp_ms / new_generator generate_u64 generate_u8_in_range sui::package / sui::display

claim claim_and_keep UpgradeCap / new_with_fields add update_version sui::kiosk / sui::transfer_policy

new place list purchase lock / new confirm_request add_rule Closed-loop tokens with policies

create_resource_account create_signer_with_capability create_object create_named_object generate_signer ExtendRef TransferRef DeleteRef transfer

aptos_framework::fungible_asset / primary_fungible_store

MintRef BurnRef TransferRef Metadata / create_primary_store_enabled_fungible_asset mint transfer balance

aptos_framework::coin / aptos_account Legacy coin / transfer transfer_coins

aptos_framework::timestamp / randomness now_seconds now_microseconds / u64_range u64_integer permutation

aptos_std::table, smart_table, simple_map, big_ordered_map

aptos_std::math64, math128, fixed_point64 aptos_token_objects::collection / token / royalty Digital Asset standard 45.4 Version & history table Move designed at Facebook for Libra Move paper and Libra testnet Libra renamed Diem Move Prover verifies the Diem Framework Diem wound down

Aptos Object framework, Fungible Asset and Digital Asset standards introduced

Sui Move 2024 edition (method syntax, macros, enums, public(package), labeled control flow)

Aptos Move 2.0 (enums, receiver functions, index notation, for loops)

Aptos Move 2.1 (compound assignment, loop labels) and 2.2 (function values, optional acquires)

Sui: party objects, Coin Registry, new package management, gRPC APIs; Movement mainnet; IOTA Rebased on Sui-style Move

Continued APT/coin migration to Fungible Assets; further Move language and tooling releases on both chains 45.5 Learning resources Official documentation:

*The Move Book* (move-book.com) — Sui Move 2024 language and concepts

*The Move Reference* (Sui) — language reference Sui Documentation (docs.sui.io) — guides, framework reference, examples

Aptos Developer Docs (aptos.dev) — Move book for Aptos, framework reference, SDKs

Movement documentation — Aptos-compatible tooling on Movement Interactive & tutorials:

Sui Move Intro Course and Sui Foundation workshops Aptos Learn (learn.aptoslabs.com) tutorials and create-aptos-dapp templates

Move by Example sites, Move Patterns (patterns for Sui Move)

Mysten Labs and Aptos Labs GitHub examples (sui/examples, aptos-core/aptos-move/move-examples) Books & papers:

*Move: A Language With Programmable Resources* — Blackshear et al. (2019)

*The Move Prover* — Zhong et al. (CAV 2020) and *Fast and Reliable Formal Verification of Smart Contracts with the Move Prover* (TACAS 2022)

*The Sui Smart Contracts Platform* white paper; *Sui Lutris* and *Mysticeti* papers

*Block-STM* paper (Aptos parallel execution) Community: Sui and Aptos Discord servers, Sui Developer Forum, Aptos forum, Move-language GitHub discussions, hackathons (Sui Overflow, Aptos hackathons), security blogs from OtterSec, Zellic, MoveBit, Asymptotic 45.6 Suggested study plan (12 weeks)

History, resource-oriented thinking, install tools, run a localnet

Packages, first module on Sui and Aptos, primitives, integer arithmetic

Vectors, options, strings, control flow — Part I exercises Modules, functions, structs, abilities

Ownership, references, generics, phantom types Enums, method syntax and macros, errors, events, testing — Part II exercises, Project 1 26–27 or 28–30

Your chain's storage model: Aptos global storage and objects, or the Sui object model and dynamic fields

Design patterns, Publisher/Display, coins and fungible assets — Project 2

NFTs, Kiosk/Digital Assets, transactions, time and randomness — Project 3

Upgrades, gas, security, Move Prover — Part III exercises SDKs, frontends, indexers, complete projects — Project 4 or 5

Best practices, the other dialect's storage model, capstone — Project 6, 7, or 8 🎓 Final Words

You've journeyed from the first module declaration to object-centric storage, global resources, capabilities, hot potatoes, coins, NFTs, upgrades, and formally verified invariants. Move asks you to think about assets the way the physical world does: they can be moved, held, and transformed, but never duplicated or lost by accident — and the compiler holds you to it. Learn both dialects, read the frameworks' source code, write tests for every abort path, and treat every public function as an entry point an adversary will call. Build the capstone projects, ship to testnet, get your code reviewed, and help grow the Move ecosystem. Happy building! 🚀

// ---------- Sui Move 2024 ----------
module pkg::example;

use std::string::String;
use sui::coin::{Self, Coin};
use sui::sui::SUI;

const EBad: u64 = 0;
#[error]
const ENotOwner: vector<u8> = b"Caller is not the owner";

public struct Thing has key, store { id: UID, name: String, owner: address }
public struct Cap has key, store { id: UID }
public struct Receipt { amount: u64 }                 // hot potato
public enum Mode has copy, drop, store { On, Off, Level(u8) }

fun init(ctx: &mut TxContext) { transfer::transfer(Cap { id: object::new(ctx) }, ctx.sender()); }

public fun new(name: String, ctx: &mut TxContext): Thing {
    Thing { id: object::new(ctx), name, owner: ctx.sender() }
}
public fun name(self: &Thing): &String { &self.name }
public fun rename(self: &mut Thing, n: String, ctx: &TxContext) {
    assert!(self.owner == ctx.sender(), ENotOwner);
    self.name = n;
}
public fun burn(self: Thing) { let Thing { id, name: _, owner: _ } = self; id.delete(); }

public fun level(m: &Mode): u8 { match (m) { Mode::Level(l) => *l, Mode::On => 1, Mode::Off => 0 } }

// transfer::transfer / public_transfer / share_object / freeze_object
// let mut v = vector[1, 2, 3]; v.push_back(
…