fix: handle Unknown addresses in get.rs to avoid panics

When processing ReturnGet with empty value, the code previously assumed
sender_from_addr was always Some and that addresses were always Known.
This caused panics in CI:
1. expect() on None sender_from_addr
2. .peer() called on PeerKeyLocation with Unknown address

Changes:
- Return error gracefully when sender lookup fails
- Use pub_key() instead of peer() for logging
- Guard tried_peers insertions with socket_addr() checks

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: sanity

crates/core/src/operations/get.rs

@@ -854,16 +854,23 @@ impl Operation for GetOp {
                     let id = *id;
                     let key = *key;
 
-                    // Use sender_from_addr for logging
-                    let sender = sender_from_addr.clone().expect(
-                        "ReturnGet requires sender lookup from connection - source_addr should resolve to known peer",
-                    );
+                    // Handle case where sender lookup failed (e.g., peer disconnected)
+                    let Some(sender) = sender_from_addr.clone() else {
+                        tracing::warn!(
+                            tx = %id,
+                            %key,
+                            source = ?source_addr,
+                            "GET: ReturnGet (empty) received but sender lookup failed - cannot process"
+                        );
+                        return Err(OpError::invalid_transition(self.id));
+                    };
 
+                    // Use pub_key for logging to avoid panics on Unknown addresses
                     tracing::info!(
                         tx = %id,
                         %key,
-                        from = %sender.peer(),
-                        to = %target.peer(),
+                        from = %sender.pub_key(),
+                        to = %target.pub_key(),
                         skip = ?skip_list,
                         "GET: ReturnGet received with empty value"
                     );
@@ -875,7 +882,7 @@ impl Operation for GetOp {
                         %this_peer,
                         "Neither contract or contract value for contract found at peer {}, \
                         retrying with other peers",
-                        sender.peer()
+                        sender.pub_key()
                     );
 
                     match self.state {
@@ -894,8 +901,10 @@ impl Operation for GetOp {
                         }) => {
                             // todo: register in the stats for the outcome of the op that failed to get a response from this peer
 
-                            // Add the failed peer to tried list
-                            tried_peers.insert(sender.peer().clone());
+                            // Add the failed peer to tried list (only if address is known)
+                            if let Some(addr) = sender.socket_addr() {
+                                tried_peers.insert(PeerId::new(addr, sender.pub_key().clone()));
+                            }
 
                             // First, check if we have alternatives at this hop level
                             if !alternatives.is_empty() && attempts_at_hop < DEFAULT_MAX_BREADTH {
@@ -905,7 +914,7 @@ impl Operation for GetOp {
                                 tracing::info!(
                                     tx = %id,
                                     %key,
-                                    next_peer = %next_target.peer(),
+                                    next_peer = %next_target.pub_key(),
                                     fetch_contract,
                                     attempts_at_hop = attempts_at_hop + 1,
                                     max_attempts = DEFAULT_MAX_BREADTH,
@@ -923,8 +932,11 @@ impl Operation for GetOp {
                                     skip_list: tried_peers.clone(),
                                 });
 
-                                // Update state with the new alternative being tried
-                                tried_peers.insert(next_target.peer().clone());
+                                // Update state with the new alternative being tried (only if address is known)
+                                if let Some(addr) = next_target.socket_addr() {
+                                    tried_peers
+                                        .insert(PeerId::new(addr, next_target.pub_key().clone()));
+                                }
                                 let updated_tried_peers = tried_peers.clone();
                                 new_state = Some(GetState::AwaitingResponse {
                                     retries,