refactor: migrate to WIT generation macro in counter-contract example,

run `cargo update`, update miden-node to v0.12.2 in the local network tests.

Author: greenhat

Cargo.lock

@@ -12,8 +12,8 @@ crate-type = ["cdylib"]
 [dependencies]
 miden = { path = "../../sdk/sdk" }
 
-# [package.metadata.component]
-# package = "miden:counter-contract"
+[package.metadata.component]
+package = "miden:counter-contract"
 
 [package.metadata.miden]
 project-kind = "account"

examples/counter-contract/Cargo.toml

@@ -8,11 +8,6 @@
 
 use miden::{component, felt, Felt, StorageMap, StorageMapAccess, Word};
 
-use crate::bindings::exports::miden::counter_contract::counter::Guest;
-
-miden::generate!();
-bindings::export!(CounterContract);
-
 /// Main contract structure for the counter example.
 #[component]
 struct CounterContract {
@@ -21,29 +16,20 @@ struct CounterContract {
     count_map: StorageMap,
 }
 
-impl Guest for CounterContract {
+#[component]
+impl CounterContract {
     /// Returns the current counter value stored in the contract's storage map.
-    fn get_count() -> Felt {
-        // Get the instance of the contract
-        let contract = CounterContract::default();
-        // Define a fixed key for the counter value within the map
+    pub fn get_count(&self) -> Felt {
         let key = Word::from([felt!(0), felt!(0), felt!(0), felt!(1)]);
-        // Read the value associated with the key from the storage map
-        contract.count_map.get(&key)
+        self.count_map.get(&key)
     }
 
     /// Increments the counter value stored in the contract's storage map by one.
-    fn increment_count() -> Felt {
-        // Get the instance of the contract
-        let contract = CounterContract::default();
-        // Define the same fixed key
+    pub fn increment_count(&self) -> Felt {
         let key = Word::from([felt!(0), felt!(0), felt!(0), felt!(1)]);
-        // Read the current value
-        let current_value: Felt = contract.count_map.get(&key);
-        // Increment the value by one
+        let current_value: Felt = self.count_map.get(&key);
         let new_value = current_value + felt!(1);
-        // Write the new value back to the storage map
-        contract.count_map.set(key, new_value);
+        self.count_map.set(key, new_value);
         new_value
     }
 }

examples/counter-contract/src/lib.rs

@@ -27,7 +27,8 @@ package = "miden:counter-note"
 "miden:counter-contract" = { path = "../counter-contract" }
 
 [package.metadata.component.target.dependencies]
-"miden:counter-contract" = { path = "../counter-contract/wit/counter.wit" }
+"miden:counter-account" = { path = "../counter-contract/target/generated-wit/" }
+
 
 [profile.release]
 trim-paths = ["diagnostics", "object"]

examples/counter-contract/wit/counter.wit

@@ -9,13 +9,13 @@
 
 use miden::*;
 
-use crate::bindings::miden::counter_contract::counter;
+use crate::bindings::miden::counter_contract::counter_contract;
 
 #[note_script]
 fn run(_arg: Word) {
-    let initial_value = counter::get_count();
-    counter::increment_count();
+    let initial_value = counter_contract::get_count();
+    counter_contract::increment_count();
     let expected_value = initial_value + Felt::from_u32(1);
-    let final_value = counter::get_count();
+    let final_value = counter_contract::get_count();
     assert_eq(final_value, expected_value);
 }

examples/counter-note/Cargo.toml

@@ -11,7 +11,7 @@ use super::{process::kill_process, sync::read_pid, COORD_DIR};
 // the compatible miden-node version. Both should typically use the same major.minor version.
 
 /// The exact miden-node version that is compatible with the miden-client version used in tests
-const MIDEN_NODE_VERSION: &str = "0.12.0";
+const MIDEN_NODE_VERSION: &str = "0.12.2";
 
 /// Manages the lifecycle of a local Miden node instance
 pub struct LocalMidenNode;

examples/counter-note/src/lib.rs

@@ -100,28 +100,8 @@ pub fn test_counter_contract_local() {
             .build()
             .unwrap();
 
-        let tx_result = client
-            .execute_transaction(counter_account.id(), note_request)
-            .await
-            .map_err(|e| {
-                eprintln!("Transaction creation error: {e}");
-                e
-            })
-            .unwrap();
-        let executed_transaction = tx_result.executed_transaction();
-        // dbg!(executed_transaction.output_notes());
-
-        assert_eq!(executed_transaction.output_notes().num_notes(), 1);
-
-        let executed_tx_output_note = executed_transaction.output_notes().get_note(0);
-        assert_eq!(executed_tx_output_note.id(), counter_note.id());
-        let create_note_tx_id = executed_transaction.id();
-        let proven_tx = client.prove_transaction(&tx_result).await.unwrap();
-        let submission_height = client
-            .submit_proven_transaction(proven_tx, tx_result.tx_inputs().clone())
-            .await
-            .unwrap();
-        client.apply_transaction(&tx_result, submission_height).await.unwrap();
+        let create_note_tx_id =
+            client.submit_new_transaction(counter_account.id(), note_request).await.unwrap();
         eprintln!("Created counter note tx: {create_note_tx_id:?}");
 
         // Consume the note to increment the counter
@@ -130,25 +110,10 @@ pub fn test_counter_contract_local() {
             .build()
             .unwrap();
 
-        let tx_result = client
-            .execute_transaction(counter_account.id(), consume_request)
-            .await
-            .map_err(|e| {
-                eprintln!("Note consumption transaction error: {e}");
-                e
-            })
-            .unwrap();
-        eprintln!(
-            "Consumed counter note tx: https://testnet.midenscan.com/tx/{:?}",
-            &tx_result.executed_transaction().id()
-        );
-
-        let proven_tx = client.prove_transaction(&tx_result).await.unwrap();
-        let submission_height = client
-            .submit_proven_transaction(proven_tx, tx_result.tx_inputs().clone())
+        let _consume_tx_id = client
+            .submit_new_transaction(counter_account.id(), consume_request)
             .await
             .unwrap();
-        client.apply_transaction(&tx_result, submission_height).await.unwrap();
 
         let sync_result = client.sync_state().await.unwrap();
         eprintln!("Synced to block: {}", sync_result.block_num);