more debugs, prevent unwrap

lib/src/lightwallet.rs

@@ -401,9 +401,21 @@ impl LightWallet {
         let txs_tuples = Vector::read(&mut reader, |r| {
             let mut txid_bytes = [0u8; 32];
             r.read_exact(&mut txid_bytes)?;
-
-            Ok((TxId{0: txid_bytes}, WalletTx::read(r).unwrap()))
+        
+            println!("TxId bytes: {:?}", txid_bytes);
+        
+            match WalletTx::read(r) {
+                Ok(wallet_tx) => {
+                    println!("WalletTx read successfully");
+                    Ok((TxId{0: txid_bytes}, wallet_tx))
+                },
+                Err(e) => {
+                    println!("Error reading WalletTx: {}", e);
+                    Err(e)
+                },
+            }
         })?;
+         
         let txs = txs_tuples.into_iter().collect::<HashMap<TxId, WalletTx>>();
 
         let chain_name = utils::read_string(&mut reader)?;

lib/src/lightwallet/data.rs

@@ -372,41 +372,63 @@ pub struct IncomingTxMetadata {
 impl IncomingTxMetadata {
     pub fn read<R: Read>(mut reader: R) -> io::Result<Self> {
         const MAX_ADDRESS_LENGTH: u64 = 120;
+
         let address_len = reader.read_u64::<LittleEndian>()?;
         println!("Read address length: {}", address_len);
+
         if address_len > MAX_ADDRESS_LENGTH {
+            println!("Address length too large: {}", address_len);
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!("Address length too large: {}", address_len),
             ));
         }
+
         let mut address_bytes = vec![0; address_len as usize];
         reader.read_exact(&mut address_bytes)
             .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, format!("Failed to read address: {}", e)))?;
-        let address = String::from_utf8(address_bytes)
-            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Invalid UTF-8 for address"))?;
+
+        println!("Address bytes: {:?}", address_bytes);
+
+        let address = match String::from_utf8(address_bytes) {
+            Ok(addr) => addr,
+            Err(_) => {
+                println!("Invalid UTF-8 for address");
+                return Err(io::Error::new(io::ErrorKind::InvalidData, "Invalid UTF-8 for address"));
+            }
+        };
+
+        println!("Address: {}", address);
 
         let value = reader.read_u64::<LittleEndian>()?;
-        println!("Read value: {}", value); 
+        println!("Read value: {}", value);
 
-        let incoming_mempool = true; 
-        let position = 0; 
+        let incoming_mempool = true;
+        let position = 0;
 
         let mut memo_bytes = [0u8; 512];
         reader.read_exact(&mut memo_bytes)
             .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, format!("Failed to read memo: {}", e)))?;
-            let memo = match Memo::from_bytes(&memo_bytes) {
-                Some(m) => m,
-                None => return Err(io::Error::new(io::ErrorKind::InvalidData, "Invalid memo")),
-            };
-            
-            Ok(IncomingTxMetadata {
-                address,
-                value,
-                memo,
-                incoming_mempool,
-                position,
-            })            
+
+        println!("Memo bytes: {:?}", memo_bytes);
+
+        let memo = match Memo::from_bytes(&memo_bytes) {
+            Some(m) => m,
+            None => {
+                println!("Invalid memo");
+                return Err(io::Error::new(io::ErrorKind::InvalidData, "Invalid memo"));
+            },
+        };
+
+        println!("Memo: {:?}", memo);
+
+        Ok(IncomingTxMetadata {
+            address,
+            value,
+            memo,
+            incoming_mempool,
+            position,
+        })            
     }
 
     pub fn write<W: Write>(&self, mut writer: W) -> io::Result<()> {