chore: update imports

Signed-off-by: Tomas Fabrizio Orsi <tomas.orsi@lambdaclass.com>

Author: lima-limon-inc

.github/workflows/ci.yml

@@ -318,14 +318,6 @@ jobs:
             cargo install cargo-make --force
           fi
 
-      # Some integration tests use midenup to compile the example projects
-      - name: Install midenup
-        run: |
-          if ! miden help 2>/dev/null; then
-            cargo install --git https://github.com/0xMiden/midenup
-            midenup init
-          fi
-
       - name: Test
         run: |
           cargo make test -E 'package(midenc-integration-network-tests)'

Cargo.lock

@@ -13,7 +13,7 @@ publish = false
 
 [dependencies]
 # miden-client = { version = "0.14", features = ["std", "tonic", "testing"] }
-miden-client = { git = "https://github.com/0xMiden/miden-client", branch = "release/v0.14.0-beta" }
+miden-client = { git = "https://github.com/0xMiden/miden-client", branch = "release/v0.14.0-beta", features = ["std", "testing"] }
 miden-core.workspace = true
 miden-protocol = { workspace = true, features = ["std", "testing"] }
 miden-standards = { workspace = true, features = ["std"] }

tests/integration-network/Cargo.toml

@@ -1,31 +1,29 @@
 //! Basic wallet test module
 
 use miden_client::{
-    asset::FungibleAsset, crypto::RandomCoin, note::NoteAssets, transaction::RawOutputNote,
+    account::{
+        component::{BasicWallet, InitStorageData},
+        AccountComponent,
+    },
+    asset::{Asset, FungibleAsset},
+    transaction::RawOutputNote,
 };
 use miden_core::Felt;
-use miden_protocol::account::{auth::AuthScheme, AccountId};
-use miden_testing::{AccountState, Auth, MockChain};
+use miden_protocol::{
+    account::auth::AuthScheme,
+    crypto::rand::RandomCoin,
+};
+use miden_standards::testing::note::NoteBuilder;
+use miden_testing::{Auth, MockChain};
 use midenc_expect_test::expect;
 
 use super::{
     cycle_helpers::{note_cycles, prologue_cycles, tx_script_processing_cycles},
     helpers::{
-        assert_account_has_fungible_asset, build_asset_transfer_tx,
-        build_existing_basic_wallet_account_builder, build_send_notes_script, compile_rust_package,
-        create_note_from_package, execute_tx, to_core_felts, NoteCreationConfig,
+        assert_account_has_fungible_asset, build_asset_transfer_tx, build_send_notes_script,
+        compile_rust_package, execute_tx, to_core_felts,
     },
 };
-use crate::mockchain::helpers::compile_rust_package;
-
-/// Converts the P2IDE note payload into protocol storage order for the basic-wallet tests.
-fn to_p2ide_storage_felts(
-    target: &AccountId,
-    reclaim_height: Felt,
-    timelock_height: Felt,
-) -> Vec<Felt> {
-    vec![target.suffix(), target.prefix().as_felt(), reclaim_height, timelock_height]
-}
 
 /// Tests the basic-wallet contract deployment and p2id note consumption workflow on a mock chain.
 #[test]
