Added initial support for feature #1433

relayer-cli/src/commands.rs

@@ -132,7 +132,14 @@ impl Configurable<Config> for CliCmd {
     ///
     /// This can be safely deleted if you don't want to override config
     /// settings from command-line options.
-    fn process_config(&self, config: Config) -> Result<Config, FrameworkError> {
+    fn process_config(&self, mut config: Config) -> Result<Config, FrameworkError> {
+        // Alter the memo for all chains to include a suffix with Hermes build details
+        let web = "https://hermes.informal.systems";
+        let suffix = format!("{} {} ({})", CliCmd::name(), CliCmd::version(), web);
+        for ccfg in config.chains.iter_mut() {
+            ccfg.memo.apply_suffix(&suffix);
+        }
+
         match self {
             CliCmd::Tx(cmd) => cmd.override_config(config),
             // CliCmd::Help(cmd) => cmd.override_config(config),

relayer/src/chain/cosmos.rs

@@ -229,7 +229,7 @@ impl CosmosSdkChain {
 
         debug!("[{}] default fee: {}", self.id(), PrettyFee(&default_fee));
 
-        let (body, body_buf) = tx_body_and_bytes(proto_msgs)?;
+        let (body, body_buf) = tx_body_and_bytes(proto_msgs, self.tx_memo())?;
 
         let (auth_info, auth_buf) = auth_info_and_bytes(signer_info.clone(), default_fee.clone())?;
         let signed_doc = self.signed_doc(body_buf.clone(), auth_buf, account_seq)?;
@@ -644,6 +644,11 @@ impl CosmosSdkChain {
             .trusting_period
             .unwrap_or(2 * unbonding_period / 3)
     }
+
+    /// Returns the preconfigured memo to be used for every submitted transaction
+    fn tx_memo(&self) -> String {
+        self.config.memo.clone().into()
+    }
 }
 
 fn empty_event_present(events: &[IbcEvent]) -> bool {
@@ -1991,11 +1996,11 @@ fn auth_info_and_bytes(signer_info: SignerInfo, fee: Fee) -> Result<(AuthInfo, V
     Ok((auth_info, auth_buf))
 }
 
-fn tx_body_and_bytes(proto_msgs: Vec<Any>) -> Result<(TxBody, Vec<u8>), Error> {
+fn tx_body_and_bytes(proto_msgs: Vec<Any>, memo: String) -> Result<(TxBody, Vec<u8>), Error> {
     // Create TxBody
     let body = TxBody {
         messages: proto_msgs.to_vec(),
-        memo: "".to_string(),
+        memo,
         timeout_height: 0_u64,
         extension_options: Vec::<Any>::new(),
         non_critical_extension_options: Vec::<Any>::new(),

relayer/src/chain/mock.rs

@@ -438,6 +438,7 @@ pub mod test_utils {
             trust_threshold: Default::default(),
             packet_filter: PacketFilter::default(),
             address_type: AddressType::default(),
+            memo: Default::default(),
         }
     }
 }

relayer/src/config.rs

@@ -14,7 +14,7 @@ use tendermint_light_client::types::TrustThreshold;
 use ibc::ics24_host::identifier::{ChainId, ChannelId, PortId};
 use ibc::timestamp::ZERO_DURATION;
 
-use crate::config::types::{MaxMsgNum, MaxTxSize};
+use crate::config::types::{MaxMsgNum, MaxTxSize, Memo};
 use crate::error::Error;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -320,6 +320,8 @@ pub struct ChainConfig {
     pub clock_drift: Duration,
     #[serde(with = "humantime_serde")]
     pub trusting_period: Option<Duration>,
+    #[serde(default)]
+    pub memo: Memo,
 
     // these two need to be last otherwise we run into `ValueAfterTable` error when serializing to TOML
     #[serde(default)]

relayer/src/config/types.rs

@@ -99,3 +99,60 @@ impl From<MaxTxSize> for usize {
         m.0
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct Memo(String);
+
+impl Memo {
+    const DEFAULT: &'static str = "";
+    const MAX_LEN: usize = 50;
+
+    pub fn apply_suffix(&mut self, suffix: &str) {
+        // Add a separator if the memo
+        // is pre-populated with some content already.
+        if !self.0.is_empty() {
+            self.0.push_str(" | ");
+        }
+
+        self.0.push_str(suffix);
+    }
+}
+
+impl Default for Memo {
+    fn default() -> Self {
+        Self(Self::DEFAULT.to_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for Memo {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let m = String::deserialize(deserializer)?;
+
+        if m.len() > Self::MAX_LEN {
+            return Err(D::Error::invalid_length(
+                m.len(),
+                &format!("a string length of at most {}", Self::MAX_LEN).as_str(),
+            ));
+        }
+
+        Ok(Memo(m))
+    }
+}
+
+impl Serialize for Memo {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+impl From<Memo> for String {
+    fn from(m: Memo) -> Self {
+        m.0
+    }
+}