Move言語で安全かつ効率的なスマートコントラクトを開発するためのベストプラクティス

module my_module::example {
    use std::signer;

    struct MyResource has key { value: u64 }

    // 誰でも呼び出せるが、署名者が必要
    public entry fun create_resource(account: &signer, initial_value: u64) {
        move_to(account, MyResource { value: initial_value });
    }

    // モジュール内部でのみ使用
    fun internal_logic(res: &MyResource): u64 {
        res.value * 2
    }

    // 署名者が必要な操作
    public entry fun update_resource(account: &signer, new_value: u64) acquires MyResource {
        let addr = signer::address_of(account);
        // 呼び出し元がリソースを所有しているか確認
        assert!(exists<MyResource>(addr), 1); // エラーコードを使用
        let res = borrow_global_mut<MyResource>(addr);
        res.value = new_value;
    }
}

module my_nft::cool_nft {
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    // NFTを表すリソース型。コピーもドロップもできない。
    struct CoolNFT has key, store {
        id: UID,
        name: string::String,
        generation: u64
    }

    // NFTをミントする関数 (エントリーポイント)
    public entry fun mint(name: vector<u8>, ctx: &mut TxContext) {
        let nft = CoolNFT {
            id: object::new(ctx),
            name: string::utf8(name),
            generation: 0 // 初期世代
        };
        // ミントしたNFTをトランザクション送信者に転送
        transfer::transfer(nft, tx_context::sender(ctx));
    }

    // NFTを転送する関数 (エントリーポイント)
    public entry fun transfer_nft(nft: CoolNFT, recipient: address, _: &mut TxContext) {
        // CoolNFTは store アビリティを持つため、オブジェクトとして直接渡せる (Suiの場合)
        transfer::transfer(nft, recipient);
    }
}

module my_dao::voting {
    // ... (他の定義) ...
    public entry fun cast_vote(proposal_id: u64, voter: &signer, choice: bool) acquires Proposal, VotingPower {
        let voter_addr = std::signer::address_of(voter);
        // 投票権を持っているか確認
        assert!(exists<VotingPower>(voter_addr), Errors::E_NO_VOTING_POWER);
        // 提案が存在し、投票期間中か確認
        let proposal = borrow_global<Proposal>(PROPOSAL_STORAGE_ADDRESS); // 仮のアドレス
        assert!(proposal.id == proposal_id, Errors::E_PROPOSAL_NOT_FOUND);
        assert!(is_voting_period_active(proposal), Errors::E_VOTING_CLOSED);

        // ... (投票処理) ...
    }
    // ... (他の関数やエラー定義) ...
}

use std::math64; // Aptosの場合

fun safe_add(a: u64, b: u64): u64 {
    let (sum, overflow) = math64::add_with_carry(a, b);
    assert!(!overflow, Errors::E_ADDITION_OVERFLOW);
    sum
}

fun safe_sub(a: u64, b: u64): u64 {
    assert!(a >= b, Errors::E_SUBTRACTION_UNDERFLOW);
    a - b
}

module my_token::events {
    use aptos_framework::event; // Aptosの場合

    struct MintEvent has drop, store {
        recipient: address,
        amount: u64,
    }
    struct BurnEvent has drop, store {
        burner: address,
        amount: u64,
    }
    // イベントハンドルを格納する構造体
    struct EventHandles has key {
        mint_events: event::EventHandle<MintEvent>,
        burn_events: event::EventHandle<BurnEvent>,
    }
    // ... (初期化処理で EventHandles を move_to する) ...

    public(friend) fun emit_mint_event(handles_ref: &mut EventHandles, recipient: address, amount: u64) {
        event::emit_event<MintEvent>(
            &mut handles_ref.mint_events,
            MintEvent { recipient, amount },
        );
    }
    // ... (emit_burn_eventも同様) ...
}

module my_project::errors {
    /// The provided address does not have admin privileges.
    const E_NOT_ADMIN: u64 = 1;
    /// The specified resource ID was not found.
    const E_RESOURCE_NOT_FOUND: u64 = 2;
    /// Insufficient balance to perform the operation.
    const E_INSUFFICIENT_BALANCE: u64 = 3;
    /// The operation is not allowed in the current state.
    const E_INVALID_STATE: u64 = 4;
}

module my_project::core {
    use my_project::errors as Errors;
    use std::signer;
    // ... (struct definitions) ...

    const ADMIN_ADDRESS: address = @my_project_admin;

    struct Config has key { paused: bool }

    public entry fun perform_sensitive_action(account: &signer, resource_id: u64) acquires Config {
        // Check 1: Sender must be admin
        assert!(signer::address_of(account) == ADMIN_ADDRESS, Errors::E_NOT_ADMIN);

        // Check 2: System must not be paused
        let config = borrow_global<Config>(ADMIN_ADDRESS);
        assert!(!config.paused, Errors::E_INVALID_STATE);

        // Check 3: Resource must exist (assuming a function exists_resource)
        assert!(exists_resource(resource_id), Errors::E_RESOURCE_NOT_FOUND);

        // ... (perform the action) ...
    }
}