@@ -65,7 +63,7 @@ pub fn test_basic_wallet_p2id() {
     let bob_account = builder
         .add_existing_account_from_components(
             Auth::BasicAuth {
-                auth_sceme: AuthScheme::Falcon512Poseidon2,
+                auth_scheme: AuthScheme::Falcon512Poseidon2,
             },
             [wallet_component],
         )
@@ -80,11 +78,11 @@ pub fn test_basic_wallet_p2id() {
     let mint_amount = 100_000u64; // 100,000 tokens
     let mint_asset = FungibleAsset::new(faucet_id, mint_amount).unwrap();
 
-    let mut note_rng = RpoRandomCoin::new(note_package.unwrap_program().hash());
+    let mut note_rng = RandomCoin::new(note_package.unwrap_program().hash());
     let p2id_note_mint = NoteBuilder::new(faucet_id, &mut note_rng)
         .package((*note_package).clone())
         .add_assets([Asset::from(mint_asset)])
-        .note_inputs(to_core_felts(&alice_id))
+        .note_storage(to_core_felts(&alice_id))
         .unwrap()
         .build()
         .unwrap();
@@ -173,7 +171,7 @@ pub fn test_basic_wallet_p2ide() {
     let alice_account = builder
         .add_existing_account_from_components(
             Auth::BasicAuth {
-                auth_sceme: AuthScheme::Falcon512Poseidon2,
+                auth_scheme: AuthScheme::Falcon512Poseidon2,
             },
             [wallet_component.clone(), BasicWallet.into()],
         )
@@ -183,7 +181,7 @@ pub fn test_basic_wallet_p2ide() {
     let bob_account = builder
         .add_existing_account_from_components(
             Auth::BasicAuth {
-                auth_sceme: AuthScheme::Falcon512Poseidon2,
+                auth_scheme: AuthScheme::Falcon512Poseidon2,
             },
             [wallet_component],
         )
@@ -198,11 +196,11 @@ pub fn test_basic_wallet_p2ide() {
     let mint_amount = 100_000u64;
     let mint_asset = FungibleAsset::new(faucet_id, mint_amount).unwrap();
 
-    let p2id_rng = RpoRandomCoin::new(p2id_note_package.unwrap_program().hash());
+    let p2id_rng = RandomCoin::new(p2id_note_package.unwrap_program().hash());
     let p2id_note_mint = NoteBuilder::new(faucet_id, p2id_rng)
         .package((*p2id_note_package).clone())
         .add_assets([Asset::from(mint_asset)])
-        .note_inputs(to_core_felts(&alice_id))
+        .note_storage(to_core_felts(&alice_id))
         .unwrap()
         .build()
         .unwrap();
@@ -231,11 +229,11 @@ pub fn test_basic_wallet_p2ide() {
     let timelock_height = Felt::new(0);
     let reclaim_height = Felt::new(0);
 
-    let p2ide_rng = RpoRandomCoin::new(p2ide_note_package.unwrap_program().hash());
+    let p2ide_rng = RandomCoin::new(p2ide_note_package.unwrap_program().hash());
     let p2ide_note = NoteBuilder::new(alice_id, p2ide_rng)
         .package((*p2ide_note_package).clone())
         .add_assets([Asset::from(transfer_asset)])
-        .note_inputs({
+        .note_storage({
             let mut inputs = to_core_felts(&bob_id);
             inputs.extend([timelock_height, reclaim_height]);
             inputs
@@ -302,7 +300,7 @@ pub fn test_basic_wallet_p2ide_reclaim() {
     let alice_account = builder
         .add_existing_account_from_components(
             Auth::BasicAuth {
-                auth_sceme: AuthScheme::Falcon512Poseidon2,
+                auth_scheme: AuthScheme::Falcon512Poseidon2,
             },
             [wallet_component.clone(), BasicWallet.into()],
         )
@@ -312,7 +310,7 @@ pub fn test_basic_wallet_p2ide_reclaim() {
     let bob_account = builder
         .add_existing_account_from_components(
             Auth::BasicAuth {
-                auth_sceme: AuthScheme::Falcon512Poseidon2,
+                auth_scheme: AuthScheme::Falcon512Poseidon2,
             },
             [wallet_component],
         )
@@ -327,11 +325,11 @@ pub fn test_basic_wallet_p2ide_reclaim() {
     let mint_amount = 100_000u64;
     let mint_asset = FungibleAsset::new(faucet_id, mint_amount).unwrap();
 
-    let p2id_rng = RpoRandomCoin::new(p2id_note_package.unwrap_program().hash());
+    let p2id_rng = RandomCoin::new(p2id_note_package.unwrap_program().hash());
     let p2id_note_mint = NoteBuilder::new(faucet_id, p2id_rng)
         .package((*p2id_note_package).clone())
         .add_assets([Asset::from(mint_asset)])
-        .note_inputs(to_core_felts(&alice_id))
+        .note_storage(to_core_felts(&alice_id))
         .unwrap()
         .build()
         .unwrap();
@@ -360,11 +358,11 @@ pub fn test_basic_wallet_p2ide_reclaim() {
     let timelock_height = Felt::new(0);
     let reclaim_height = Felt::new(1);
 
-    let p2ide_rng = RpoRandomCoin::new(p2ide_note_package.unwrap_program().hash());
+    let p2ide_rng = RandomCoin::new(p2ide_note_package.unwrap_program().hash());
     let p2ide_note = NoteBuilder::new(alice_id, p2ide_rng)
         .package((*p2ide_note_package).clone())
         .add_assets([Asset::from(transfer_asset)])
-        .note_inputs({
+        .note_storage({
             let mut inputs = to_core_felts(&bob_id);
             inputs.extend([timelock_height, reclaim_height]);
             inputs

tests/integration-network/src/mockchain/basic_wallet.rs

@@ -1,28 +1,25 @@
 //! Counter contract test module
 
 use miden_client::{
-    account::component::BasicWallet,
-    crypto::{RandomCoin, RpoRandomCoin},
-    note::NoteTag,
+    account::{component::InitStorageData, AccountComponent},
     transaction::RawOutputNote,
     Word,
 };
 use miden_core::Felt;
-use miden_protocol::account::{
-    auth::AuthScheme, AccountBuilder, AccountStorageMode, AccountType, StorageMap, StorageMapKey,
-    StorageSlot, StorageSlotName,
+use miden_protocol::{
+    account::{auth::AuthScheme, StorageSlotName},
+    crypto::rand::RandomCoin,
 };
-use miden_testing::{AccountState, Auth, MockChain};
+use miden_standards::testing::note::NoteBuilder;
+use miden_testing::{Auth, MockChain};
 use midenc_expect_test::expect;
 
 use super::{
     cycle_helpers::note_cycles,
     helpers::{
-        account_component_from_package, assert_counter_storage, compile_rust_package,
-        create_note_from_package, execute_tx, NoteCreationConfig,
+        assert_counter_storage, compile_rust_package, execute_tx, COUNTER_CONTRACT_STORAGE_KEY,
     },
 };
-use crate::mockchain::helpers::COUNTER_CONTRACT_STORAGE_KEY;
 
 /// Tests the counter contract deployment and note consumption workflow on a mock chain.
 #[test]
@@ -34,33 +31,30 @@ pub fn test_counter_contract() {
     let value = Word::from([Felt::ZERO, Felt::ZERO, Felt::ZERO, Felt::ONE]);
     let counter_storage_slot =
         StorageSlotName::new("miden::component::miden_counter_contract::count_map").unwrap();
-    let storage_slots = vec![StorageSlot::with_map(
-        counter_storage_slot.clone(),
-        StorageMap::with_entries([(StorageMapKey::new(COUNTER_CONTRACT_STORAGE_KEY), value)])
-            .unwrap(),
-    )];
 
     let mut init_storage_data = InitStorageData::default();
     init_storage_data
-        .insert_map_entry(counter_storage_slot.clone(), key, value)
+        .insert_map_entry(counter_storage_slot.clone(), COUNTER_CONTRACT_STORAGE_KEY, value)
         .unwrap();
-    let contract_package = AccountComponent::from_package(&contract_package, &init_storage_data)
+    let contract_component = AccountComponent::from_package(&contract_package, &init_storage_data)
         .expect("Failed to build account component from counter project");
 
     let mut builder = MockChain::builder();
     let counter_account = builder
         .add_existing_account_from_components(
-            Auth::BasicAuth,
-            [BasicWallet.into(), contract_package],
+            Auth::BasicAuth {
+                auth_scheme: AuthScheme::Falcon512Poseidon2,
+            },
+            [contract_component],
         )
         .unwrap();
 
-    let mut rng = RpoRandomCoin::new(note_package.clone().unwrap_program().hash());
+    let mut rng = RandomCoin::new(note_package.clone().unwrap_program().hash());
     let counter_note = NoteBuilder::new(counter_account.id(), &mut rng)
         .package((*note_package).clone())
         .build()
         .unwrap();
-    builder.add_output_note(OutputNote::Full(counter_note.clone()));
+    builder.add_output_note(RawOutputNote::Full(counter_note.clone()));
 
     let mut chain = builder.build().expect("failed to build mock chain");
     chain.prove_next_block().unwrap();

tests/integration-network/src/mockchain/counter_contract.rs

@@ -1,30 +1,27 @@
 //! Counter contract test with no-auth authentication component
 
 use miden_client::{
-    account::component::BasicWallet, crypto::RandomCoin, note::NoteTag, transaction::RawOutputNote,
+    account::{component::InitStorageData, AccountComponent},
+    note::NoteTag,
+    transaction::RawOutputNote,
     Word,
 };
-use miden_core::{Felt, FieldElement};
-use miden_protocol::account::{
-    auth::AuthScheme, AccountBuilder, AccountStorageMode, AccountType, StorageMap, StorageMapKey,
-    StorageSlot, StorageSlotName,
+use miden_core::Felt;
+use miden_protocol::{
+    account::{auth::AuthScheme, AccountBuilder, AccountStorageMode, AccountType, StorageSlotName},
+    crypto::rand::RandomCoin,
 };
+use miden_standards::testing::note::NoteBuilder;
 use miden_testing::{AccountState, Auth, MockChain};
 use midenc_expect_test::expect;
 
 use super::{
-    crypto::RpoRandomCoin,
     cycle_helpers::{auth_procedure_cycles, note_cycles},
     helpers::{
         assert_counter_storage, build_existing_counter_account_builder_with_auth_package,
-        compile_rust_package, create_note_from_package, execute_tx, NoteCreationConfig,
+        compile_rust_package, execute_tx, COUNTER_CONTRACT_STORAGE_KEY,
     },
-    note::NoteTag,
-    testing::{AccountState, Auth, MockChain, NoteBuilder},
-    transaction::OutputNote,
-    Word,
 };
-use crate::mockchain::helpers::compile_rust_package;
 
 /// Tests the counter contract with a "no-auth" authentication component.
 ///
@@ -44,26 +41,16 @@ pub fn test_counter_contract_no_auth() {
     let value = Word::from([Felt::ZERO, Felt::ZERO, Felt::ZERO, Felt::ONE]);
     let counter_storage_slot =
         StorageSlotName::new("miden::component::miden_counter_contract::count_map").unwrap();
-    let counter_storage_slots = vec![StorageSlot::with_map(
-        counter_storage_slot.clone(),
-        StorageMap::with_entries([(StorageMapKey::new(COUNTER_CONTRACT_STORAGE_KEY), value)])
-            .unwrap(),
-    )];
 
-    let mut builder = MockChain::builder();
     let counter_component = {
         let mut init_storage_data = InitStorageData::default();
         init_storage_data
-            .insert_map_entry(counter_storage_slot.clone(), key, value)
+            .insert_map_entry(counter_storage_slot.clone(), COUNTER_CONTRACT_STORAGE_KEY, value)
             .unwrap();
         AccountComponent::from_package(&counter_package, &init_storage_data).unwrap()
     };
 
-    let mut counter_init_storage_data = InitStorageData::default();
-    counter_init_storage_data
-        .insert_map_entry(counter_storage_slot.clone(), key, value)
-        .expect("failed to insert counter map entry");
-
+    let mut builder = MockChain::builder();
     let counter_account = build_existing_counter_account_builder_with_auth_package(
         counter_component,
         no_auth_auth_component,
@@ -82,7 +69,7 @@ pub fn test_counter_contract_no_auth() {
     let sender_builder = AccountBuilder::new(seed)
         .account_type(AccountType::RegularAccountUpdatableCode)
         .storage_mode(AccountStorageMode::Public)
-        .with_component(BasicWallet);
+        .with_component(miden_client::account::component::BasicWallet);
     let sender_account = builder
         .add_account_from_builder(
             Auth::BasicAuth {
@@ -95,7 +82,7 @@ pub fn test_counter_contract_no_auth() {
     eprintln!("Sender account ID: {:?}", sender_account.id().to_hex());
 
     // Sender creates the counter note (note script increments counter's storage on consumption)
-    let rng = RpoRandomCoin::new(note_package.unwrap_program().hash());
+    let rng = RandomCoin::new(note_package.unwrap_program().hash());
     let counter_note = NoteBuilder::new(sender_account.id(), rng)
         .package((*note_package).clone())
         .tag(NoteTag::with_account_target(counter_account.id()).into())