movementkit-cli 1.0.1 → 1.0.3

package/kits/engineer/contracts/Move.toml

@@ -0,0 +1,13 @@
+[package]
+name = "movement_dapp"
+version = "1.0.0"
+authors = []
+
+[addresses]
+module_addr = "_"
+
+[dependencies]
+AptosFramework = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-framework", rev = "mainnet" }
+AptosStdlib = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-stdlib", rev = "mainnet" }
+MoveStdlib = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/move-stdlib", rev = "mainnet" }
+

package/kits/engineer/contracts/sources/counter.move

@@ -0,0 +1,122 @@
+/// A simple counter module demonstrating basic Move patterns on Movement blockchain.
+/// This serves as a template for building more complex dApps.
+module module_addr::counter {
+    use std::signer;
+    use aptos_framework::event;
+
+    // ==================== Error Codes ====================
+    
+    /// Error when counter doesn't exist for the account
+    const E_COUNTER_NOT_FOUND: u64 = 1;
+    /// Error when counter already exists for the account
+    const E_COUNTER_ALREADY_EXISTS: u64 = 2;
+
+    // ==================== Resources ====================
+
+    /// Counter resource stored at each user's address
+    struct Counter has key {
+        value: u64,
+    }
+
+    // ==================== Events ====================
+
+    /// Event emitted when a counter is created
+    #[event]
+    struct CounterCreated has drop, store {
+        account: address,
+        initial_value: u64,
+    }
+
+    /// Event emitted when a counter is incremented
+    #[event]
+    struct CounterIncremented has drop, store {
+        account: address,
+        old_value: u64,
+        new_value: u64,
+    }
+
+    /// Event emitted when a counter is decremented
+    #[event]
+    struct CounterDecremented has drop, store {
+        account: address,
+        old_value: u64,
+        new_value: u64,
+    }
+
+    // ==================== Entry Functions ====================
+
+    /// Initialize a new counter for the calling account
+    public entry fun initialize(account: &signer) {
+        let addr = signer::address_of(account);
+        assert!(!exists<Counter>(addr), E_COUNTER_ALREADY_EXISTS);
+        
+        move_to(account, Counter { value: 0 });
+        
+        event::emit(CounterCreated {
+            account: addr,
+            initial_value: 0,
+        });
+    }
+
+    /// Increment the counter by 1
+    public entry fun increment(account: &signer) acquires Counter {
+        let addr = signer::address_of(account);
+        assert!(exists<Counter>(addr), E_COUNTER_NOT_FOUND);
+        
+        let counter = borrow_global_mut<Counter>(addr);
+        let old_value = counter.value;
+        counter.value = counter.value + 1;
+        
+        event::emit(CounterIncremented {
+            account: addr,
+            old_value,
+            new_value: counter.value,
+        });
+    }
+
+    /// Decrement the counter by 1 (saturating at 0)
+    public entry fun decrement(account: &signer) acquires Counter {
+        let addr = signer::address_of(account);
+        assert!(exists<Counter>(addr), E_COUNTER_NOT_FOUND);
+        
+        let counter = borrow_global_mut<Counter>(addr);
+        let old_value = counter.value;
+        
+        if (counter.value > 0) {
+            counter.value = counter.value - 1;
+        };
+        
+        event::emit(CounterDecremented {
+            account: addr,
+            old_value,
+            new_value: counter.value,
+        });
+    }
+
+    /// Set the counter to a specific value
+    public entry fun set_value(account: &signer, new_value: u64) acquires Counter {
+        let addr = signer::address_of(account);
+        assert!(exists<Counter>(addr), E_COUNTER_NOT_FOUND);
+        
+        let counter = borrow_global_mut<Counter>(addr);
+        counter.value = new_value;
+    }
+
+    // ==================== View Functions ====================
+
+    /// Get the current counter value for an address
+    #[view]
+    public fun get_count(addr: address): u64 acquires Counter {
+        if (!exists<Counter>(addr)) {
+            return 0
+        };
+        borrow_global<Counter>(addr).value
+    }
+
+    /// Check if a counter exists for an address
+    #[view]
+    public fun has_counter(addr: address): bool {
+        exists<Counter>(addr)
+    }
+}
+

package/kits/engineer/contracts/tests/counter_tests.move

@@ -0,0 +1,96 @@
+#[test_only]
+module module_addr::counter_tests {
+    use std::signer;
+    use module_addr::counter;
+
+    #[test(account = @0x1)]
+    fun test_initialize(account: &signer) {
+        // Initialize counter
+        counter::initialize(account);
+        
+        // Verify counter exists and has value 0
+        let addr = signer::address_of(account);
+        assert!(counter::has_counter(addr), 0);
+        assert!(counter::get_count(addr) == 0, 1);
+    }
+
+    #[test(account = @0x1)]
+    fun test_increment(account: &signer) {
+        // Setup
+        counter::initialize(account);
+        let addr = signer::address_of(account);
+        
+        // Increment
+        counter::increment(account);
+        assert!(counter::get_count(addr) == 1, 0);
+        
+        // Increment again
+        counter::increment(account);
+        assert!(counter::get_count(addr) == 2, 1);
+    }
+
+    #[test(account = @0x1)]
+    fun test_decrement(account: &signer) {
+        // Setup
+        counter::initialize(account);
+        let addr = signer::address_of(account);
+        
+        // Increment first
+        counter::increment(account);
+        counter::increment(account);
+        assert!(counter::get_count(addr) == 2, 0);
+        
+        // Decrement
+        counter::decrement(account);
+        assert!(counter::get_count(addr) == 1, 1);
+    }
+
+    #[test(account = @0x1)]
+    fun test_decrement_at_zero(account: &signer) {
+        // Setup
+        counter::initialize(account);
+        let addr = signer::address_of(account);
+        
+        // Decrement at 0 should stay at 0 (saturating)
+        counter::decrement(account);
+        assert!(counter::get_count(addr) == 0, 0);
+    }
+
+    #[test(account = @0x1)]
+    fun test_set_value(account: &signer) {
+        // Setup
+        counter::initialize(account);
+        let addr = signer::address_of(account);
+        
+        // Set value
+        counter::set_value(account, 100);
+        assert!(counter::get_count(addr) == 100, 0);
+    }
+
+    #[test(account = @0x1)]
+    #[expected_failure(abort_code = counter::E_COUNTER_ALREADY_EXISTS)]
+    fun test_double_initialize_fails(account: &signer) {
+        counter::initialize(account);
+        counter::initialize(account); // Should fail
+    }
+
+    #[test(account = @0x1)]
+    #[expected_failure(abort_code = counter::E_COUNTER_NOT_FOUND)]
+    fun test_increment_without_init_fails(account: &signer) {
+        counter::increment(account); // Should fail - no counter
+    }
+
+    #[test]
+    fun test_get_count_nonexistent() {
+        // Getting count for non-existent counter should return 0
+        let count = counter::get_count(@0x999);
+        assert!(count == 0, 0);
+    }
+
+    #[test]
+    fun test_has_counter_nonexistent() {
+        // Checking non-existent counter should return false
+        assert!(!counter::has_counter(@0x999), 0);
+    }
+}
+