diff --git a/.github/workflows/cache.yml b/.github/workflows/cache.yml new file mode 100644 index 000000000..4e5f20f1d --- /dev/null +++ b/.github/workflows/cache.yml @@ -0,0 +1,30 @@ +name: Clear cache + +on: + workflow_dispatch: + +permissions: + actions: write + +jobs: + clear-cache: + runs-on: ubuntu-latest + steps: + - name: Clear cache + uses: actions/github-script@v7 + with: + script: | + console.log("About to clear") + const caches = await github.rest.actions.getActionsCacheList({ + owner: context.repo.owner, + repo: context.repo.repo, + }) + for (const cache of caches.data.actions_caches) { + console.log(cache) + github.rest.actions.deleteActionsCacheById({ + owner: context.repo.owner, + repo: context.repo.repo, + cache_id: cache.id, + }) + } + console.log("Clear completed") \ No newline at end of file diff --git a/orm/migrations/2025-01-27-130323_gas_estimation_ibc/down.sql b/orm/migrations/2025-01-27-130323_gas_estimation_ibc/down.sql new file mode 100644 index 000000000..611bcd342 --- /dev/null +++ b/orm/migrations/2025-01-27-130323_gas_estimation_ibc/down.sql @@ -0,0 +1,4 @@ +-- This file should undo anything in `up.sql` +ALTER TABLE gas_estimations DROP COLUMN ibc_unshielding_transfer; +ALTER TABLE gas_estimations DROP COLUMN ibc_shielding_transfer; +ALTER TABLE gas_estimations DROP COLUMN token; \ No newline at end of file diff --git a/orm/migrations/2025-01-27-130323_gas_estimation_ibc/up.sql b/orm/migrations/2025-01-27-130323_gas_estimation_ibc/up.sql new file mode 100644 index 000000000..682a65609 --- /dev/null +++ b/orm/migrations/2025-01-27-130323_gas_estimation_ibc/up.sql @@ -0,0 +1,11 @@ +-- Your SQL goes here +ALTER TABLE gas_estimations ADD COLUMN ibc_unshielding_transfer INT NOT NULL DEFAULT 0; +ALTER TABLE gas_estimations ADD COLUMN ibc_shielding_transfer INT NOT NULL DEFAULT 0; + +ALTER TABLE gas_estimations ADD COLUMN token VARCHAR; + +UPDATE gas_estimations +SET token = (SELECT address FROM "token" WHERE token_type = 'native' LIMIT 1) +WHERE token IS NULL; + +ALTER TABLE gas_estimations ALTER COLUMN token SET NOT NULL; \ No newline at end of file diff --git a/orm/src/gas.rs b/orm/src/gas.rs index a32257a35..349cfbc6d 100644 --- a/orm/src/gas.rs +++ b/orm/src/gas.rs @@ -42,6 +42,8 @@ pub struct GasEstimationDb { pub shielded_transfer: i32, pub shielding_transfer: i32, pub unshielding_transfer: i32, + pub ibc_unshielding_transfer: i32, + pub ibc_shielding_transfer: i32, pub ibc_msg_transfer: i32, pub bond: i32, pub redelegation: i32, @@ -52,6 +54,7 @@ pub struct GasEstimationDb { pub reveal_pk: i32, pub signatures: i32, pub tx_size: i32, + pub token: String, } pub type GasEstimationInsertDb = GasEstimationDb; @@ -65,6 +68,8 @@ impl From for GasEstimationInsertDb { shielding_transfer: value.shielding_transfer as i32, unshielding_transfer: value.unshielding_transfer as i32, ibc_msg_transfer: value.ibc_msg_transfer as i32, + ibc_unshielding_transfer: value.ibc_unshielding_transfer as i32, + ibc_shielding_transfer: value.ibc_shielding_transfer as i32, bond: value.bond as i32, redelegation: value.redelegation as i32, unbond: value.unbond as i32, @@ -74,6 +79,7 @@ impl From for GasEstimationInsertDb { reveal_pk: value.reveal_pk as i32, signatures: value.signatures as i32, tx_size: value.size as i32, + token: value.token.to_string(), } } } diff --git a/orm/src/schema.rs b/orm/src/schema.rs index 38a7d1217..f35d8c751 100644 --- a/orm/src/schema.rs +++ b/orm/src/schema.rs @@ -38,32 +38,32 @@ pub mod sql_types { std::fmt::Debug, diesel::sql_types::SqlType, )] - #[diesel(postgres_type(name = "payment_kind"))] - pub struct PaymentKind; + #[diesel(postgres_type(name = "history_kind"))] + pub struct HistoryKind; #[derive( diesel::query_builder::QueryId, std::fmt::Debug, diesel::sql_types::SqlType, )] - #[diesel(postgres_type(name = "payment_recurrence"))] - pub struct PaymentRecurrence; + #[diesel(postgres_type(name = "ibc_status"))] + pub struct IbcStatus; #[derive( diesel::query_builder::QueryId, std::fmt::Debug, diesel::sql_types::SqlType, )] - #[diesel(postgres_type(name = "history_kind"))] - pub struct HistoryKind; + #[diesel(postgres_type(name = "payment_kind"))] + pub struct PaymentKind; #[derive( diesel::query_builder::QueryId, std::fmt::Debug, diesel::sql_types::SqlType, )] - #[diesel(postgres_type(name = "ibc_status"))] - pub struct IbcStatus; + #[diesel(postgres_type(name = "payment_recurrence"))] + pub struct PaymentRecurrence; #[derive( diesel::query_builder::QueryId, @@ -202,6 +202,9 @@ diesel::table! { reveal_pk -> Int4, tx_size -> Int4, signatures -> Int4, + ibc_unshielding_transfer -> Int4, + ibc_shielding_transfer -> Int4, + token -> Varchar, } } diff --git a/shared/src/block.rs b/shared/src/block.rs index fa9e35565..c0033fd62 100644 --- a/shared/src/block.rs +++ b/shared/src/block.rs @@ -18,6 +18,7 @@ use crate::header::BlockHeader; use crate::id::Id; use crate::proposal::{GovernanceProposal, GovernanceProposalKind}; use crate::public_key::PublicKey; +use crate::ser; use crate::token::{IbcToken, Token}; use crate::transaction::{ InnerTransaction, Transaction, TransactionExitStatus, TransactionKind, @@ -941,47 +942,61 @@ impl Block { ) -> Option> { let change = match &tx.kind { TransactionKind::IbcMsgTransfer(data) => { - let data = data.clone().and_then(|d| { - Self::ibc_msg_recv_packet(d.0).and_then(|msg| { - serde_json::from_slice::(&msg.packet.data) - .map(|p| (msg, p)) - .ok() - }) - }); - - let (msg, packet_data) = data?; - let denom = packet_data.token.denom.to_string(); + Self::parse_ibc_tx_balances(data, native_token) + .unwrap_or_default() + } + TransactionKind::ShieldedTransfer(data) => { + let data = data.as_ref()?; - let ibc_trace = format!( - "{}/{}/{}", - msg.packet.port_id_on_b, - msg.packet.chan_id_on_b, - packet_data.token.denom - ); + [&data.sources] + .iter() + .flat_map(|transfer_changes| { + transfer_changes.0.keys().map(|account| { + BalanceChange::new( + Id::from(account.owner.clone()), + Token::Native(Id::from(account.token.clone())), + ) + }) + }) + .collect() + } + TransactionKind::UnshieldingTransfer(data) => { + let data = data.as_ref()?; - let trace = Id::IbcTrace(ibc_trace.clone()); - let address = namada_ibc::trace::convert_to_address(ibc_trace) - .expect("Failed to convert IBC trace to address"); + [&data.targets] + .iter() + .flat_map(|transfer_changes| { + transfer_changes.0.keys().map(|account| { + BalanceChange::new( + Id::from(account.owner.clone()), + Token::Native(Id::from(account.token.clone())), + ) + }) + }) + .collect() + } + TransactionKind::MixedTransfer(data) => { + let data = data.as_ref()?; - let mut balances = vec![BalanceChange::new( - Id::Account(String::from(packet_data.receiver.as_ref())), - Token::Ibc(IbcToken { - address: Id::from(address.clone()), - trace, - }), - )]; - - // If the denom contains the namada native token, try to fetch - // the balance - if denom.contains(&native_token.to_string()) { - balances.push(BalanceChange::new( - Id::Account(String::from( - packet_data.receiver.as_ref(), - )), - Token::Native(native_token.clone()), - )) - } - balances + [&data.sources, &data.targets] + .iter() + .flat_map(|transfer_changes| { + transfer_changes.0.keys().map(|account| { + BalanceChange::new( + Id::from(account.owner.clone()), + Token::Native(Id::from(account.token.clone())), + ) + }) + }) + .collect() + } + TransactionKind::IbcShieldingTransfer((data, _)) => { + Self::parse_ibc_tx_balances(data, native_token) + .unwrap_or_default() + } + TransactionKind::IbcUnshieldingTransfer((data, _)) => { + Self::parse_ibc_tx_balances(data, native_token) + .unwrap_or_default() } TransactionKind::TransparentTransfer(data) => { let data = data.as_ref()?; @@ -1317,4 +1332,50 @@ impl Block { }) .collect() } + + fn parse_ibc_tx_balances( + data: &Option>, + native_token: &Id, + ) -> Option> { + // IbcShieldingTransfer((Option>, TransferData)), + let data = data.clone().and_then(|d| { + Self::ibc_msg_recv_packet(d.0).and_then(|msg| { + serde_json::from_slice::(&msg.packet.data) + .map(|p| (msg, p)) + .ok() + }) + }); + + let (msg, packet_data) = data?; + let denom = packet_data.token.denom.to_string(); + + let ibc_trace = format!( + "{}/{}/{}", + msg.packet.port_id_on_b, + msg.packet.chan_id_on_b, + packet_data.token.denom + ); + + let trace = Id::IbcTrace(ibc_trace.clone()); + let address = namada_ibc::trace::convert_to_address(ibc_trace) + .expect("Failed to convert IBC trace to address"); + + let mut balances = vec![BalanceChange::new( + Id::Account(String::from(packet_data.receiver.as_ref())), + Token::Ibc(IbcToken { + address: Id::from(address.clone()), + trace, + }), + )]; + + // If the denom contains the namada native token, try to fetch + // the balance + if denom.contains(&native_token.to_string()) { + balances.push(BalanceChange::new( + Id::Account(String::from(packet_data.receiver.as_ref())), + Token::Native(native_token.clone()), + )) + } + Some(balances) + } } diff --git a/shared/src/block_result.rs b/shared/src/block_result.rs index 42d47989a..7ad5e44b6 100644 --- a/shared/src/block_result.rs +++ b/shared/src/block_result.rs @@ -1,6 +1,8 @@ -use std::collections::BTreeMap; +use std::collections::{BTreeMap, HashMap}; +use std::fmt; use std::str::FromStr; +use namada_sdk::events::extend::{IndexedMaspData, MaspTxRef}; use namada_tx::data::TxResult; use tendermint_rpc::endpoint::block_results::Response as TendermintBlockResultResponse; @@ -108,7 +110,7 @@ impl BatchResults { } } -#[derive(Debug, Clone, Default)] +#[derive(Clone)] pub struct TxApplied { pub code: TxEventStatusCode, pub gas: u64, @@ -116,6 +118,27 @@ pub struct TxApplied { pub height: u64, pub batch: BatchResults, pub info: String, + pub masp_refs: HashMap>, +} + +impl fmt::Debug for TxApplied { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("TxApplied") + .field("code", &self.code) + .field("gas", &self.gas) + .field("hash", &self.hash) + .field("height", &self.height) + .field("batch", &self.batch) + .field("info", &self.info) + .field("masp_refs_len", &self.masp_refs.len()) + .finish() + } +} + +#[derive(Debug, Clone)] +pub enum MaspRef { + Native(String), + Ibc(String), } #[derive(Debug, Clone, Default)] @@ -189,6 +212,19 @@ impl TxAttributesType { .map(|height| u64::from_str(height).unwrap()) .unwrap() .to_owned(), + masp_refs: attributes + .get("masp_data_refs") + .map(|data| { + if let Ok(data) = + serde_json::from_str::(data) + { + let refs = data.masp_refs.0.to_vec(); + HashMap::from_iter([(data.tx_index.0 as u64, refs)]) + } else { + HashMap::default() + } + }) + .unwrap_or_default(), batch: attributes .get("batch") .map(|batch_result| { @@ -323,4 +359,23 @@ impl BlockResult { }); exit_status.unwrap_or(TransactionExitStatus::Rejected) } + + pub fn masp_refs(&self, wrapper_hash: &Id, index: u64) -> Vec { + self.end_events + .iter() + .filter_map(|event| { + if let Some(TxAttributesType::TxApplied(data)) = + &event.attributes + { + Some(data.clone()) + } else { + None + } + }) + .find(|attributes| attributes.hash.eq(wrapper_hash)) + .map(|event| { + event.masp_refs.get(&index).cloned().unwrap_or_default() + }) + .unwrap_or_default() + } } diff --git a/shared/src/gas.rs b/shared/src/gas.rs index 6399b683e..3878728bf 100644 --- a/shared/src/gas.rs +++ b/shared/src/gas.rs @@ -27,10 +27,11 @@ pub struct GasEstimation { pub reveal_pk: u64, pub size: u64, pub signatures: u64, + pub token: Id, } impl GasEstimation { - pub fn new(tx_id: Id) -> Self { + pub fn new(tx_id: Id, token: Id) -> Self { Self { wrapper_id: tx_id, transparent_transfer: 0, @@ -50,6 +51,7 @@ impl GasEstimation { reveal_pk: 0, size: 0, signatures: 0, + token, } } @@ -57,28 +59,28 @@ impl GasEstimation { self.transparent_transfer += 1 } - pub fn increase_shielded_transfer(&mut self) { - self.shielded_transfer += 1 + pub fn increase_shielded_transfer(&mut self, notes: u64) { + self.shielded_transfer += notes } - pub fn increase_shielding_transfer(&mut self) { - self.shielding_transfer += 1 + pub fn increase_shielding_transfer(&mut self, notes: u64) { + self.shielding_transfer += notes } - pub fn increase_unshielding_transfer(&mut self) { - self.unshielding_transfer += 1 + pub fn increase_unshielding_transfer(&mut self, notes: u64) { + self.unshielding_transfer += notes } - pub fn increase_mixed_transfer(&mut self) { - self.mixed_transfer += 1 + pub fn increase_mixed_transfer(&mut self, notes: u64) { + self.mixed_transfer += notes } - pub fn increase_ibc_shielding_transfer(&mut self) { - self.ibc_shielding_transfer += 1 + pub fn increase_ibc_shielding_transfer(&mut self, notes: u64) { + self.ibc_shielding_transfer += notes } - pub fn increase_ibc_unshielding_transfer(&mut self) { - self.ibc_unshielding_transfer += 1 + pub fn increase_ibc_unshielding_transfer(&mut self, notes: u64) { + self.ibc_unshielding_transfer += notes } pub fn increase_ibc_msg_transfer(&mut self) { diff --git a/shared/src/transaction.rs b/shared/src/transaction.rs index 4d27b4fa9..a205f8602 100644 --- a/shared/src/transaction.rs +++ b/shared/src/transaction.rs @@ -4,6 +4,7 @@ use std::fmt::Display; use namada_governance::{InitProposalData, VoteProposalData}; use namada_sdk::address::Address; use namada_sdk::borsh::BorshDeserialize; +use namada_sdk::events::extend::MaspTxRef; use namada_sdk::key::common::PublicKey; use namada_sdk::token::Transfer; use namada_sdk::uint::Uint; @@ -116,20 +117,11 @@ impl TransactionKind { } } "tx_bond" => { - let data = if let Ok(data) = Bond::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = Bond::try_from_slice(data).ok(); TransactionKind::Bond(data) } "tx_redelegate" => { - let data = if let Ok(data) = Redelegation::try_from_slice(data) - { - Some(data) - } else { - None - }; + let data = Redelegation::try_from_slice(data).ok(); TransactionKind::Redelegation(data) } "tx_unbond" => { @@ -141,56 +133,27 @@ impl TransactionKind { TransactionKind::Unbond(data) } "tx_withdraw" => { - let data = if let Ok(data) = Withdraw::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = Withdraw::try_from_slice(data).ok(); TransactionKind::Withdraw(data) } "tx_claim_rewards" => { - let data = if let Ok(data) = ClaimRewards::try_from_slice(data) - { - Some(data) - } else { - None - }; + let data = ClaimRewards::try_from_slice(data).ok(); TransactionKind::ClaimRewards(data) } "tx_init_proposal" => { - let data = - if let Ok(data) = InitProposalData::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = InitProposalData::try_from_slice(data).ok(); TransactionKind::InitProposal(data) } "tx_vote_proposal" => { - let data = - if let Ok(data) = VoteProposalData::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = VoteProposalData::try_from_slice(data).ok(); TransactionKind::ProposalVote(data) } "tx_change_validator_metadata" => { - let data = - if let Ok(data) = MetaDataChange::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = MetaDataChange::try_from_slice(data).ok(); TransactionKind::MetadataChange(data) } "tx_commission_change" => { - let data = - if let Ok(data) = CommissionChange::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = CommissionChange::try_from_slice(data).ok(); TransactionKind::CommissionChange(data) } "tx_reveal_pk" => { @@ -202,19 +165,11 @@ impl TransactionKind { TransactionKind::RevealPk(data) } "tx_deactivate_validator" => { - let data = if let Ok(data) = Address::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = Address::try_from_slice(data).ok(); TransactionKind::DeactivateValidator(data) } "tx_reactivate_validator" => { - let data = if let Ok(data) = Address::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = Address::try_from_slice(data).ok(); TransactionKind::ReactivateValidator(data) } "tx_ibc" => { @@ -252,20 +207,11 @@ impl TransactionKind { } } "tx_unjail_validator" => { - let data = if let Ok(data) = Address::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = Address::try_from_slice(data).ok(); TransactionKind::UnjailValidator(data) } "tx_become_validator" => { - let data = - if let Ok(data) = BecomeValidator::try_from_slice(data) { - Some(data) - } else { - None - }; + let data = BecomeValidator::try_from_slice(data).ok(); TransactionKind::BecomeValidator(data.map(Box::new)) } _ => { @@ -315,6 +261,11 @@ pub struct Transaction { pub fee: Fee, } +#[derive(Debug, Clone)] +pub struct MaspSectionData { + pub total_notes: u64, +} + #[derive(Debug, Clone)] pub struct WrapperTransaction { pub tx_id: Id, @@ -336,6 +287,7 @@ pub struct InnerTransaction { pub memo: Option, pub data: Option, pub extra_sections: HashMap>, + pub notes: u64, pub exit_code: TransactionExitStatus, } @@ -395,6 +347,8 @@ impl Transaction { let gas_used = block_results .gas_used(&wrapper_tx_id) .map(|gas| gas.parse::().unwrap()); + let masp_refs = + block_results.masp_refs(&wrapper_tx_id, index as u64); let fee = Fee { gas: Uint::from(wrapper.gas_limit).to_string(), @@ -504,6 +458,28 @@ impl Transaction { acc }); + let notes = masp_refs.clone().into_iter().map(|masp_ref| { + match masp_ref { + MaspTxRef::MaspSection(masp_tx_id) => { + transaction + .get_masp_section(&masp_tx_id) + .map(|bundle| bundle.clone().into_data().sapling_bundle().map(|bundle| bundle.shielded_spends.len() + bundle.shielded_outputs.len()).unwrap_or_default()).unwrap_or_default() as u64 + }, + MaspTxRef::IbcData(hash) => { + transaction.get_data_section(&hash).map(|section| match namada_sdk::ibc::decode_message::(§ion) { + Ok(namada_ibc::IbcMessage::Envelope(msg_envelope)) => { + if let Some(bundle) = namada_sdk::ibc::extract_masp_tx_from_envelope(&msg_envelope) { + bundle.clone().into_data().sapling_bundle().map(|bundle| bundle.shielded_spends.len() + bundle.shielded_outputs.len()).unwrap_or_default() as u64 + } else { + 0 + } + }, + _ => 0, + }).unwrap_or_default() + }, + } + }).sum::(); + let inner_tx = InnerTransaction { tx_id: inner_tx_id, index, @@ -511,6 +487,7 @@ impl Transaction { memo, data: encoded_tx_data, extra_sections, + notes, exit_code: inner_tx_status, kind: tx_kind, }; diff --git a/transactions/src/services/tx.rs b/transactions/src/services/tx.rs index 2c534a2dc..d8445b946 100644 --- a/transactions/src/services/tx.rs +++ b/transactions/src/services/tx.rs @@ -117,7 +117,10 @@ pub fn get_gas_estimates( wrapper_txs .iter() .map(|wrapper_tx| { - let mut gas_estimate = GasEstimation::new(wrapper_tx.tx_id.clone()); + let mut gas_estimate = GasEstimation::new( + wrapper_tx.tx_id.clone(), + wrapper_tx.fee.gas_token.clone(), + ); gas_estimate.signatures = wrapper_tx.total_signatures; gas_estimate.size = wrapper_tx.size; @@ -128,9 +131,12 @@ pub fn get_gas_estimates( && inner_tx.wrapper_id.eq(&wrapper_tx.tx_id) }) .for_each(|tx| match tx.kind { - TransactionKind::TransparentTransfer(_) - | TransactionKind::MixedTransfer(_) => { - gas_estimate.increase_mixed_transfer() + TransactionKind::TransparentTransfer(_) => { + gas_estimate.increase_transparent_transfer(); + } + TransactionKind::MixedTransfer(_) => { + let notes = tx.notes; + gas_estimate.increase_mixed_transfer(notes) } TransactionKind::IbcMsgTransfer(_) => { gas_estimate.increase_ibc_msg_transfer() @@ -155,16 +161,24 @@ pub fn get_gas_estimates( gas_estimate.increase_reveal_pk() } TransactionKind::ShieldedTransfer(_) => { - gas_estimate.increase_shielded_transfer() + let notes = tx.notes; + gas_estimate.increase_shielded_transfer(notes); } TransactionKind::ShieldingTransfer(_) => { - gas_estimate.increase_shielding_transfer() + let notes = tx.notes; + gas_estimate.increase_shielding_transfer(notes) } TransactionKind::UnshieldingTransfer(_) => { - gas_estimate.increase_ibc_unshielding_transfer() + let notes = tx.notes; + gas_estimate.increase_unshielding_transfer(notes) } TransactionKind::IbcShieldingTransfer(_) => { - gas_estimate.increase_ibc_shielding_transfer() + let notes = tx.notes; + gas_estimate.increase_ibc_shielding_transfer(notes) + } + TransactionKind::IbcUnshieldingTransfer(_) => { + let notes = tx.notes; + gas_estimate.increase_ibc_unshielding_transfer(notes) } _ => (), }); diff --git a/webserver/src/dto/gas.rs b/webserver/src/dto/gas.rs index 24e75770e..b1b66f51e 100644 --- a/webserver/src/dto/gas.rs +++ b/webserver/src/dto/gas.rs @@ -20,6 +20,10 @@ pub struct GasEstimateQuery { #[validate(range(min = 1, max = 100))] pub unshielding_transfer: Option, #[validate(range(min = 1, max = 100))] + pub ibc_shielding_transfer: Option, + #[validate(range(min = 1, max = 100))] + pub ibc_unshielding_transfer: Option, + #[validate(range(min = 1, max = 100))] pub vote: Option, #[validate(range(min = 1, max = 100))] pub ibc: Option, @@ -33,6 +37,7 @@ pub struct GasEstimateQuery { pub signatures: Option, #[validate(range(min = 1, max = 100000))] pub tx_size: Option, + pub token: String, } impl GasEstimateQuery { @@ -45,6 +50,8 @@ impl GasEstimateQuery { self.shielded_transfer, self.shielding_transfer, self.unshielding_transfer, + self.ibc_shielding_transfer, + self.ibc_unshielding_transfer, self.vote, self.withdraw, self.ibc, diff --git a/webserver/src/handler/gas.rs b/webserver/src/handler/gas.rs index b37eb7aa8..0cd02c640 100644 --- a/webserver/src/handler/gas.rs +++ b/webserver/src/handler/gas.rs @@ -50,6 +50,7 @@ pub async fn get_gas_estimate( let gas = state .gas_service .estimate_gas( + query.token, query.bond.unwrap_or(0), query.redelegate.unwrap_or(0), query.claim_rewards.unwrap_or(0), @@ -58,6 +59,8 @@ pub async fn get_gas_estimate( query.shielded_transfer.unwrap_or(0), query.shielding_transfer.unwrap_or(0), query.unshielding_transfer.unwrap_or(0), + query.ibc_unshielding_transfer.unwrap_or(0), + query.ibc_shielding_transfer.unwrap_or(0), query.vote.unwrap_or(0), query.ibc.unwrap_or(0), query.withdraw.unwrap_or(0), diff --git a/webserver/src/repository/gas.rs b/webserver/src/repository/gas.rs index 6ef41d6fb..ec9dcdc75 100644 --- a/webserver/src/repository/gas.rs +++ b/webserver/src/repository/gas.rs @@ -32,6 +32,7 @@ pub trait GasRepositoryTrait { #[allow(clippy::too_many_arguments)] async fn find_gas_estimates( &self, + token: String, bond: u64, redelegate: u64, claim_rewards: u64, @@ -40,6 +41,8 @@ pub trait GasRepositoryTrait { shielded_transfer: u64, shielding_transfer: u64, unshielding_transfer: u64, + ibc_shielding_transfer: u64, + ibc_unshielding_transfer: u64, vote: u64, ibc: u64, withdraw: u64, @@ -99,6 +102,7 @@ impl GasRepositoryTrait for GasRepository { #[allow(clippy::too_many_arguments)] async fn find_gas_estimates( &self, + token: String, bond: u64, redelegate: u64, claim_rewards: u64, @@ -107,6 +111,8 @@ impl GasRepositoryTrait for GasRepository { shielded_transfer: u64, shielding_transfer: u64, unshielding_transfer: u64, + ibc_shielding_transfer: u64, + ibc_unshielding_transfer: u64, vote: u64, ibc: u64, withdraw: u64, @@ -119,6 +125,7 @@ impl GasRepositoryTrait for GasRepository { conn.interact(move |conn| { gas_estimations::table + .filter(gas_estimations::dsl::token.eq(token)) .filter(gas_estimations::dsl::bond.eq(bond as i32)) .filter( gas_estimations::dsl::redelegation.eq(redelegate as i32), @@ -144,6 +151,14 @@ impl GasRepositoryTrait for GasRepository { gas_estimations::dsl::unshielding_transfer .eq(unshielding_transfer as i32), ) + .filter( + gas_estimations::dsl::ibc_unshielding_transfer + .eq(ibc_unshielding_transfer as i32), + ) + .filter( + gas_estimations::dsl::ibc_shielding_transfer + .eq(ibc_shielding_transfer as i32), + ) .filter(gas_estimations::dsl::vote_proposal.eq(vote as i32)) .filter(gas_estimations::dsl::ibc_msg_transfer.eq(ibc as i32)) .filter(gas_estimations::dsl::withdraw.eq(withdraw as i32)) diff --git a/webserver/src/service/gas.rs b/webserver/src/service/gas.rs index 82b197d65..3c7da4bb2 100644 --- a/webserver/src/service/gas.rs +++ b/webserver/src/service/gas.rs @@ -52,6 +52,7 @@ impl GasService { #[allow(clippy::too_many_arguments)] pub async fn estimate_gas( &self, + token: String, bond: u64, redelegate: u64, claim_rewards: u64, @@ -60,6 +61,8 @@ impl GasService { shielded_transfer: u64, shielding_transfer: u64, unshielding_transfer: u64, + ibc_shielding_transfer: u64, + ibc_unshielding_transfer: u64, vote: u64, ibc: u64, withdraw: u64, @@ -70,6 +73,7 @@ impl GasService { let (min, max, avg, count) = self .gas_repo .find_gas_estimates( + token, bond, redelegate, claim_rewards, @@ -78,6 +82,8 @@ impl GasService { shielded_transfer, shielding_transfer, unshielding_transfer, + ibc_shielding_transfer, + ibc_unshielding_transfer, vote, ibc, withdraw, @@ -129,12 +135,18 @@ impl GasService { * gas.get(&TransactionKind::ShieldingTransfer).unwrap(); estimate += unshielding_transfer * gas.get(&TransactionKind::UnshieldingTransfer).unwrap(); + estimate += ibc_unshielding_transfer + * gas.get(&TransactionKind::UnshieldingTransfer).unwrap(); + estimate += ibc_shielding_transfer + * gas.get(&TransactionKind::ShieldingTransfer).unwrap(); estimate += vote * gas.get(&TransactionKind::VoteProposal).unwrap(); estimate += ibc * gas.get(&TransactionKind::IbcMsgTransfer).unwrap(); estimate += withdraw * gas.get(&TransactionKind::Withdraw).unwrap(); estimate += reveal_pk * gas.get(&TransactionKind::RevealPk).unwrap(); + estimate += + redelegate * gas.get(&TransactionKind::Redelegation).unwrap(); Ok(GasEstimate { min: estimate,