Interactor gas price, dex-interactor refactor

contracts/feature-tests/composability/forwarder-blind/dex-interactor/Cargo.toml

@@ -7,10 +7,10 @@ publish = false
 
 [[bin]]
 name = "forwarder-blind-dex-interactor"
-path = "src/interactor_main.rs"
+path = "src/dex_interactor_main.rs"
 
 [lib]
-path = "src/interact.rs"
+path = "src/dex_interactor.rs"
 
 [dependencies.forwarder-blind]
 path = ".."

contracts/feature-tests/composability/forwarder-blind/dex-interactor/src/interact.rs → contracts/feature-tests/composability/forwarder-blind/dex-interactor/src/dex_interactor.rs

@@ -1,10 +1,11 @@
 mod config;
-mod interact_cli;
+mod dex_interactor_cli;
 pub mod proxies;
 mod state;
 
 use clap::Parser;
 pub use config::Config;
+use dex_interactor_cli as cli;
 use multiversx_sc_snippets::imports::*;
 use proxies::*;
 use state::State;
@@ -17,78 +18,78 @@ pub async fn forwarder_blind_cli() {
     let config = Config::load_config();
     let mut interact = ContractInteract::new(config).await;
 
-    let cli = interact_cli::InteractCli::parse();
+    let cli = cli::InteractCli::parse();
     match &cli.command {
-        Some(interact_cli::InteractCliCommand::Deploy) => {
+        Some(cli::InteractCliCommand::Deploy) => {
             interact.deploy().await;
         }
-        Some(interact_cli::InteractCliCommand::WrapEgld(args)) => {
+        Some(cli::InteractCliCommand::WrapEgld(args)) => {
             interact.wrap_egld(args.amount).await;
         }
-        Some(interact_cli::InteractCliCommand::Swap1(args)) => match &args.method {
-            interact_cli::SwapWegldForUsdcMethod::Direct(args) => {
+        Some(cli::InteractCliCommand::Swap1(args)) => match &args.method {
+            cli::SwapWegldForUsdcMethod::Direct(args) => {
                 interact
                     .swap1_direct(args.wegld_amount, args.usdc_amount_min)
                     .await;
             }
-            interact_cli::SwapWegldForUsdcMethod::Sync(args) => {
+            cli::SwapWegldForUsdcMethod::Sync(args) => {
                 interact
                     .swap1_sync(args.wegld_amount, args.usdc_amount_min)
                     .await;
             }
-            interact_cli::SwapWegldForUsdcMethod::Async1(args) => {
+            cli::SwapWegldForUsdcMethod::Async1(args) => {
                 interact
                     .swap1_async1(args.wegld_amount, args.usdc_amount_min)
                     .await;
             }
-            interact_cli::SwapWegldForUsdcMethod::Async2(args) => {
+            cli::SwapWegldForUsdcMethod::Async2(args) => {
                 interact
                     .swap1_async2(args.wegld_amount, args.usdc_amount_min)
                     .await;
             }
-            interact_cli::SwapWegldForUsdcMethod::Te(args) => {
+            cli::SwapWegldForUsdcMethod::Te(args) => {
                 interact
                     .swap1_te(args.wegld_amount, args.usdc_amount_min)
                     .await;
             }
         },
-        Some(interact_cli::InteractCliCommand::Swap2(args)) => match &args.method {
-            interact_cli::SwapUsdcForWegldMethod::Direct(args) => {
+        Some(cli::InteractCliCommand::Swap2(args)) => match &args.method {
+            cli::SwapUsdcForWegldMethod::Direct(args) => {
                 interact
                     .swap2_direct(args.usdc_amount, args.wegld_amount_min)
                     .await;
             }
-            interact_cli::SwapUsdcForWegldMethod::Sync(args) => {
+            cli::SwapUsdcForWegldMethod::Sync(args) => {
                 interact
                     .swap2_sync(args.usdc_amount, args.wegld_amount_min)
                     .await;
             }
-            interact_cli::SwapUsdcForWegldMethod::Async1(args) => {
+            cli::SwapUsdcForWegldMethod::Async1(args) => {
                 interact
                     .swap2_async1(args.usdc_amount, args.wegld_amount_min)
                     .await;
             }
-            interact_cli::SwapUsdcForWegldMethod::Async2(args) => {
+            cli::SwapUsdcForWegldMethod::Async2(args) => {
                 interact
                     .swap2_async2(args.usdc_amount, args.wegld_amount_min)
                     .await;
             }
-            interact_cli::SwapUsdcForWegldMethod::Te(args) => {
+            cli::SwapUsdcForWegldMethod::Te(args) => {
                 interact
                     .swap2_te(args.usdc_amount, args.wegld_amount_min)
                     .await;
             }
         },
-        Some(interact_cli::InteractCliCommand::GetRate(args)) => {
+        Some(cli::InteractCliCommand::GetRate(args)) => {
             interact.get_rate(args.wegld_amount).await;
         }
-        Some(interact_cli::InteractCliCommand::GetLiquidity) => {
+        Some(cli::InteractCliCommand::GetLiquidity) => {
             interact.get_liquidity().await;
         }
-        Some(interact_cli::InteractCliCommand::Drain) => {
+        Some(cli::InteractCliCommand::Drain) => {
             interact.drain().await;
         }
-        Some(interact_cli::InteractCliCommand::Balances) => {
+        Some(cli::InteractCliCommand::Balances) => {
             interact.balances().await;
         }
         None => {}
@@ -112,9 +113,8 @@ pub struct ContractInteract {
 
 impl ContractInteract {
     pub async fn new(config: Config) -> Self {
-        let mut interactor = Interactor::new(config.gateway_uri())
-            .await
-            .use_chain_simulator(config.use_chain_simulator());
+        let mut interactor = Interactor::new(config.gateway_uri()).await;
+        interactor.gas_price *= 25;
         interactor.set_current_dir_from_workspace(
             "contracts/feature-tests/composability/forwarder-blind/dex-interactor",
         );

framework/snippets/src/interactor/interactor_base.rs

@@ -27,6 +27,7 @@ where
     pub use_chain_simulator: bool,
     pub network_config: NetworkConfig,
     pub sender_map: HashMap<Address, Sender>,
+    pub gas_price: u64,
 
     pub waiting_time_ms: u64,
     pub pre_runners: ScenarioRunnerList,
@@ -42,7 +43,11 @@ where
     /// Not yet changed for backwards compatibility.
     pub async fn new(gateway_uri: &str) -> Self {
         let proxy = GatewayProxy::from_uri(gateway_uri);
-        let network_config = proxy.request(NetworkConfigRequest).await.unwrap();
+        let network_config = proxy
+            .request(NetworkConfigRequest)
+            .await
+            .expect("could not get network config");
+        let gas_price = network_config.min_gas_price;
         Self {
             proxy,
             use_chain_simulator: false,
@@ -52,6 +57,7 @@ where
             pre_runners: ScenarioRunnerList::empty(),
             post_runners: ScenarioRunnerList::empty(),
             current_dir: PathBuf::default(),
+            gas_price,
         }
     }
 

framework/snippets/src/interactor/interactor_scenario/interactor_sc_call.rs

@@ -122,7 +122,7 @@ where
             value: normalized.egld_value.value.to_string(),
             sender: Bech32Address::encode_address(hrp, normalized.from.to_address()),
             receiver: Bech32Address::encode_address(hrp, normalized.to.to_address()),
-            gas_price: self.network_config.min_gas_price,
+            gas_price: self.gas_price,
             gas_limit: normalized.gas_limit.value,
             data,
             signature: None,

framework/snippets/src/interactor/interactor_scenario/interactor_sc_deploy.rs

@@ -27,7 +27,7 @@ where
             value: sc_deploy_step.tx.egld_value.value.to_string(),
             sender: sc_deploy_step.tx.from.to_address().to_bech32(&hrp),
             receiver: Bech32Address::zero(&hrp),
-            gas_price: self.network_config.min_gas_price,
+            gas_price: self.gas_price,
             gas_limit: sc_deploy_step.tx.gas_limit.value,
             data: Some(base64_encode(sc_deploy_step.tx.to_tx_data())),
             signature: None,