Merge branch 'rc/v0.53' into system-func-calls-interactor

Author: JustEatAnApple

contracts/examples/adder/interact/.gitignore

@@ -1,5 +1,6 @@
 # Pem files are used for interactions, but shouldn't be committed
 *.pem
+*.json
 !adder-owner.pem
 
 # Temporary storage of deployed contract address, so we can preserve the context between executions.

contracts/examples/adder/interact/src/basic_interact.rs

@@ -41,7 +41,10 @@ async fn main() {
             basic_interact.print_sum().await;
         },
         Some(basic_interact_cli::InteractCliCommand::Upgrade(args)) => {
-            basic_interact.upgrade(args.value).await
+            let owner_address = basic_interact.adder_owner_address.clone();
+            basic_interact
+                .upgrade(args.value, &owner_address, None)
+                .await
         },
         None => {},
     }
@@ -66,8 +69,14 @@ impl AdderInteract {
         let adder_owner_address =
             interactor.register_wallet(Wallet::from_pem_file("adder-owner.pem").unwrap());
         // PASSWORD: "alice"
-        let wallet_address = interactor
-            .register_wallet(Wallet::from_keystore_secret("alice.json", "alice").unwrap());
+        // InsertPassword::Plaintext("alice".to_string()) || InsertPassword::StandardInput
+        let wallet_address = interactor.register_wallet(
+            Wallet::from_keystore_secret(
+                "alice.json",
+                InsertPassword::Plaintext("alice".to_string()),
+            )
+            .unwrap(),
+        );
 
         Self {
             interactor,
@@ -95,7 +104,7 @@ impl AdderInteract {
             .interactor
             .tx()
             .from(&self.adder_owner_address)
-            .gas(3_000_000)
+            .gas(6_000_000)
             .typed(adder_proxy::AdderProxy)
             .init(0u32)
             .code(ADDER_CODE_PATH)
@@ -125,7 +134,7 @@ impl AdderInteract {
                     .typed(adder_proxy::AdderProxy)
                     .init(0u32)
                     .code(ADDER_CODE_PATH)
-                    .gas(3_000_000)
+                    .gas(6_000_000)
                     .returns(ReturnsNewBech32Address)
             });
         }
@@ -153,7 +162,7 @@ impl AdderInteract {
                     .to(self.state.current_adder_address())
                     .typed(adder_proxy::AdderProxy)
                     .add(value)
-                    .gas(3_000_000)
+                    .gas(6_000_000)
             });
         }
 
