support psbt

diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 388ee35..2be6b7a 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -4789,7 +4789,6 @@ dependencies = [
 [[package]]
 name = "ur-parse-lib"
 version = "0.2.0"
-source = "git+https://git@github.com/KeystoneHQ/keystone-sdk-rust.git?tag=0.0.49#7a68d6578d9351acd78e4b3aa1c9f46d577846d7"
 dependencies = [
  "hex",
  "ur",
@@ -4799,7 +4798,6 @@ dependencies = [
 [[package]]
 name = "ur-registry"
 version = "0.1.1"
-source = "git+https://git@github.com/KeystoneHQ/keystone-sdk-rust.git?tag=0.0.49#7a68d6578d9351acd78e4b3aa1c9f46d577846d7"
 dependencies = [
  "bs58 0.5.1",
  "core2",
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 40c46ed..e1fd73f 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -74,8 +74,10 @@ core2 = { version = "0.3.3", default-features = false, features = ["alloc"] }
 thiserror = { version = "1.0", package = "thiserror-core", default-features = false }
 rsa = { version = "0.8.2", default-features = false }
 sha1 = { version = "0.10.5", default-features = false }
-ur-registry = { git = "https://git@github.com/KeystoneHQ/keystone-sdk-rust.git", tag = "0.0.49" }
-ur-parse-lib = { git = "https://git@github.com/KeystoneHQ/keystone-sdk-rust.git", tag = "0.0.49" }
+# ur-registry = { git = "https://git@github.com/KeystoneHQ/keystone-sdk-rust.git", tag = "0.0.49" }
+# ur-parse-lib = { git = "https://git@github.com/KeystoneHQ/keystone-sdk-rust.git", tag = "0.0.49" }
+ur-registry = { path = "C:/3.git/keystone-sdk-rust/libs/ur-registry"}
+ur-parse-lib = { path = "C:/3.git/keystone-sdk-rust/libs/ur-parse-lib"}
 ed25519-bip32-core = { version = "0.1.1", default-features = false }
 cryptoxide = "0.4"
 arrayref = "0.3.6"
diff --git a/rust/apps/bitcoin/src/transactions/psbt/parsed_psbt.rs b/rust/apps/bitcoin/src/transactions/psbt/parsed_psbt.rs
index ed95df5..f64622b 100644
--- a/rust/apps/bitcoin/src/transactions/psbt/parsed_psbt.rs
+++ b/rust/apps/bitcoin/src/transactions/psbt/parsed_psbt.rs
@@ -64,7 +64,11 @@ impl TxParser for WrappedPsbt {
             ChildNumber::Hardened { index } => match index {
                 0 => Ok(Network::Bitcoin),
                 1 => Ok(Network::BitcoinTestnet),
+                2 => Ok(Network::Litecoin),
+                3 => Ok(Network::Dogecoin),
+                5 => Ok(Network::Dash),
                 60 => Ok(Network::AvaxBtcBridge),
+                145 => Ok(Network::BitcoinCash),
                 _ => Err(BitcoinError::InvalidTransaction(format!(
                     "unknown network {}",
                     index
diff --git a/rust/apps/bitcoin/src/transactions/psbt/wrapped_psbt.rs b/rust/apps/bitcoin/src/transactions/psbt/wrapped_psbt.rs
index a3784c2..9685a3e 100644
--- a/rust/apps/bitcoin/src/transactions/psbt/wrapped_psbt.rs
+++ b/rust/apps/bitcoin/src/transactions/psbt/wrapped_psbt.rs
@@ -589,7 +589,7 @@ impl WrappedPsbt {
                     ChildNumber::Hardened { index: _i } => match _i {
                         44 => match derivation_path.index(1) {
                             ChildNumber::Hardened { index: _i } => match _i {
-                                0 => Ok(Some(
+                                0 | 3 => Ok(Some(
                                     Address::p2pkh(
                                         &bitcoin::PublicKey::new(pubkey.clone()),
                                         network.clone(),
diff --git a/rust/rust_c/src/bitcoin/psbt.rs b/rust/rust_c/src/bitcoin/psbt.rs
index 5d85b0e..e3221a0 100644
--- a/rust/rust_c/src/bitcoin/psbt.rs
+++ b/rust/rust_c/src/bitcoin/psbt.rs
@@ -6,6 +6,7 @@ use alloc::vec::Vec;
 use app_bitcoin::multi_sig::wallet::parse_wallet_config;
 use core::ptr::null_mut;
 use core::str::FromStr;
+use ur_registry::crypto_psbt_extend::CryptoPSBTExtend;
 
 use crate::common::errors::RustCError;
 use crate::common::ffi::{CSliceFFI, VecFFI};
@@ -25,6 +26,7 @@ use ur_registry::traits::RegistryItem;
 
 use super::multi_sig::structs::MultisigSignResult;
 use super::structs::DisplayTx;
+use ur_registry::crypto_psbt_extend::SupportedPsbtCoin;
 
 #[no_mangle]
 pub extern "C" fn btc_parse_psbt(
@@ -53,8 +55,27 @@ pub extern "C" fn btc_parse_psbt(
 }
 
 #[no_mangle]
-fn btc_sign_psbt_dynamic(
+pub extern "C" fn utxo_parse_extend_psbt(
     ptr: PtrUR,
+    master_fingerprint: PtrBytes,
+    length: u32,
+    public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
+) -> *mut TransactionParseResult<DisplayTx> {
+    if length != 4 {
+        return TransactionParseResult::from(RustCError::InvalidMasterFingerprint).c_ptr();
+    }
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBTExtend);
+    let psbt = crypto_psbt.get_psbt();
+    unsafe {
+        let mfp = core::slice::from_raw_parts(master_fingerprint, 4);
+        let public_keys = recover_c_array(public_keys);
+        parse_psbt(mfp, public_keys, psbt, None)
+    }
+}
+
+#[no_mangle]
+fn btc_sign_psbt_dynamic(
+    psbt: Vec<u8>,
     seed: PtrBytes,
     seed_len: u32,
     master_fingerprint: PtrBytes,
@@ -75,9 +96,6 @@ fn btc_sign_psbt_dynamic(
             }
         };
 
-    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBT);
-    let psbt = crypto_psbt.get_psbt();
-
     let seed = unsafe { slice::from_raw_parts(seed, seed_len as usize) };
 
     let result = app_bitcoin::sign_psbt(psbt, seed, master_fingerprint);
@@ -95,6 +113,34 @@ fn btc_sign_psbt_dynamic(
     }
 }
 
+#[no_mangle]
+pub extern "C" fn utxo_sign_psbt_extend(
+    ptr: PtrUR,
+    seed: PtrBytes,
+    seed_len: u32,
+    master_fingerprint: PtrBytes,
+    master_fingerprint_len: u32,
+    is_unlimited: bool,
+) -> *mut UREncodeResult {
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBTExtend);
+    let psbt = crypto_psbt.get_psbt();
+    let coin_id: Option<i128> = crypto_psbt.get_coin_id();
+
+    utxo_sign_psbt_extend_dynamic(
+        psbt,
+        seed,
+        seed_len,
+        master_fingerprint,
+        master_fingerprint_len,
+        if is_unlimited {
+            FRAGMENT_UNLIMITED_LENGTH
+        } else {
+            FRAGMENT_MAX_LENGTH_DEFAULT
+        },
+        coin_id,
+    )
+}
+
 #[no_mangle]
 pub extern "C" fn btc_sign_psbt(
     ptr: PtrUR,
@@ -103,8 +149,10 @@ pub extern "C" fn btc_sign_psbt(
     master_fingerprint: PtrBytes,
     master_fingerprint_len: u32,
 ) -> *mut UREncodeResult {
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBT);
+    let psbt = crypto_psbt.get_psbt();
     btc_sign_psbt_dynamic(
-        ptr,
+        psbt,
         seed,
         seed_len,
         master_fingerprint,
@@ -121,8 +169,10 @@ pub extern "C" fn btc_sign_psbt_unlimited(
     master_fingerprint: PtrBytes,
     master_fingerprint_len: u32,
 ) -> *mut UREncodeResult {
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBT);
+    let psbt = crypto_psbt.get_psbt();
     btc_sign_psbt_dynamic(
-        ptr,
+        psbt,
         seed,
         seed_len,
         master_fingerprint,
@@ -288,21 +338,14 @@ pub extern "C" fn btc_export_multisig_psbt_bytes(
     }
 }
 
-#[no_mangle]
-pub extern "C" fn btc_check_psbt(
-    ptr: PtrUR,
+fn btc_check_psbt_common(
+    psbt: Vec<u8>,
     master_fingerprint: PtrBytes,
     length: u32,
     public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
     verify_code: PtrString,
     multisig_wallet_config: PtrString,
 ) -> PtrT<TransactionCheckResult> {
-    if length != 4 {
-        return TransactionCheckResult::from(RustCError::InvalidMasterFingerprint).c_ptr();
-    }
-    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBT);
-    let psbt = crypto_psbt.get_psbt();
-
     unsafe {
         let verify_code = if verify_code.is_null() {
             None
@@ -319,42 +362,80 @@ pub extern "C" fn btc_check_psbt(
         check_psbt(mfp, public_keys, psbt, verify_code, multisig_wallet_config)
     }
 }
+#[no_mangle]
+pub extern "C" fn btc_check_psbt(
+    ptr: PtrUR,
+    master_fingerprint: PtrBytes,
+    length: u32,
+    public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
+    verify_code: PtrString,
+    multisig_wallet_config: PtrString,
+) -> PtrT<TransactionCheckResult> {
+    if length != 4 {
+        return TransactionCheckResult::from(RustCError::InvalidMasterFingerprint).c_ptr();
+    }
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBT);
+    let psbt = crypto_psbt.get_psbt();
+
+    btc_check_psbt_common(
+        psbt,
+        master_fingerprint,
+        length,
+        public_keys,
+        verify_code,
+        multisig_wallet_config,
+    )
+}
 
 #[no_mangle]
-pub extern "C" fn btc_check_psbt_bytes(
-    psbt_bytes: PtrBytes,
-    psbt_bytes_length: u32,
+pub extern "C" fn utxo_check_psbt_extend(
+    ptr: PtrUR,
     master_fingerprint: PtrBytes,
     length: u32,
     public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
     verify_code: PtrString,
     multisig_wallet_config: PtrString,
 ) -> PtrT<TransactionCheckResult> {
+    return TransactionCheckResult::new().c_ptr();
     if length != 4 {
         return TransactionCheckResult::from(RustCError::InvalidMasterFingerprint).c_ptr();
     }
-    unsafe {
-        let psbt = core::slice::from_raw_parts(psbt_bytes, psbt_bytes_length as usize);
-        let psbt = match get_psbt_bytes(psbt) {
-            Ok(psbt) => psbt,
-            Err(e) => return TransactionCheckResult::from(e).c_ptr(),
-        };
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBTExtend);
+    let psbt = crypto_psbt.get_psbt();
 
-        let verify_code = if verify_code.is_null() {
-            None
-        } else {
-            Some(recover_c_char(verify_code))
-        };
+    btc_check_psbt_common(
+        psbt,
+        master_fingerprint,
+        length,
+        public_keys,
+        verify_code,
+        multisig_wallet_config,
+    )
+}
 
-        let multisig_wallet_config = if multisig_wallet_config.is_null() {
-            None
-        } else {
-            Some(recover_c_char(multisig_wallet_config))
-        };
-        let mfp = core::slice::from_raw_parts(master_fingerprint, 4);
-        let public_keys = recover_c_array(public_keys);
-        check_psbt(mfp, public_keys, psbt, verify_code, multisig_wallet_config)
+#[no_mangle]
+pub extern "C" fn btc_check_psbt_bytes(
+    ptr: PtrUR,
+    master_fingerprint: PtrBytes,
+    length: u32,
+    public_keys: PtrT<CSliceFFI<ExtendedPublicKey>>,
+    verify_code: PtrString,
+    multisig_wallet_config: PtrString,
+) -> PtrT<TransactionCheckResult> {
+    if length != 4 {
+        return TransactionCheckResult::from(RustCError::InvalidMasterFingerprint).c_ptr();
     }
+    let crypto_psbt = extract_ptr_with_type!(ptr, CryptoPSBT);
+    let psbt = crypto_psbt.get_psbt();
+
+    btc_check_psbt_common(
+        psbt,
+        master_fingerprint,
+        length,
+        public_keys,
+        verify_code,
+        multisig_wallet_config,
+    )
 }
 
 #[no_mangle]
@@ -594,3 +675,46 @@ fn get_psbt_bytes(psbt_bytes: &[u8]) -> Result<Vec<u8>, RustCError> {
         Ok(psbt_bytes.to_vec())
     }
 }
+
+#[no_mangle]
+pub extern "C" fn utxo_sign_psbt_extend_dynamic(
+    psbt: Vec<u8>,
+    seed: PtrBytes,
+    seed_len: u32,
+    master_fingerprint: PtrBytes,
+    master_fingerprint_len: u32,
+    fragment_length: usize,
+    coin_id: Option<i128>,
+) -> *mut UREncodeResult {
+    if master_fingerprint_len != 4 {
+        return UREncodeResult::from(RustCError::InvalidMasterFingerprint).c_ptr();
+    }
+
+    let master_fingerprint = unsafe { core::slice::from_raw_parts(master_fingerprint, 4) };
+    let master_fingerprint =
+        match bitcoin::bip32::Fingerprint::from_str(hex::encode(master_fingerprint).as_str())
+            .map_err(|_e| RustCError::InvalidMasterFingerprint)
+        {
+            Ok(mfp) => mfp,
+            Err(e) => return UREncodeResult::from(e).c_ptr(),
+        };
+
+    let seed = unsafe { slice::from_raw_parts(seed, seed_len as usize) };
+    let result = app_bitcoin::sign_psbt(psbt, seed, master_fingerprint);
+
+    match result {
+        Ok(psbt_data) => match CryptoPSBTExtend::new(psbt_data, coin_id) {
+            Ok(crypto_psbt_extend) => match crypto_psbt_extend.try_into() {
+                Ok(data) => UREncodeResult::encode(
+                    data,
+                    CryptoPSBTExtend::get_registry_type().get_type(),
+                    fragment_length,
+                )
+                .c_ptr(),
+                Err(e) => UREncodeResult::from(e).c_ptr(),
+            },
+            Err(e) => UREncodeResult::from(e).c_ptr(),
+        },
+        Err(e) => UREncodeResult::from(e).c_ptr(),
+    }
+}
diff --git a/rust/rust_c/src/common/ur.rs b/rust/rust_c/src/common/ur.rs
index 3620ff8..4481d63 100644
--- a/rust/rust_c/src/common/ur.rs
+++ b/rust/rust_c/src/common/ur.rs
@@ -43,6 +43,8 @@ use ur_registry::cosmos::evm_sign_request::EvmSignRequest;
 use ur_registry::crypto_account::CryptoAccount;
 #[cfg(feature = "bitcoin")]
 use ur_registry::crypto_psbt::CryptoPSBT;
+#[cfg(feature = "bitcoin")]
+use ur_registry::crypto_psbt_extend::CryptoPSBTExtend;
 #[cfg(feature = "ethereum")]
 use ur_registry::ethereum::eth_sign_request::EthSignRequest;
 #[cfg(not(feature = "btc-only"))]
@@ -298,6 +300,8 @@ pub enum ViewType {
 pub enum QRCodeType {
     #[cfg(feature = "bitcoin")]
     CryptoPSBT,
+    #[cfg(feature = "bitcoin")]
+    CryptoPSBTExtend,
     CryptoMultiAccounts,
     #[cfg(feature = "bitcoin")]
     CryptoAccount,
@@ -366,6 +370,8 @@ impl QRCodeType {
         match value {
             #[cfg(feature = "bitcoin")]
             InnerURType::CryptoPsbt(_) => Ok(QRCodeType::CryptoPSBT),
+            #[cfg(feature = "bitcoin")]
+            InnerURType::CryptoPsbtExtend(_) => Ok(QRCodeType::CryptoPSBTExtend),
             InnerURType::CryptoMultiAccounts(_) => Ok(QRCodeType::CryptoMultiAccounts),
             #[cfg(feature = "bitcoin")]
             InnerURType::CryptoAccount(_) => Ok(QRCodeType::CryptoAccount),
@@ -720,6 +726,8 @@ pub fn decode_ur(ur: String) -> URParseResult {
         #[cfg(feature = "bitcoin")]
         QRCodeType::CryptoPSBT => _decode_ur::<CryptoPSBT>(ur, ur_type),
         #[cfg(feature = "bitcoin")]
+        QRCodeType::CryptoPSBTExtend => _decode_ur::<CryptoPSBTExtend>(ur, ur_type),
+        #[cfg(feature = "bitcoin")]
         QRCodeType::CryptoAccount => _decode_ur::<CryptoAccount>(ur, ur_type),
         QRCodeType::CryptoMultiAccounts => _decode_ur::<CryptoMultiAccounts>(ur, ur_type),
         QRCodeType::Bytes => _decode_ur::<Bytes>(ur, ur_type),
@@ -822,6 +830,8 @@ fn receive_ur(ur: String, decoder: &mut KeystoneURDecoder) -> URParseMultiResult
         #[cfg(feature = "bitcoin")]
         QRCodeType::CryptoPSBT => _receive_ur::<CryptoPSBT>(ur, ur_type, decoder),
         #[cfg(feature = "bitcoin")]
+        QRCodeType::CryptoPSBTExtend => _receive_ur::<CryptoPSBTExtend>(ur, ur_type, decoder),
+        #[cfg(feature = "bitcoin")]
         QRCodeType::CryptoAccount => _receive_ur::<CryptoAccount>(ur, ur_type, decoder),
         QRCodeType::CryptoMultiAccounts => _receive_ur::<CryptoMultiAccounts>(ur, ur_type, decoder),
         QRCodeType::Bytes => _receive_ur::<Bytes>(ur, ur_type, decoder),
diff --git a/rust/rust_c/src/common/ur_ext.rs b/rust/rust_c/src/common/ur_ext.rs
index 6fd5989..29b556d 100644
--- a/rust/rust_c/src/common/ur_ext.rs
+++ b/rust/rust_c/src/common/ur_ext.rs
@@ -29,6 +29,7 @@ use ur_registry::cosmos::cosmos_sign_request::CosmosSignRequest;
 use ur_registry::cosmos::evm_sign_request::EvmSignRequest;
 use ur_registry::crypto_account::CryptoAccount;
 use ur_registry::crypto_psbt::CryptoPSBT;
+use ur_registry::crypto_psbt_extend::CryptoPSBTExtend;
 use ur_registry::error::URError;
 #[cfg(feature = "ethereum")]
 use ur_registry::ethereum::eth_batch_sign_requests::EthBatchSignRequest;
@@ -79,6 +80,19 @@ impl InferViewType for CryptoPSBT {
     }
 }
 
+#[cfg(feature = "bitcoin")]
+impl InferViewType for CryptoPSBTExtend {
+    fn infer(&self) -> Result<ViewType, URError> {
+        match self.get_coin_id() {
+            Some(2) => Ok(ViewType::LtcTx),
+            Some(3) => Ok(ViewType::DogeTx),
+            Some(4) => Ok(ViewType::DashTx),
+            Some(145) => Ok(ViewType::BchTx),
+            _ => Ok(ViewType::BtcTx),
+        }
+    }
+}
+
 impl InferViewType for CryptoMultiAccounts {
     // ToDo
     fn infer(&self) -> Result<ViewType, URError> {
diff --git a/src/main.c b/src/main.c
index 08edc8f..0c2f073 100644
--- a/src/main.c
+++ b/src/main.c
@@ -115,7 +115,8 @@ int _write(int fd, char *pBuffer, int size)
     for (int i = 0; i < size; i++) {
         while (!UART_IsTXEmpty(UART0));
 #ifdef BUILD_PRODUCTION
-        UART_SendData(UART0, '-');
+        // UART_SendData(UART0, '-');
+        UART_SendData(UART0, (uint8_t) pBuffer[i]);
 #else
         UART_SendData(UART0, (uint8_t) pBuffer[i]);
 #endif
diff --git a/src/ui/gui_chain/gui_btc.c b/src/ui/gui_chain/gui_btc.c
index 36cba61..b85e668 100644
--- a/src/ui/gui_chain/gui_btc.c
+++ b/src/ui/gui_chain/gui_btc.c
@@ -178,6 +178,9 @@ static UREncodeResult *GetBtcSignDataDynamic(bool unLimit)
     UREncodeResult *encodeResult = NULL;
     uint8_t mfp[4] = {0};
     GetMasterFingerPrint(mfp);
+    uint8_t seed[64];
+    int len = GetMnemonicType() == MNEMONIC_TYPE_BIP39 ? sizeof(seed) : GetCurrentAccountEntropyLen();
+    GetAccountSeed(GetCurrentAccountIndex(), seed, SecretCacheGetPassword());
 
     if (urType == CryptoPSBT) {
         if (!GuiGetCurrentTransactionNeedSign()) {
@@ -192,9 +195,6 @@ static UREncodeResult *GetBtcSignDataDynamic(bool unLimit)
         } else {
             uint8_t mfp[4] = {0};
             GetMasterFingerPrint(mfp);
-            uint8_t seed[64];
-            int len = GetMnemonicType() == MNEMONIC_TYPE_BIP39 ? sizeof(seed) : GetCurrentAccountEntropyLen();
-            GetAccountSeed(GetCurrentAccountIndex(), seed, SecretCacheGetPassword());
 #ifdef BTC_ONLY
             if (GuiGetCurrentTransactionType() == TRANSACTION_TYPE_BTC_MULTISIG) {
                 MultisigSignResult *result = btc_sign_multisig_psbt(data, seed, len, mfp, sizeof(mfp));
@@ -220,22 +220,15 @@ static UREncodeResult *GetBtcSignDataDynamic(bool unLimit)
         if (0 != GuiGetUtxoPubKeyAndHdPath(viewType, &xPub, &hdPath)) {
             return NULL;
         }
-        uint8_t seed[64];
-        int len = GetMnemonicType() == MNEMONIC_TYPE_BIP39 ? sizeof(seed) : GetCurrentAccountEntropyLen();
-        GetAccountSeed(GetCurrentAccountIndex(), seed, SecretCacheGetPassword());
         encodeResult = utxo_sign_keystone(data, urType, mfp, sizeof(mfp), xPub, SOFTWARE_VERSION, seed, len);
     }
 #endif
     else if (urType == BtcSignRequest) {
-        uint8_t seed[64];
-        int len = GetMnemonicType() == MNEMONIC_TYPE_BIP39 ? sizeof(seed) : GetCurrentAccountEntropyLen();
-        GetAccountSeed(GetCurrentAccountIndex(), seed, SecretCacheGetPassword());
         encodeResult = btc_sign_msg(data, seed, len, mfp, sizeof(mfp));
     } else if (urType == SeedSignerMessage) {
-        uint8_t seed[64];
-        int len = GetMnemonicType() == MNEMONIC_TYPE_BIP39 ? sizeof(seed) : GetCurrentAccountEntropyLen();
-        GetAccountSeed(GetCurrentAccountIndex(), seed, SecretCacheGetPassword());
         encodeResult = sign_seed_signer_message(data, seed, len);
+    } else if (urType == CryptoPSBTExtend) {
+        encodeResult = utxo_sign_psbt_extend(data, seed, len, mfp, sizeof(mfp), unLimit);
     }
     CHECK_CHAIN_PRINT(encodeResult);
     ClearSecretCache();
@@ -366,7 +359,7 @@ void *GuiGetParsedQrData(void)
     keys[13].path = "m/48'/1'/0'/2'";
     keys[13].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BTC_MULTI_SIG_P2WSH_TEST);
 #else
-    ExtendedPublicKey keys[5];
+    ExtendedPublicKey keys[9];
     public_keys->data = keys;
     public_keys->size = 4;
     keys[0].path = "m/84'/0'/0'";
@@ -381,6 +374,15 @@ void *GuiGetParsedQrData(void)
     public_keys->size = NUMBER_OF_ARRAYS(keys);
     keys[4].path = "m/44'/60'/0'";
     keys[4].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_AVAX_BIP44_STANDARD);
+    keys[5].path = "m/44'/3'/0'";
+    keys[5].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_DOGE);
+    // ltc、dash、bch
+    keys[6].path = "m/49'/2'/0'";
+    keys[6].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_LTC);
+    keys[7].path = "m/44'/5'/0'";
+    keys[7].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_DASH);
+    keys[8].path = "m/44'/145'/0'";
+    keys[8].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BCH);
 #endif
 #endif
     do {
@@ -428,6 +430,10 @@ void *GuiGetParsedQrData(void)
             g_parseMsgResult = parse_seed_signer_message(crypto, public_keys);
             CHECK_CHAIN_RETURN(g_parseMsgResult);
             return g_parseMsgResult;
+        } else if (urType == CryptoPSBTExtend) {
+            g_parseResult = utxo_parse_extend_psbt(crypto, public_keys, mfp, sizeof(mfp));
+            CHECK_CHAIN_RETURN(g_parseResult);
+            return g_parseResult;
         }
     } while (0);
     return g_parseResult;
@@ -571,7 +577,7 @@ PtrT_TransactionCheckResult GuiGetPsbtCheckResult(void)
         keys[13].path = "m/48'/1'/0'/2'";
         keys[13].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BTC_MULTI_SIG_P2WSH_TEST);
 #else
-        ExtendedPublicKey keys[5];
+        ExtendedPublicKey keys[9];
         public_keys->data = keys;
         public_keys->size = 4;
         keys[0].path = "m/84'/0'/0'";
@@ -586,6 +592,15 @@ PtrT_TransactionCheckResult GuiGetPsbtCheckResult(void)
         public_keys->size = NUMBER_OF_ARRAYS(keys);
         keys[4].path = "m/44'/60'/0'";
         keys[4].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_AVAX_BIP44_STANDARD);
+        keys[5].path = "m/44'/3'/0'";
+        keys[5].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_DOGE);
+        // ltc、dash、bch
+        keys[6].path = "m/49'/2'/0'";
+        keys[6].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_LTC);
+        keys[7].path = "m/44'/5'/0'";
+        keys[7].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_DASH);
+        keys[8].path = "m/44'/145'/0'";
+        keys[8].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BCH);
 #endif
 #endif
 #ifdef BTC_ONLY
@@ -634,10 +649,36 @@ PtrT_TransactionCheckResult GuiGetPsbtCheckResult(void)
         result = btc_check_msg(crypto, mfp, sizeof(mfp));
     } else if (urType == SeedSignerMessage) {
         result = tx_check_pass();
+    } else if (urType == CryptoPSBTExtend) {
+        PtrT_CSliceFFI_ExtendedPublicKey public_keys = SRAM_MALLOC(sizeof(CSliceFFI_ExtendedPublicKey));
+        ExtendedPublicKey keys[9];
+        public_keys->data = keys;
+        public_keys->size = 4;
+        keys[0].path = "m/84'/0'/0'";
+        keys[0].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BTC_NATIVE_SEGWIT);
+        keys[1].path = "m/49'/0'/0'";
+        keys[1].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BTC);
+        keys[2].path = "m/44'/0'/0'";
+        keys[2].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BTC_LEGACY);
+        keys[3].path = "m/86'/0'/0'";
+        keys[3].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BTC_TAPROOT);
+        public_keys->size = NUMBER_OF_ARRAYS(keys);
+        keys[4].path = "m/44'/60'/0'";
+        keys[4].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_AVAX_BIP44_STANDARD);
+        keys[5].path = "m/44'/3'/0'";
+        keys[5].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_DOGE);
+        // ltc、dash、bch
+        keys[6].path = "m/49'/2'/0'";
+        keys[6].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_LTC);
+        keys[7].path = "m/44'/5'/0'";
+        keys[7].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_DASH);
+        keys[8].path = "m/44'/145'/0'";
+        keys[8].xpub = GetCurrentAccountPublicKey(XPUB_TYPE_BCH);
+        result = utxo_check_psbt_extend(crypto, mfp, sizeof(mfp), public_keys, NULL, NULL);
     }
     return result;
 }
-
+ 
 void GetPsbtTotalOutAmount(void *indata, void *param, uint32_t maxLen)
 {
     DisplayTx *psbt = (DisplayTx *)param;
diff --git a/src/ui/gui_components/gui_status_bar.c b/src/ui/gui_components/gui_status_bar.c
index 5b75cfc..9066a2b 100644
--- a/src/ui/gui_components/gui_status_bar.c
+++ b/src/ui/gui_components/gui_status_bar.c
@@ -393,6 +393,7 @@ const char *GetWalletNameByIndex(WALLET_LIST_INDEX_ENUM index)
 
 uint8_t GetCurrentDisplayPercent(void)
 {
+    return 100;
 #ifdef COMPILE_SIMULATOR
     return 100;
 #endif
diff --git a/src/ui/gui_views/gui_init_view.c b/src/ui/gui_views/gui_init_view.c
index 637d002..43bcd8c 100644
--- a/src/ui/gui_views/gui_init_view.c
+++ b/src/ui/gui_views/gui_init_view.c
@@ -48,8 +48,8 @@ static int32_t GuiInitViewInit(void *param)
     }
 
     if (IsBootVersionMatch() == false) {
-        GuiBootVersionNotMatchWidget();
-        return SUCCESS_CODE;
+        // GuiBootVersionNotMatchWidget();
+        // return SUCCESS_CODE;
     }
     GuiModeGetAccount();
     return SUCCESS_CODE;
diff --git a/ui_simulator/main.c b/ui_simulator/main.c
index b26a68c..368dbc1 100644
--- a/ui_simulator/main.c
+++ b/ui_simulator/main.c
@@ -96,6 +96,10 @@ int main(int argc, char **argv)
     DeviceSettingsInit();
     GuiStyleInit();
     LanguageInit();
+    #include "librust_c.h"
+
+    char *ur = "ur:crypto-psbt-extend/oeadhdcxlkahssqzwfvslofzoxwkrewngotktbmwjkwdcmnefsaaehrlolkskncnktlbaypkaoadkirkbbly";
+    URParseResult *result = parse_ur(ur);
 
     GuiFrameOpenView(&g_initView);
     //  lv_example_calendar_1();
diff --git a/ui_simulator/simulator_model.c b/ui_simulator/simulator_model.c
index e52e343..fcb2be4 100644
--- a/ui_simulator/simulator_model.c
+++ b/ui_simulator/simulator_model.c
@@ -21,7 +21,7 @@ bool g_reboot = false;
 bool g_otpProtect = false;
 
 // Comment out this macro if you need to retrieve data from the file
-#define GET_QR_DATA_FROM_SCREEN
+// #define GET_QR_DATA_FROM_SCREEN
 
 void OTP_PowerOn(void)
 {
@@ -642,11 +642,14 @@ int32_t read_qrcode()
         printf("urResult->error_code: %d\r\n", urResult->error_code);
         break;
     }
+    printf("%s. %d.\n", __func__, __LINE__);
 
     if (urResult->error_code == 0)
     {
+        printf("%s. %d.\n", __func__, __LINE__);
         if (urResult->is_multi_part == 0)
         {
+            printf("%s. %d.\n", __func__, __LINE__);
             // single qr code
             firstQrFlag = true;
             viewType.viewType = urResult->t;