add form address

ww3512687 · ww3512687 · commit 1517f741858c · 2025-01-10T17:57:44.000+08:00
diff --git a/rust/apps/avalanche/src/lib.rs b/rust/apps/avalanche/src/lib.rs
@@ -11,12 +11,8 @@ use alloc::{
 };
 
 pub use address::get_address;
-use bitcoin::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
 use bytes::{Buf, Bytes};
-use hex;
-use transactions::base_tx::BaseTx;
 use transactions::tx_header::Header;
-use ur_registry::pb::protoc;
 
 use crate::errors::{AvaxError, Result};
 use core::{
diff --git a/rust/apps/avalanche/src/transactions/structs.rs b/rust/apps/avalanche/src/transactions/structs.rs
@@ -1,4 +1,6 @@
+use crate::constants::NAVAX_TO_AVAX_RATIO;
 use crate::errors::{AvaxError, Result};
+use crate::get_address;
 use alloc::{
     string::{String, ToString},
     vec::Vec,
diff --git a/rust/rust_c/src/avalanche/mod.rs b/rust/rust_c/src/avalanche/mod.rs
@@ -12,7 +12,7 @@ use crate::common::{
     structs::{ExtendedPublicKey, SimpleResponse, TransactionCheckResult, TransactionParseResult},
     types::{Ptr, PtrBytes, PtrString, PtrT, PtrUR},
     ur::{UREncodeResult, FRAGMENT_MAX_LENGTH_DEFAULT, FRAGMENT_UNLIMITED_LENGTH},
-    utils::recover_c_char,
+    utils::{recover_c_array, recover_c_char},
 };
 use crate::{extract_ptr_with_type, impl_c_ptr};
 use alloc::{
@@ -31,7 +31,7 @@ use app_avalanche::{
         base_tx::{avax_base_sign, BaseTx},
         export::ExportTx,
         import::ImportTx,
-        type_id::TypeId,
+        type_id::{self, TypeId},
         C_chain::{evm_export::ExportTx as CchainExportTx, evm_import::ImportTx as CchainImportTx},
         P_chain::{
             add_permissionless_delegator::AddPermissLessionDelegatorTx,
@@ -49,61 +49,94 @@ use {
     },
 };
 
+const C_CHAIN_PREFIX: &str = "m/44'/60'/0'";
+const X_P_CHAIN_PREFIX: &str = "m/44'/9000'/0'";
+
+#[derive(Debug, Clone)]
+pub struct DerivationPath {
+    pub base_path: String,
+    pub full_path: String,
+}
+
 #[no_mangle]
 pub extern "C" fn avax_parse_transaction(
     ptr: PtrUR,
     mfp: PtrBytes,
     mfp_len: u32,
     public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
 ) -> PtrT<TransactionParseResult<DisplayAvaxTx>> {
-    let avax_sign_request = extract_ptr_with_type!(ptr, AvaxSignRequest);
-
-    match get_avax_tx_type_id(avax_sign_request.get_tx_data()) {
-        Ok(type_id) => parse_transaction_by_type(type_id, avax_sign_request.get_tx_data()),
-        Err(_) => {
-            TransactionParseResult::from(RustCError::InvalidData("Invalid tx type".to_string()))
-                .c_ptr()
-        }
-    }
+    parse_transaction_by_type(extract_ptr_with_type!(ptr, AvaxSignRequest), public_keys)
 }
+extern crate std;
+use std::println;
 
 fn parse_transaction_by_type(
-    type_id: TypeId,
-    tx_data: Vec<u8>,
+    sign_request: &mut AvaxSignRequest,
+    public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
 ) -> PtrT<TransactionParseResult<DisplayAvaxTx>> {
-    macro_rules! parse_tx {
-        ($tx_type:ty) => {
-            parse_avax_tx::<$tx_type>(tx_data)
-                .map(|parse_data| {
-                    TransactionParseResult::success(DisplayAvaxTx::from(parse_data).c_ptr()).c_ptr()
-                })
-                .unwrap_or_else(|_| {
-                    TransactionParseResult::from(RustCError::InvalidMasterFingerprint).c_ptr()
-                })
-        };
-    }
+    let tx_data = sign_request.get_tx_data();
+    let type_id = get_avax_tx_type_id(sign_request.get_tx_data()).unwrap();
 
-    match type_id {
-        TypeId::BaseTx => {
-            let header = get_avax_tx_header(tx_data.clone()).unwrap();
-            if header.get_blockchain_id() == C_BLOCKCHAIN_ID
-                || header.get_blockchain_id() == C_TEST_BLOCKCHAIN_ID
-            {
-                return parse_tx!(CchainImportTx);
-            } else {
-                return parse_tx!(BaseTx);
+    unsafe {
+        let path = get_avax_tx_type_id(sign_request.get_tx_data())
+            .map_err(|_| AvaxError::InvalidInput)
+            .and_then(|type_id| {
+                determine_derivation_path(type_id, &sign_request, sign_request.get_wallet_index())
+            })
+            .unwrap();
+
+        let mut address = String::new();
+        for key in recover_c_array(public_keys).iter() {
+            if recover_c_char(key.path) == path.base_path {
+                address = app_avalanche::get_address(
+                    app_avalanche::network::Network::AvaxMainNet,
+                    &path.full_path.as_str(),
+                    &recover_c_char(key.xpub).as_str(),
+                    &path.base_path.as_str(),
+                )
+                .unwrap();
             }
         }
-        TypeId::PchainExportTx | TypeId::XchainExportTx => parse_tx!(ExportTx),
-        TypeId::XchainImportTx | TypeId::PchainImportTx => parse_tx!(ImportTx),
-        TypeId::CchainExportTx => parse_tx!(CchainExportTx),
-        TypeId::AddPermissLessionValidator => parse_tx!(AddPermissLessionValidatorTx),
-        TypeId::AddPermissLessionDelegator => parse_tx!(AddPermissLessionDelegatorTx),
-        _ => TransactionParseResult::from(RustCError::InvalidData(format!(
-            "{:?} not support",
-            type_id
-        )))
-        .c_ptr(),
+
+        macro_rules! parse_tx {
+            ($tx_type:ty) => {
+                parse_avax_tx::<$tx_type>(tx_data)
+                    .map(|parse_data| {
+                        TransactionParseResult::success(
+                            DisplayAvaxTx::from(parse_data)
+                                .with_from_address(address.to_string(), path.full_path.to_string())
+                                .c_ptr(),
+                        )
+                        .c_ptr()
+                    })
+                    .unwrap_or_else(|_| {
+                        TransactionParseResult::from(RustCError::InvalidMasterFingerprint).c_ptr()
+                    })
+            };
+        }
+
+        match type_id {
+            TypeId::BaseTx => {
+                let header = get_avax_tx_header(tx_data.clone()).unwrap();
+                if header.get_blockchain_id() == C_BLOCKCHAIN_ID
+                    || header.get_blockchain_id() == C_TEST_BLOCKCHAIN_ID
+                {
+                    return parse_tx!(CchainImportTx);
+                } else {
+                    return parse_tx!(BaseTx);
+                }
+            }
+            TypeId::PchainExportTx | TypeId::XchainExportTx => parse_tx!(ExportTx),
+            TypeId::XchainImportTx | TypeId::PchainImportTx => parse_tx!(ImportTx),
+            TypeId::CchainExportTx => parse_tx!(CchainExportTx),
+            TypeId::AddPermissLessionValidator => parse_tx!(AddPermissLessionValidatorTx),
+            TypeId::AddPermissLessionDelegator => parse_tx!(AddPermissLessionDelegatorTx),
+            _ => TransactionParseResult::from(RustCError::InvalidData(format!(
+                "{:?} not support",
+                type_id
+            )))
+            .c_ptr(),
+        }
     }
 }
 
@@ -135,31 +168,43 @@ fn avax_sign_dynamic(
         )
 }
 
-fn handle_base_tx_path(
+pub fn determine_derivation_path(
+    type_id: TypeId,
     sign_request: &AvaxSignRequest,
     wallet_index: u64,
-) -> Result<String, AvaxError> {
-    let blockchain_id = get_avax_tx_header(sign_request.get_tx_data())?.get_blockchain_id();
+) -> Result<DerivationPath, AvaxError> {
+    println!("type_id = {:?}, wallet_index = {}", type_id, wallet_index);
+    let wallet_suffix = format!("/0/{}", wallet_index);
+
+    let (base_path, full_path) = match type_id {
+        TypeId::CchainExportTx => (
+            C_CHAIN_PREFIX,
+            format!("{}{}", C_CHAIN_PREFIX, wallet_suffix),
+        ),
+        TypeId::BaseTx => {
+            let blockchain_id = get_avax_tx_header(sign_request.get_tx_data())?.get_blockchain_id();
 
-    let path = match blockchain_id {
-        id if id == C_BLOCKCHAIN_ID || id == C_TEST_BLOCKCHAIN_ID => {
-            format!("m/44'/60'/0'/0/{}", wallet_index)
+            if blockchain_id == C_BLOCKCHAIN_ID || blockchain_id == C_TEST_BLOCKCHAIN_ID {
+                (
+                    C_CHAIN_PREFIX,
+                    format!("{}{}", C_CHAIN_PREFIX, wallet_suffix),
+                )
+            } else {
+                (
+                    X_P_CHAIN_PREFIX,
+                    format!("{}{}", X_P_CHAIN_PREFIX, wallet_suffix),
+                )
+            }
         }
-        _ => format!("m/44'/9000'/0'/0/{}", wallet_index),
+        _ => (
+            X_P_CHAIN_PREFIX,
+            format!("{}{}", X_P_CHAIN_PREFIX, wallet_suffix),
+        ),
     };
 
-    Ok(path)
-}
-
-fn determine_derivation_path(
-    type_id: TypeId,
-    sign_request: &AvaxSignRequest,
-    wallet_index: u64,
-) -> Result<String, AvaxError> {
-    Ok(match type_id {
-        TypeId::CchainExportTx => format!("m/44'/60'/0'/0/{}", wallet_index),
-        TypeId::BaseTx => handle_base_tx_path(sign_request, wallet_index)?,
-        _ => format!("m/44'/9000'/0'/0/{}", wallet_index),
+    Ok(DerivationPath {
+        base_path: base_path.to_string(),
+        full_path: full_path,
     })
 }
 
@@ -170,7 +215,8 @@ fn build_sign_result(ptr: PtrUR, seed: &[u8]) -> Result<AvaxSignature, AvaxError
         .map_err(|_| AvaxError::InvalidInput)
         .and_then(|type_id| {
             determine_derivation_path(type_id, &sign_request, sign_request.get_wallet_index())
-        })?;
+        })?
+        .full_path;
 
     avax_base_sign(seed, path, sign_request.get_tx_data())
         .map(|signature| AvaxSignature::new(sign_request.get_request_id(), signature.to_vec()))
diff --git a/rust/rust_c/src/avalanche/structs.rs b/rust/rust_c/src/avalanche/structs.rs
@@ -42,8 +42,8 @@ pub struct DisplayTxAvaxData {
     fee_amount: PtrString,
     reward_address: PtrString,
     method: PtrT<DisplayAvaxMethodInfo>,
-    // from: PtrT<VecFFI<DisplayAddress>>,
     to: PtrT<VecFFI<DisplayAvaxFromToInfo>>,
+    from: PtrT<DisplayAvaxFromToInfo>,
 }
 
 impl_c_ptr!(DisplayTxAvaxData);
@@ -115,9 +115,30 @@ impl<T: AvaxTxInfo> From<T> for DisplayAvaxTx {
     }
 }
 
+impl DisplayAvaxTx {
+    pub fn with_from_address(mut self, address: String, path: String) -> Self {
+        unsafe {
+            let data = &mut *self.data;
+            let from = &mut *data.from;
+            from.address = convert_c_char(address);
+            from.path = convert_c_char(path);
+        }
+        self
+    }
+}
+
 impl<T: AvaxTxInfo> From<T> for DisplayTxAvaxData {
     fn from(value: T) -> Self {
         DisplayTxAvaxData {
+            from: DisplayAvaxFromToInfo {
+                address: convert_c_char("".to_string()),
+                amount: convert_c_char(format!(
+                    "{} AVAX",
+                    value.get_total_input_amount() as f64 / NAVAX_TO_AVAX_RATIO
+                )),
+                path: convert_c_char("".to_string()),
+            }
+            .c_ptr(),
             total_input_amount: convert_c_char(format!(
                 "{} AVAX",
                 value.get_total_input_amount() as f64 / NAVAX_TO_AVAX_RATIO
diff --git a/src/ui/gui_chain/multi/web3/gui_avax.c b/src/ui/gui_chain/multi/web3/gui_avax.c
@@ -90,7 +90,7 @@ void *GuiGetAvaxGUIData(void)
         public_keys->size = NUMBER_OF_ARRAYS(keys);
         keys[0].path = "m/44'/60'/0'";
         keys[0].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_AVAX_BIP44_STANDARD);
-        keys[1].path = "m/44'/9000'/0";
+        keys[1].path = "m/44'/9000'/0'";
         keys[1].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_AVAX_X_P);
         PtrT_TransactionParseResult_DisplayTonTransaction parseResult = avax_parse_transaction(data, mfp, sizeof(mfp), public_keys);
         SRAM_FREE(public_keys);
@@ -120,7 +120,7 @@ lv_obj_t *CreateTxOverviewFromTo(lv_obj_t *parent, void *from, int fromLen, void
     }
 
     ptr = (DisplayUtxoFromTo *)to;
-    uint16_t offset = 30 + 8 + (30 + 8) * fromLen + 16;
+    uint16_t offset = 30 + 8 + (60 + 8) * fromLen + 16;
     label = GuiCreateNoticeLabel(container, _("To"));
     lv_obj_align(label, LV_ALIGN_TOP_LEFT, 24, offset);
     for (int i = 0; i < toLen; i++) {
@@ -176,8 +176,7 @@ void GuiAvaxTxOverview(lv_obj_t *parent, void *totalData)
         GuiAlignToPrevObj(container, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 16);
     }
 
-    printf("txData->data->from->size->address: %s\n", txData->data->to->data[0].address);
-    container = CreateTxOverviewFromTo(parent, NULL, 0, txData->data->to->data, txData->data->to->size);
+    container = CreateTxOverviewFromTo(parent, txData->data->from, 1, txData->data->to->data, txData->data->to->size);
     GuiAlignToPrevObj(container, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 16);
     lv_obj_update_layout(parent);
 }
@@ -214,7 +213,7 @@ void GuiAvaxTxRawData(lv_obj_t *parent, void *totalData)
     container = CreateValueDetailValue(parent, txData->data->total_input_amount, txData->data->total_output_amount, txData->data->fee_amount);
     GuiAlignToPrevObj(container, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 16);
 
-    container = CreateTxDetailsFromTo(parent, "From", NULL, 0);
+    container = CreateTxDetailsFromTo(parent, "From", txData->data->from, 1);
     GuiAlignToPrevObj(container, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 16);
 
     container = CreateTxDetailsFromTo(parent, "To", txData->data->to->data, txData->data->to->size);