@@ -178,7 +187,7 @@ impl AdderInteract {
             .tx()
             .from(&self.wallet_address)
             .to(self.state.current_adder_address())
-            .gas(3_000_000)
+            .gas(6_000_000)
             .typed(adder_proxy::AdderProxy)
             .add(value)
             .prepare_async()
@@ -203,45 +212,87 @@ impl AdderInteract {
         println!("sum: {sum}");
     }
 
-    async fn upgrade(&mut self, new_value: u32) {
-        let response = self
-            .interactor
-            .tx()
-            .from(&self.wallet_address)
-            .to(self.state.current_adder_address())
-            .gas(3_000_000)
-            .typed(adder_proxy::AdderProxy)
-            .upgrade(BigUint::from(new_value))
-            .code_metadata(CodeMetadata::UPGRADEABLE)
-            .code(ADDER_CODE_PATH)
-            .returns(ReturnsResultUnmanaged)
-            .prepare_async()
-            .run()
-            .await;
-
-        let sum = self
-            .interactor
-            .query()
-            .to(self.state.current_adder_address())
-            .typed(adder_proxy::AdderProxy)
-            .sum()
-            .returns(ReturnsResultUnmanaged)
-            .prepare_async()
-            .run()
-            .await;
-        assert_eq!(sum, RustBigUint::from(new_value));
+    async fn upgrade(
+        &mut self,
+        new_value: u32,
+        sender: &Bech32Address,
+        expected_result: Option<(u64, &str)>,
+    ) {
+        match expected_result {
+            Some((code, msg)) => {
+                let response = self
+                    .interactor
+                    .tx()
+                    .from(sender)
+                    .to(self.state.current_adder_address())
+                    .gas(6_000_000)
+                    .typed(adder_proxy::AdderProxy)
+                    .upgrade(new_value)
+                    .code_metadata(CodeMetadata::UPGRADEABLE)
+                    .code(ADDER_CODE_PATH)
+                    .returns(ExpectError(code, msg))
+                    .prepare_async()
+                    .run()
+                    .await;
+
+                println!("response: {response:?}");
+            },
+            None => {
+                self.interactor
+                    .tx()
+                    .from(sender)
+                    .to(self.state.current_adder_address())
+                    .gas(6_000_000)
+                    .typed(adder_proxy::AdderProxy)
+                    .upgrade(new_value)
+                    .code_metadata(CodeMetadata::UPGRADEABLE)
+                    .code(ADDER_CODE_PATH)
+                    .prepare_async()
+                    .run()
+                    .await;
 
-        println!("response: {response:?}");
+                let sum = self
+                    .interactor
+                    .query()
+                    .to(self.state.current_adder_address())
+                    .typed(adder_proxy::AdderProxy)
+                    .sum()
+                    .returns(ReturnsResultUnmanaged)
+                    .prepare_async()
+                    .run()
+                    .await;
+
+                assert_eq!(sum, RustBigUint::from(new_value));
+            },
+        }
     }
 }
 
 #[tokio::test]
 #[ignore = "run on demand"]
-async fn test() {
+async fn upgrade_test() {
     let mut basic_interact = AdderInteract::init().await;
+    let wallet_address = basic_interact.wallet_address.clone();
+    let adder_owner_address = basic_interact.adder_owner_address.clone();
+    let error_not_owner = (4, "upgrade is allowed only for owner");
 
     basic_interact.deploy().await;
     basic_interact.add(1u32).await;
 
-    basic_interact.upgrade(7u32).await;
+    // Sum will be 1
+    basic_interact.print_sum().await;
+
+    basic_interact
+        .upgrade(7u32, &adder_owner_address, None)
+        .await;
+
+    // Sum will be the updated value of 7
+    basic_interact.print_sum().await;
+
+    basic_interact
+        .upgrade(10u32, &wallet_address, Some(error_not_owner))
+        .await;
+
+    // Sum will remain 7
+    basic_interact.print_sum().await;
 }

framework/snippets/src/imports.rs

@@ -4,7 +4,10 @@ pub use crate::{
     dns_address_for_name, test_wallets, Interactor, InteractorPrepareAsync, StepBuffer,
 };
 
-pub use multiversx_sdk::wallet::Wallet;
+pub use multiversx_sdk::{
+    wallet::Wallet,
+    data::keystore::InsertPassword,
+};
 
 pub use env_logger;
 pub use tokio;

sdk/core/src/data/keystore.rs

@@ -12,6 +12,13 @@ pub enum WalletError {
     InvalidKdf,
     InvalidCipher,
 }
+
+#[derive(Debug)]
+pub enum InsertPassword {
+    Plaintext(String),
+    StandardInput,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct CryptoParams {
     pub iv: String,

sdk/core/src/wallet.rs

@@ -156,13 +156,24 @@ impl Wallet {
         (private_key_str, public_key_str)
     }
 
-    pub fn from_keystore_secret(file_path: &str, password: &str) -> Result<Self> {
-        let decyption_params = Self::validate_keystore_password(file_path, password.to_string())
-            .unwrap_or_else(|e| {
-                panic!("Error: {:?}", e);
-            });
+    pub fn from_keystore_secret(file_path: &str, insert_password: InsertPassword) -> Result<Self> {
+        let decryption_params = match insert_password {
+            InsertPassword::Plaintext(password) => {
+                Self::validate_keystore_password(file_path, password.to_string()).unwrap_or_else(
+                    |e| {
+                        panic!("Error: {:?}", e);
+                    },
+                )
+            },
+            InsertPassword::StandardInput => {
+                Self::validate_keystore_password(file_path, Self::get_keystore_password())
+                    .unwrap_or_else(|e| {
+                        panic!("Error: {:?}", e);
+                    })
+            },
+        };
         let priv_key = PrivateKey::from_hex_str(
-            hex::encode(Self::decrypt_secret_key(decyption_params)).as_str(),
+            hex::encode(Self::decrypt_secret_key(decryption_params)).as_str(),
         )?;
         Ok(Self { priv_key })
     }