use gas params from toml files

Author: soaresa

src/chains/osmosis/osmosis_pool_service.rs

@@ -11,6 +11,9 @@ use super::osmosis_transaction::broadcast_tx;
 use osmosis_std::types::osmosis::gamm::v1beta1::{MsgSwapExactAmountOut, SwapAmountOutRoute, MsgSwapExactAmountIn, SwapAmountInRoute};
 use osmosis_std::types::cosmos::base::v1beta1::Coin as OsmosisCoin;
 
+use serde_json::json;
+use cosmrs::proto::cosmos::tx::v1beta1::{SimulateRequest, SimulateResponse};
+
 use cosmrs::tendermint::{block::Height, chain::Id};
 use cosmrs::tx::{Body, Fee, AuthInfo, SignDoc, Tx};
 use cosmrs::Any;
@@ -22,6 +25,46 @@ use prost::Message;
 
 use reqwest::Client;
 
+// TODO: WIP Function to simulate a transaction cost
+pub async fn simulate_tx(tx: Tx) -> Result<()> {
+    // Step 1: Encode the transaction into the protobuf format
+    let proto_tx: cosmrs::proto::cosmos::tx::v1beta1::Tx = tx.into();
+    let mut tx_bytes = Vec::new();
+    proto_tx.encode(&mut tx_bytes).map_err(|e| anyhow::anyhow!("Failed to encode Tx: {}", e))?;
+
+    // Step 2: Convert the tx bytes to Base64
+    let tx_base64 = base64::encode(&tx_bytes);
+
+    // Step 3: Prepare the request body
+    let simulate_body = json!({
+        "tx_bytes": tx_base64
+    });
+
+    // Step 4: Make the request to the simulate endpoint
+    let client = Client::new();
+    let simulate_url = "https://lcd.osmotest5.osmosis.zone/cosmos/tx/v1beta1/simulate".to_string();
+    let response = client
+        .post(simulate_url)
+        .json(&simulate_body)
+        .send()
+        .await?;
+
+    // Step 5: Parse the response
+    let response_json = response.json::<serde_json::Value>().await.map_err(|e| anyhow::anyhow!("Failed to parse response: {}", e))?;
+
+    // Step 6: Extract relevant data
+    if let Some(simulate_response) = response_json.get("gas_info") {
+        let gas_used = simulate_response["gas_used"].as_str();
+        let gas_wanted = simulate_response["gas_wanted"].as_str();
+
+        println!("Gas Used: {:?}, Gas Wanted: {:?}", gas_used, gas_wanted);
+    } else {
+        println!("Failed to get gas info from response: {:?}", response_json);
+    }
+
+    Ok(())
+}
+
 pub async fn perform_swap(
     signer: &Signer,
     pool_id: u64,
@@ -44,7 +87,7 @@ pub async fn perform_swap(
 
     // Step 3. Get the current block height
     let current_height = get_current_block_height().await.map_err(|e| anyhow::anyhow!("Failed to get current block height: {}", e))?;
-    let timeout_height = current_height + 1000;  // Set a future timeout height
+    let timeout_height = current_height + 200;  // Set a future timeout height
 
     // Step 4. Create TxBody
     let tx_body = Body {
@@ -62,8 +105,8 @@ pub async fn perform_swap(
     // Step 6: Create AuthInfo with fee details
     let fee = Fee::from_amount_and_gas(CosmosCoin {
         denom: "uosmo".parse().unwrap(),
-        amount: Decimal::from(320_000u64),
-    }, 350_000);
+        amount: Decimal::from(CONFIG.gas_config.amount),
+    }, CONFIG.gas_config.gas_limit);
     let auth_info = AuthInfo {
         signer_infos: vec![signer_info],
         fee,
@@ -77,6 +120,7 @@ pub async fn perform_swap(
 
     // Step 8: Create and broadcast the transaction
     let tx_parsed = Tx::from_bytes(&tx_bytes).map_err(|e| anyhow::anyhow!("Failed to parse transaction bytes: {}", e))?;
+    // simulate_tx(tx_parsed.clone()).await?;
     broadcast_tx(tx_parsed, sender_address, pool_id, coin_in, coin_out, amount, swap_type, min_price).await
 }
 

src/chains/osmosis/osmosis_transaction.rs

@@ -14,7 +14,7 @@ use regex::Regex;
 use cosmrs::tx::Tx;
 use prost::Message;
 use crate::utils::format_token_amount_with_denom;
-use log::{info, error, warn};
+use log::{info, error, warn, debug};
 
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -53,7 +53,7 @@ pub async fn broadcast_tx(
     let broadcast_url = get_osmosis_broadcast_tx_url();
     let broadcast_body = json!({
         "tx_bytes": tx_base64,
-        "mode": 2
+        "mode": "BROADCAST_MODE_ASYNC"
     });
     let response = client.post(broadcast_url)
         .json(&broadcast_body)
@@ -71,8 +71,14 @@ pub async fn broadcast_tx(
     info!(">>> Transaction broadcasted");
 
     // Store the broadcasted transaction
-    let txhash = response_json["tx_response"]["txhash"].as_str().unwrap();
-    let code = response_json["tx_response"]["code"].as_u64();
+    let txhash = match response_json["tx_response"]["txhash"].as_str() {
+        Some(hash) => hash,
+        None => return Err(anyhow::anyhow!("Failed to get txhash from response")),
+    };    
+    let code = match response_json["tx_response"]["code"].as_u64() {
+        Some(code) => Some(code),
+        None => return Err(anyhow::anyhow!("Failed to get code from response")),
+    };
     let raw_log = response_json["tx_response"]["raw_log"].as_str().map(String::from);
     let _ = store_broadcasted_transaction(
         sender_address,
@@ -272,7 +278,7 @@ async fn poll_transaction_status(txhash: &str, account_id: &str) -> Result<Optio
             Ok((code, raw_log, gas_used, tokens_in, tokens_out)) => {
                 if code.is_some() {
                     // Transaction was executed
-                    update_transaction_status(txhash, account_id, "executed", code, raw_log, gas_used, tokens_in, tokens_out).await?;
+                    update_transaction(txhash, account_id, "executed", code, raw_log, gas_used, tokens_in, tokens_out).await?;
                     return Ok(code);
                 } else {
                     info!("... Transaction not yet confirmed");
@@ -290,8 +296,8 @@ async fn poll_transaction_status(txhash: &str, account_id: &str) -> Result<Optio
 }
 
 
-// Function to update the transaction status in the JSON file
-async fn update_transaction_status(
+// Function to update the transaction details in the JSON file
+async fn update_transaction(
     txhash: &str,
     account_id: &str,
     status: &str,
@@ -320,6 +326,8 @@ async fn update_transaction_status(
             transaction["tokens_in"] = json!(tokens_in);
             transaction["tokens_out"] = json!(tokens_out);
 
+            debug!("update_transaction: {}", transaction);
+
             // Write the updated transactions back to the file
             fs::write(file_path, serde_json::to_string_pretty(&transactions)?)?;
         }
@@ -331,7 +339,7 @@ async fn update_transaction_status(
 // Function to handle timeout scenario
 async fn update_transaction_with_timeout(txhash: &str) -> Result<(), Box<dyn std::error::Error>> {
     // Implement your logic to update the transaction with timeout error here
-    update_transaction_status(txhash, "account_id", "timeout", None, None, None, None, None).await?;
+    update_transaction(txhash, "account_id", "timeout", None, None, None, None, None).await?;
     Ok(())
 }
 

src/config/prod.toml

@@ -8,8 +8,8 @@ osmosis_tx_details_url = "https://lcd.osmosis.zone/cosmos/tx/v1beta1/txs/{}"
 
 [gas_config]
 token = "OSMO"
-amount = 320000
-gas_limit = 350000
+amount = 50_000
+gas_limit = 300_000
 
 [env_constants]
 pool_id = 1721

src/config/test.toml

@@ -8,8 +8,8 @@ osmosis_tx_details_url = "https://lcd.osmotest5.osmosis.zone/cosmos/tx/v1beta1/t
 
 [gas_config]
 token = "TOSMO"
-amount = 320_000
-gas_limit = 350_000
+amount = 50_000
+gas_limit = 250_00
 
 [env_constants]
 pool_id = 15