Substitution of UTXO transaction ID in the template

contracts/satoshi-bridge/src/api/token_receiver.rs

@@ -71,7 +71,7 @@ impl FungibleTokenReceiver for Contract {
                     &vutxos,
                     amount,
                     withdraw_fee,
-                    max_gas_fee
+                    max_gas_fee,
                 );
 
                 let need_signature_num = psbt.unsigned_tx.input.len();

contracts/satoshi-bridge/src/btc_light_client/deposit.rs

@@ -42,7 +42,8 @@ impl Contract {
                 .deposit_bridge_fee
                 .get_protocol_and_relayer_fee(deposit_fee);
 
-            let post_actions = self.check_deposit_msg(deposit_msg, mint_amount);
+            let post_actions =
+                self.check_deposit_msg(deposit_msg, mint_amount, pending_utxo_info.tx_id.clone());
             promise.then(
                 Self::ext(env::current_account_id())
                     .with_static_gas(GAS_FOR_VERIFY_DEPOSIT_CALL_BACK)

contracts/satoshi-bridge/src/deposit_msg.rs

@@ -40,8 +40,9 @@ impl Contract {
         &self,
         deposit_msg: DepositMsg,
         actual_mintable_amount: u128,
+        utxo_tx_id: String,
     ) -> Option<Vec<PostAction>> {
-        let post_actions = deposit_msg.post_actions?;
+        let mut post_actions = deposit_msg.post_actions?;
         if post_actions.is_empty() {
             Event::InvalidPostAction {
                 index: None,
@@ -65,7 +66,7 @@ impl Contract {
         }
         let mut total_gas = 0;
         let mut total_amount = 0;
-        for (index, post_action) in post_actions.iter().enumerate() {
+        for (index, post_action) in post_actions.iter_mut().enumerate() {
             total_amount += post_action.amount.0;
             // The receiver_id must be on the whitelist.
             if !self
@@ -88,21 +89,41 @@ impl Contract {
                 .post_action_msg_templates
                 .get(&post_action.receiver_id)
             {
-                let is_match =
+                let updated_post_action: Option<String> =
                     match serde_json::from_str::<Value>(&post_action.msg) {
-                        Ok(msg_value) => msg_templates.iter().any(|template| {
-                            match serde_json::from_str::<Value>(template) {
-                                Ok(template_value) => {
-                                    is_structure_equal(&template_value, &msg_value)
+                        Ok(msg_value) => {
+                            let mut res = None;
+                            for template in msg_templates {
+                                if let Ok(template_value) = serde_json::from_str::<Value>(template)
+                                {
+                                    res = check_template_and_update_msg(
+                                        &template_value,
+                                        &msg_value,
+                                        &utxo_tx_id,
+                                    );
+                                    if res.is_some() {
+                                        break;
+                                    }
                                 }
-                                Err(_) => false,
                             }
-                        }),
-                        Err(_) => msg_templates
-                            .iter()
-                            .any(|template| template == &post_action.msg),
+
+                            res.map(|x| x.to_string())
+                        }
+                        Err(_) => {
+                            if msg_templates
+                                .iter()
+                                .any(|template| template == &post_action.msg)
+                            {
+                                Some(post_action.msg.clone())
+                            } else {
+                                None
+                            }
+                        }
                     };
-                if !is_match {
+
+                if let Some(updated_post_action) = updated_post_action {
+                    post_action.msg = updated_post_action;
+                } else {
                     Event::InvalidPostAction {
                         index: Some(index),
                         err_msg: "Unsupported post_action.msg.".to_string(),

contracts/satoshi-bridge/src/json_utils.rs

@@ -1,5 +1,7 @@
 use crate::*;
 
+const INSERT_UTXO_TX_ID_TEMPLATE: &str = "{{UTXO_TX_ID}}";
+
 /// Recursively checks whether the structure of `input` matches the structure of `template`.
 /// Values can differ, but keys and value types must conform to the `template`.
 ///
@@ -11,16 +13,22 @@ use crate::*;
 /// 4. If the template array has multiple elements, it's treated as an enum array:
 ///    all elements in `input` must match one of the enum variants.
 /// 5. If a template value is `null`, then any corresponding input value is accepted (i.e., unconstrained).
-pub fn is_structure_equal(template: &Value, input: &Value) -> bool {
+pub fn check_template_and_update_msg(
+    template: &Value,
+    input: &Value,
+    utxo_tx_id: &str,
+) -> Option<Value> {
+    let mut res = input.clone();
     match (template, input) {
         (Value::Object(t_obj), Value::Object(i_obj)) => {
             for (key, t_val) in t_obj {
                 match i_obj.get(key) {
-                    Some(i_val) => {
-                        if !is_structure_equal(t_val, i_val) {
-                            return false;
+                    Some(i_val) => match check_template_and_update_msg(t_val, i_val, utxo_tx_id) {
+                        Some(val) => {
+                            res.as_object_mut().unwrap().insert(key.clone(), val);
                         }
-                    }
+                        None => return None,
+                    },
                     None => {
                         // Input is allowed to omit fields defined in the template; these are treated as optional fields.
                         continue;
@@ -30,33 +38,46 @@ pub fn is_structure_equal(template: &Value, input: &Value) -> bool {
             // The input must not contain fields that are not defined in the template.
             for key in i_obj.keys() {
                 if !t_obj.contains_key(key) {
-                    return false;
+                    return None;
                 }
             }
-            true
+            Some(res)
         }
         (Value::Array(t_arr), Value::Array(i_arr)) => {
             if t_arr.is_empty() {
-                return i_arr.is_empty();
+                if i_arr.is_empty() {
+                    return Some(res);
+                }
+                return None;
             }
+            res = Value::Array(vec![]);
+
             for i_item in i_arr {
                 let mut matched = false;
                 for t_item in t_arr {
-                    if is_structure_equal(t_item, i_item) {
+                    if let Some(sub_res) = check_template_and_update_msg(t_item, i_item, utxo_tx_id)
+                    {
+                        res.as_array_mut().unwrap().push(sub_res);
+
                         matched = true;
                         break;
                     }
                 }
                 if !matched {
-                    return false;
+                    return None;
                 }
             }
-            true
+            Some(res)
+        }
+        (Value::String(temp_str), Value::String(real_str)) => {
+            if temp_str == INSERT_UTXO_TX_ID_TEMPLATE && real_str == INSERT_UTXO_TX_ID_TEMPLATE {
+                res = Value::String(utxo_tx_id.to_string());
+            }
+            Some(res)
         }
-        (Value::String(_), Value::String(_)) => true,
-        (Value::Number(_), Value::Number(_)) => true,
-        (Value::Bool(_), Value::Bool(_)) => true,
-        (Value::Null, _) => true, // When a key’s value is not restricted, set its value to null.
-        _ => false,
+        (Value::Number(_), Value::Number(_)) => Some(res),
+        (Value::Bool(_), Value::Bool(_)) => Some(res),
+        (Value::Null, _) => Some(res), // When a key’s value is not restricted, set its value to null.
+        _ => None,
     }
 }

contracts/satoshi-bridge/src/psbt.rs

@@ -21,9 +21,15 @@ impl Contract {
             amount,
             withdraw_fee,
         );
-        
+
         if let Some(max_gas_fee) = max_gas_fee {
-            require!(gas_fee <= max_gas_fee.0, format!("Gas fee does not match the provided max fee (gas fee = {}; max gas fee = {})", gas_fee, max_gas_fee.0));
+            require!(
+                gas_fee <= max_gas_fee.0,
+                format!(
+                    "Gas fee does not match the provided max fee (gas fee = {}; max gas fee = {})",
+                    gas_fee, max_gas_fee.0
+                )
+            );
         }
 
         require!(