Adapt to rename of protocol::authority.

evoskuil · evoskuil · commit eb92795ab7f5 · 2026-01-10T23:03:08.000-05:00
diff --git a/src/protocols/protocol_block_in_106.cpp b/src/protocols/protocol_block_in_106.cpp
@@ -81,14 +81,14 @@ bool protocol_block_in_106::handle_receive_inventory(const code& ec,
     if (!tracker_.ids.empty())
     {
         LOGP("Unrequested (" << block_count << ") block inventory from ["
-            << authority() << "] with (" << tracker_.ids.size()
+            << opposite() << "] with (" << tracker_.ids.size()
             << ") pending.");
         return true;
     }
 
     const auto getter = create_get_data(*message);
     LOGP("Received (" << block_count << ") block inventory from ["
-        << authority() << "] with (" << getter.items.size()
+        << opposite() << "] with (" << getter.items.size()
         << ") new blocks.");
 
     // If getter is empty it may be because we have them all.
@@ -103,12 +103,12 @@ bool protocol_block_in_106::handle_receive_inventory(const code& ec,
 
         // A non-maximal inventory has no new blocks, assume complete.
         // Inventory completeness assumes empty response if caught up at 500.
-        LOGP("Completed block inventory from [" << authority() << "].");
+        LOGP("Completed block inventory from [" << opposite() << "].");
         return true;
     }
 
     LOGP("Requested (" << getter.items.size() << ") blocks from ["
-        << authority() << "].");
+        << opposite() << "].");
 
     // Track inventory and request blocks (to_hashes order is reversed).
     tracker_.announced = block_count;
@@ -136,7 +136,7 @@ bool protocol_block_in_106::handle_receive_block(const code& ec,
     if (tracker_.ids.find(block_ptr->get_hash()) == tracker_.ids.end())
     {
         LOGP("Unrequested block [" << encode_hash(block_ptr->get_hash())
-            << "] from [" << authority() << "].");
+            << "] from [" << opposite() << "].");
         return true;
     }
 
@@ -176,20 +176,20 @@ void protocol_block_in_106::do_handle_organize(const code& ec, size_t height,
             // Many peers blindly broadcast blocks even at/above v31800, ugh.
             // If we are not caught up on headers this is useless information.
             LOGP("Block [" << encode_hash(block_ptr->get_hash()) << "] from ["
-                << authority() << "] " << ec.message());
+                << opposite() << "] " << ec.message());
         }
         else
         {
             LOGR("Block [" << encode_hash(block_ptr->hash()) << ":" << height
-                << "] from [" << authority() << "] " << ec.message());
+                << "] from [" << opposite() << "] " << ec.message());
         }
 
         stop(ec);
         return;
     }
 
     LOGP("Block [" << encode_hash(block_ptr->get_hash()) << ":" << height
-        << "] from [" << authority() << "].");
+        << "] from [" << opposite() << "].");
 
     // Completion of tracked inventory.
     if (tracker_.ids.empty())
@@ -203,7 +203,7 @@ void protocol_block_in_106::do_handle_organize(const code& ec, size_t height,
         {
             // Completeness stalls if on 500 as empty message is ambiguous.
             // This is ok, since complete is not used for anything essential.
-            LOGP("Completed blocks from [" << authority() << "] with ("
+            LOGP("Completed blocks from [" << opposite() << "] with ("
                 << tracker_.announced << ") announced.");
         }
     }
@@ -238,13 +238,13 @@ get_blocks protocol_block_in_106::create_get_inventory(
     if (hashes.size() == one)
     {
         LOGP("Request block inventory after [" << encode_hash(hashes.front())
-            << "] from [" << authority() << "].");
+            << "] from [" << opposite() << "].");
     }
     else
     {
         LOGP("Request block inventory (" << hashes.size() << ") after ["
             << encode_hash(hashes.front()) << "] from ["
-            << authority() << "].");
+            << opposite() << "].");
     }
 
     return { std::move(hashes) };
diff --git a/src/protocols/protocol_block_in_31800.cpp b/src/protocols/protocol_block_in_31800.cpp
@@ -183,7 +183,7 @@ void protocol_block_in_31800::do_purge(peer_t) NOEXCEPT
 
     if (!map_->empty())
     {
-        LOGV("Purge work (" << map_->size() << ") from [" << authority() << "].");
+        LOGV("Purge work (" << map_->size() << ") from [" << opposite() << "].");
         map_->clear();
         stop(error::sacrificed_channel);
     }
@@ -196,7 +196,7 @@ void protocol_block_in_31800::do_split(peer_t) NOEXCEPT
     if (stopped())
         return;
 
-    LOGV("Divide work (" << map_->size() << ") from [" << authority() << "].");
+    LOGV("Divide work (" << map_->size() << ") from [" << opposite() << "].");
     restore(chaser_check::split(map_));
     restore(map_);
     map_ = chaser_check::empty_map();
@@ -209,7 +209,7 @@ void protocol_block_in_31800::do_report(count_t sequence) NOEXCEPT
 
     // Uses application logging since it outputs to a runtime option.
     LOGA("Work report [" << sequence << "] is (" << map_->size() << ") for ["
-        << authority() << "].");
+        << opposite() << "].");
 }
 
 // request hashes
@@ -279,7 +279,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,
     {
         // Allow unrequested block, not counted toward performance.
         LOGR("Unrequested block [" << encode_hash(hash) << "] from ["
-            << authority() << "].");
+            << opposite() << "].");
         return true;
     }
 
@@ -302,7 +302,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,
             code == system::error::invalid_witness_commitment)
         {
             LOGR("Malleated block [" << encode_hash(hash) << ":" << height
-                << "] from [" << authority() << "] " << code.message()
+                << "] from [" << opposite() << "] " << code.message()
                 << " txs(" << block->transactions() << ")"
                 << " segregated(" << block->is_segregated() << ").");
             stop(code);
@@ -316,7 +316,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,
         }
 
         LOGR("Block failed check [" << encode_hash(hash) << ":" << height
-            << "] from [" << authority() << "] " << code.message());
+            << "] from [" << opposite() << "] " << code.message());
         notify(error::success, chase::unchecked, link);
         fire(events::block_unconfirmable, height);
         stop(code);
@@ -329,7 +329,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,
     if (const auto code = query.set_code(*block, link, checked))
     {
         LOGF("Failure storing block [" << encode_hash(hash) << ":" << height
-            << "] from [" << authority() << "] " << code.message());
+            << "] from [" << opposite() << "] " << code.message());
 
         stop(fault(code));
         return false;
@@ -339,7 +339,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,
     // ........................................................................
 
     LOGP("Downloaded block [" << encode_hash(hash) << ":" << height
-        << "] from [" << authority() << "].");
+        << "] from [" << opposite() << "].");
 
     notify(ec, chase::checked, height);
     fire(events::block_archived, height);
@@ -388,18 +388,18 @@ void protocol_block_in_31800::restore(const map_ptr& map) NOEXCEPT
 void protocol_block_in_31800::handle_put_hashes(const code& ec,
     size_t count) NOEXCEPT
 {
-    LOGV("Put (" << count << ") work for [" << authority() << "].");
+    LOGV("Put (" << count << ") work for [" << opposite() << "].");
 
     if (ec)
     {
-        LOGF("Error putting work for [" << authority() << "] " << ec.message());
+        LOGF("Error putting work for [" << opposite() << "] " << ec.message());
     }
 }
 
 void protocol_block_in_31800::handle_get_hashes(const code& ec,
     const map_ptr& map, const job::ptr& job) NOEXCEPT
 {
-    LOGV("Got (" << map->size() << ") work for [" << authority() << "].");
+    LOGV("Got (" << map->size() << ") work for [" << opposite() << "].");
 
     if (stopped())
     {
@@ -409,7 +409,7 @@ void protocol_block_in_31800::handle_get_hashes(const code& ec,
 
     if (ec)
     {
-        LOGF("Error getting work for [" << authority() << "] " << ec.message());
+        LOGF("Error getting work for [" << opposite() << "] " << ec.message());
         stop(ec);
         return;
     }
diff --git a/src/protocols/protocol_block_out_106.cpp b/src/protocols/protocol_block_out_106.cpp
@@ -131,7 +131,7 @@ bool protocol_block_out_106::handle_receive_get_blocks(const code& ec,
         return false;
 
     LOGP("Get headers above " << encode_hash(message->start_hash())
-        << " from [" << authority() << "].");
+        << " from [" << opposite() << "].");
 
     SEND(create_inventory(*message), handle_send, _1);
     return true;
@@ -178,7 +178,7 @@ void protocol_block_out_106::send_block(const code& ec, size_t index,
     const auto witness = item.is_witness_type();
     if (!node_witness_ && witness)
     {
-        LOGR("Unsupported witness get_data from [" << authority() << "].");
+        LOGR("Unsupported witness get_data from [" << opposite() << "].");
         stop(network::error::protocol_violation);
         return;
     }
@@ -192,7 +192,7 @@ void protocol_block_out_106::send_block(const code& ec, size_t index,
     if (!ptr)
     {
         LOGR("Requested block " << encode_hash(item.hash)
-            << " from [" << authority() << "] not found.");
+            << " from [" << opposite() << "] not found.");
 
         // This block could not have been advertised to the peer.
         stop(system::error::not_found);
diff --git a/src/protocols/protocol_header_in_31800.cpp b/src/protocols/protocol_header_in_31800.cpp
@@ -63,7 +63,7 @@ bool protocol_header_in_31800::handle_receive_headers(const code& ec,
         return false;
 
     LOGP("Headers (" << message->header_ptrs.size() << ") from ["
-        << authority() << "].");
+        << opposite() << "].");
 
     // Store each header, drop channel if invalid.
     for (const auto& ptr: message->header_ptrs)
@@ -89,7 +89,7 @@ bool protocol_header_in_31800::handle_receive_headers(const code& ec,
     {
         // Protocol presumes max_get_headers unless complete.
         // Completeness assumes empty response from peer if caught up at 2000.
-        LOGP("Completed headers from [" << authority() << "].");
+        LOGP("Completed headers from [" << opposite() << "].");
         complete();
     }
 
@@ -111,20 +111,20 @@ void protocol_header_in_31800::handle_organize(const code& ec,
         if (is_zero(height))
         {
             LOGP("Header [" << encode_hash(header_ptr->get_hash()) << "] from ["
-                << authority() << "] " << ec.message());
+                << opposite() << "] " << ec.message());
         }
         else
         {
             LOGR("Header [" << encode_hash(header_ptr->get_hash()) << ":"
-                << height << "] from [" << authority() << "] " << ec.message());
+                << height << "] from [" << opposite() << "] " << ec.message());
         }
 
         stop(ec);
         return;
     }
 
     LOGP("Header [" << encode_hash(header_ptr->get_hash()) << ":" << height
-        << "] from [" << authority() << "] " << ec.message());
+        << "] from [" << opposite() << "] " << ec.message());
 }
 
 // This could be the end of a catch-up sequence, or a singleton announcement.
@@ -138,7 +138,7 @@ void protocol_header_in_31800::complete() NOEXCEPT
     {
         subscribed = true;
         SUBSCRIBE_CHANNEL(inventory, handle_receive_inventory, _1, _2);
-        LOGP("Subscribed to block announcements at [" << authority() << "].");
+        LOGP("Subscribed to block announcements at [" << opposite() << "].");
     }
 }
 
@@ -199,13 +199,13 @@ get_headers protocol_header_in_31800::create_get_headers(
     if (is_one(hashes.size()))
     {
         LOGP("Request headers after [" << encode_hash(hashes.front())
-            << "] from [" << authority() << "].");
+            << "] from [" << opposite() << "].");
     }
     else
     {
-        LOGP("Request headers (" << hashes.size() << ") after ["
-            << encode_hash(hashes.front()) << "] from ["
-            << authority() << "].");
+        LOGP("Request headers (" << hashes.size()
+            << ") after [" << encode_hash(hashes.front())
+            << "] from [" << opposite() << "].");
     }
 
     return { std::move(hashes) };
diff --git a/src/protocols/protocol_header_in_70012.cpp b/src/protocols/protocol_header_in_70012.cpp
@@ -36,7 +36,7 @@ void protocol_header_in_70012::complete() NOEXCEPT
     {
         subscribed = true;
         SEND(send_headers{}, handle_send, _1);
-        LOGP("Subscribed to header announcements at [" << authority() << "].");
+        LOGP("Subscribed to header announcements at [" << opposite() << "].");
     }
 
     // Must come after subscribed is updated.
diff --git a/src/protocols/protocol_header_out_31800.cpp b/src/protocols/protocol_header_out_31800.cpp
@@ -60,7 +60,7 @@ bool protocol_header_out_31800::handle_receive_get_headers(const code& ec,
         return false;
 
     LOGP("Get headers above " << encode_hash(message->start_hash())
-        << " from [" << authority() << "].");
+        << " from [" << opposite() << "].");
 
     SEND(create_headers(*message), handle_send, _1);
     return true;
diff --git a/src/protocols/protocol_header_out_70012.cpp b/src/protocols/protocol_header_out_70012.cpp
@@ -100,7 +100,7 @@ bool protocol_header_out_70012::do_announce(header_t link) NOEXCEPT
     if (was_announced(hash))
     {
         LOGP("Suppress " << encode_hash(hash) << " to ["
-            << authority() << "].");
+            << opposite() << "].");
         return true;
     }
 
@@ -112,7 +112,7 @@ bool protocol_header_out_70012::do_announce(header_t link) NOEXCEPT
         return true;
     }
 
-    LOGN("Announce " << encode_hash(hash) << " to [" << authority() << "].");
+    LOGN("Announce " << encode_hash(hash) << " to [" << opposite() << "].");
     SEND(headers{ { ptr } }, handle_send, _1);
     return true;
 }
diff --git a/src/protocols/protocol_observer.cpp b/src/protocols/protocol_observer.cpp
@@ -109,7 +109,7 @@ bool protocol_observer::handle_receive_inventory(const code& ec,
     //  Common with Satoshi 25.0 and 25.1.
     if (relay_disallowed_ && message->any_transaction())
     {
-        LOGR("Unrequested tx relay from [" << authority() << "] "
+        LOGR("Unrequested tx relay from [" << opposite() << "] "
             << peer_version()->user_agent);
 
         stop(network::error::protocol_violation);
@@ -119,7 +119,7 @@ bool protocol_observer::handle_receive_inventory(const code& ec,
     ////// Witness types never allowed in inventory (wxtid excluded).
     ////if (message->any_witness())
     ////{
-    ////    LOGR("Unsupported witness inventory from [" << authority() << "].");
+    ////    LOGR("Unsupported witness inventory from [" << opposite() << "].");
     ////    stop(network::error::protocol_violation);
     ////    return false;
     ////}
@@ -138,7 +138,7 @@ bool protocol_observer::handle_receive_inventory(const code& ec,
 ////    // Witness types only allowed in get_data if witness service advertised.
 ////    if (!node_witness_ && message->any_witness())
 ////    {
-////        LOGR("Unsupported witness get_data from [" << authority() << "].");
+////        LOGR("Unsupported witness get_data from [" << authority42() << "].");
 ////        stop(network::error::protocol_violation);
 ////        return false;
 ////    }
diff --git a/src/protocols/protocol_performer.cpp b/src/protocols/protocol_performer.cpp
@@ -135,14 +135,14 @@ void protocol_performer::do_handle_performance(const code& ec) NOEXCEPT
     // Caused only by performance(zero|xxx) - had outstanding work.
     if (ec == error::stalled_channel || ec == error::slow_channel)
     {
-        LOGP("Channel dropped [" << authority() << "] " << ec.message());
+        LOGP("Channel dropped [" << opposite() << "] " << ec.message());
         stop(ec);
         return;
     }
 
     if (ec)
     {
-        LOGF("Performance failure [" << authority() << "] " << ec.message());
+        LOGF("Performance failure [" << opposite() << "] " << ec.message());
         stop(ec);
         return;
     }
diff --git a/src/protocols/protocol_transaction_out_106.cpp b/src/protocols/protocol_transaction_out_106.cpp
@@ -163,7 +163,7 @@ void protocol_transaction_out_106::send_transaction(const code& ec,
     const auto witness = item.is_witness_type();
     if (!node_witness_ && witness)
     {
-        LOGR("Unsupported witness get_data from [" << authority() << "].");
+        LOGR("Unsupported witness get_data from [" << opposite() << "].");
         stop(network::error::protocol_violation);
         return;
     }
@@ -176,7 +176,7 @@ void protocol_transaction_out_106::send_transaction(const code& ec,
     if (!ptr)
     {
         LOGR("Requested tx " << encode_hash(item.hash)
-            << " from [" << authority() << "] not found.");
+            << " from [" << opposite() << "] not found.");
 
         // This tx could not have been advertised to the peer.
         stop(system::error::not_found);

Original file line number	Diff line number	Diff line change
`@@ -81,14 +81,14 @@ bool protocol_block_in_106::handle_receive_inventory(const code& ec,`
`81`	`81`	`if (!tracker_.ids.empty())`
`82`	`82`	`{`
`83`	`83`	`LOGP("Unrequested (" << block_count << ") block inventory from ["`
`84`		`- << authority() << "] with (" << tracker_.ids.size()`
	`84`	`+ << opposite() << "] with (" << tracker_.ids.size()`
`85`	`85`	`<< ") pending.");`
`86`	`86`	`return true;`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`const auto getter = create_get_data(*message);`
`90`	`90`	`LOGP("Received (" << block_count << ") block inventory from ["`
`91`		`- << authority() << "] with (" << getter.items.size()`
	`91`	`+ << opposite() << "] with (" << getter.items.size()`
`92`	`92`	`<< ") new blocks.");`
`93`	`93`
`94`	`94`	`// If getter is empty it may be because we have them all.`
`@@ -103,12 +103,12 @@ bool protocol_block_in_106::handle_receive_inventory(const code& ec,`
`103`	`103`
`104`	`104`	`// A non-maximal inventory has no new blocks, assume complete.`
`105`	`105`	`// Inventory completeness assumes empty response if caught up at 500.`
`106`		`- LOGP("Completed block inventory from [" << authority() << "].");`
	`106`	`+ LOGP("Completed block inventory from [" << opposite() << "].");`
`107`	`107`	`return true;`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`LOGP("Requested (" << getter.items.size() << ") blocks from ["`
`111`		`- << authority() << "].");`
	`111`	`+ << opposite() << "].");`
`112`	`112`
`113`	`113`	`// Track inventory and request blocks (to_hashes order is reversed).`
`114`	`114`	`tracker_.announced = block_count;`
`@@ -136,7 +136,7 @@ bool protocol_block_in_106::handle_receive_block(const code& ec,`
`136`	`136`	`if (tracker_.ids.find(block_ptr->get_hash()) == tracker_.ids.end())`
`137`	`137`	`{`
`138`	`138`	`LOGP("Unrequested block [" << encode_hash(block_ptr->get_hash())`
`139`		`- << "] from [" << authority() << "].");`
	`139`	`+ << "] from [" << opposite() << "].");`
`140`	`140`	`return true;`
`141`	`141`	`}`
`142`	`142`
`@@ -176,20 +176,20 @@ void protocol_block_in_106::do_handle_organize(const code& ec, size_t height,`
`176`	`176`	`// Many peers blindly broadcast blocks even at/above v31800, ugh.`
`177`	`177`	`// If we are not caught up on headers this is useless information.`
`178`	`178`	`LOGP("Block [" << encode_hash(block_ptr->get_hash()) << "] from ["`
`179`		`- << authority() << "] " << ec.message());`
	`179`	`+ << opposite() << "] " << ec.message());`
`180`	`180`	`}`
`181`	`181`	`else`
`182`	`182`	`{`
`183`	`183`	`LOGR("Block [" << encode_hash(block_ptr->hash()) << ":" << height`
`184`		`- << "] from [" << authority() << "] " << ec.message());`
	`184`	`+ << "] from [" << opposite() << "] " << ec.message());`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`stop(ec);`
`188`	`188`	`return;`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`LOGP("Block [" << encode_hash(block_ptr->get_hash()) << ":" << height`
`192`		`- << "] from [" << authority() << "].");`
	`192`	`+ << "] from [" << opposite() << "].");`
`193`	`193`
`194`	`194`	`// Completion of tracked inventory.`
`195`	`195`	`if (tracker_.ids.empty())`
`@@ -203,7 +203,7 @@ void protocol_block_in_106::do_handle_organize(const code& ec, size_t height,`
`203`	`203`	`{`
`204`	`204`	`// Completeness stalls if on 500 as empty message is ambiguous.`
`205`	`205`	`// This is ok, since complete is not used for anything essential.`
`206`		`- LOGP("Completed blocks from [" << authority() << "] with ("`
	`206`	`+ LOGP("Completed blocks from [" << opposite() << "] with ("`
`207`	`207`	`<< tracker_.announced << ") announced.");`
`208`	`208`	`}`
`209`	`209`	`}`
`@@ -238,13 +238,13 @@ get_blocks protocol_block_in_106::create_get_inventory(`
`238`	`238`	`if (hashes.size() == one)`
`239`	`239`	`{`
`240`	`240`	`LOGP("Request block inventory after [" << encode_hash(hashes.front())`
`241`		`- << "] from [" << authority() << "].");`
	`241`	`+ << "] from [" << opposite() << "].");`
`242`	`242`	`}`
`243`	`243`	`else`
`244`	`244`	`{`
`245`	`245`	`LOGP("Request block inventory (" << hashes.size() << ") after ["`
`246`	`246`	`<< encode_hash(hashes.front()) << "] from ["`
`247`		`- << authority() << "].");`
	`247`	`+ << opposite() << "].");`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`return { std::move(hashes) };`
Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ void protocol_block_in_31800::do_purge(peer_t) NOEXCEPT`
`183`	`183`
`184`	`184`	`if (!map_->empty())`
`185`	`185`	`{`
`186`		`- LOGV("Purge work (" << map_->size() << ") from [" << authority() << "].");`
	`186`	`+ LOGV("Purge work (" << map_->size() << ") from [" << opposite() << "].");`
`187`	`187`	`map_->clear();`
`188`	`188`	`stop(error::sacrificed_channel);`
`189`	`189`	`}`
`@@ -196,7 +196,7 @@ void protocol_block_in_31800::do_split(peer_t) NOEXCEPT`
`196`	`196`	`if (stopped())`
`197`	`197`	`return;`
`198`	`198`
`199`		`- LOGV("Divide work (" << map_->size() << ") from [" << authority() << "].");`
	`199`	`+ LOGV("Divide work (" << map_->size() << ") from [" << opposite() << "].");`
`200`	`200`	`restore(chaser_check::split(map_));`
`201`	`201`	`restore(map_);`
`202`	`202`	`map_ = chaser_check::empty_map();`
`@@ -209,7 +209,7 @@ void protocol_block_in_31800::do_report(count_t sequence) NOEXCEPT`
`209`	`209`
`210`	`210`	`// Uses application logging since it outputs to a runtime option.`
`211`	`211`	`LOGA("Work report [" << sequence << "] is (" << map_->size() << ") for ["`
`212`		`- << authority() << "].");`
	`212`	`+ << opposite() << "].");`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`// request hashes`
`@@ -279,7 +279,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,`
`279`	`279`	`{`
`280`	`280`	`// Allow unrequested block, not counted toward performance.`
`281`	`281`	`LOGR("Unrequested block [" << encode_hash(hash) << "] from ["`
`282`		`- << authority() << "].");`
	`282`	`+ << opposite() << "].");`
`283`	`283`	`return true;`
`284`	`284`	`}`
`285`	`285`
`@@ -302,7 +302,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,`
`302`	`302`	`code == system::error::invalid_witness_commitment)`
`303`	`303`	`{`
`304`	`304`	`LOGR("Malleated block [" << encode_hash(hash) << ":" << height`
`305`		`- << "] from [" << authority() << "] " << code.message()`
	`305`	`+ << "] from [" << opposite() << "] " << code.message()`
`306`	`306`	`<< " txs(" << block->transactions() << ")"`
`307`	`307`	`<< " segregated(" << block->is_segregated() << ").");`
`308`	`308`	`stop(code);`
`@@ -316,7 +316,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,`
`316`	`316`	`}`
`317`	`317`
`318`	`318`	`LOGR("Block failed check [" << encode_hash(hash) << ":" << height`
`319`		`- << "] from [" << authority() << "] " << code.message());`
	`319`	`+ << "] from [" << opposite() << "] " << code.message());`
`320`	`320`	`notify(error::success, chase::unchecked, link);`
`321`	`321`	`fire(events::block_unconfirmable, height);`
`322`	`322`	`stop(code);`
`@@ -329,7 +329,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,`
`329`	`329`	`if (const auto code = query.set_code(*block, link, checked))`
`330`	`330`	`{`
`331`	`331`	`LOGF("Failure storing block [" << encode_hash(hash) << ":" << height`
`332`		`- << "] from [" << authority() << "] " << code.message());`
	`332`	`+ << "] from [" << opposite() << "] " << code.message());`
`333`	`333`
`334`	`334`	`stop(fault(code));`
`335`	`335`	`return false;`
`@@ -339,7 +339,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec,`
`339`	`339`	`// ........................................................................`
`340`	`340`
`341`	`341`	`LOGP("Downloaded block [" << encode_hash(hash) << ":" << height`
`342`		`- << "] from [" << authority() << "].");`
	`342`	`+ << "] from [" << opposite() << "].");`
`343`	`343`
`344`	`344`	`notify(ec, chase::checked, height);`
`345`	`345`	`fire(events::block_archived, height);`
`@@ -388,18 +388,18 @@ void protocol_block_in_31800::restore(const map_ptr& map) NOEXCEPT`
`388`	`388`	`void protocol_block_in_31800::handle_put_hashes(const code& ec,`
`389`	`389`	`size_t count) NOEXCEPT`
`390`	`390`	`{`
`391`		`- LOGV("Put (" << count << ") work for [" << authority() << "].");`
	`391`	`+ LOGV("Put (" << count << ") work for [" << opposite() << "].");`
`392`	`392`
`393`	`393`	`if (ec)`
`394`	`394`	`{`
`395`		`- LOGF("Error putting work for [" << authority() << "] " << ec.message());`
	`395`	`+ LOGF("Error putting work for [" << opposite() << "] " << ec.message());`
`396`	`396`	`}`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`void protocol_block_in_31800::handle_get_hashes(const code& ec,`
`400`	`400`	`const map_ptr& map, const job::ptr& job) NOEXCEPT`
`401`	`401`	`{`
`402`		`- LOGV("Got (" << map->size() << ") work for [" << authority() << "].");`
	`402`	`+ LOGV("Got (" << map->size() << ") work for [" << opposite() << "].");`
`403`	`403`
`404`	`404`	`if (stopped())`
`405`	`405`	`{`
`@@ -409,7 +409,7 @@ void protocol_block_in_31800::handle_get_hashes(const code& ec,`
`409`	`409`
`410`	`410`	`if (ec)`
`411`	`411`	`{`
`412`		`- LOGF("Error getting work for [" << authority() << "] " << ec.message());`
	`412`	`+ LOGF("Error getting work for [" << opposite() << "] " << ec.message());`
`413`	`413`	`stop(ec);`
`414`	`414`	`return;`
`415`	`415`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ bool protocol_header_in_31800::handle_receive_headers(const code& ec,`
`63`	`63`	`return false;`
`64`	`64`
`65`	`65`	`LOGP("Headers (" << message->header_ptrs.size() << ") from ["`
`66`		`- << authority() << "].");`
	`66`	`+ << opposite() << "].");`
`67`	`67`
`68`	`68`	`// Store each header, drop channel if invalid.`
`69`	`69`	`for (const auto& ptr: message->header_ptrs)`
`@@ -89,7 +89,7 @@ bool protocol_header_in_31800::handle_receive_headers(const code& ec,`
`89`	`89`	`{`
`90`	`90`	`// Protocol presumes max_get_headers unless complete.`
`91`	`91`	`// Completeness assumes empty response from peer if caught up at 2000.`
`92`		`- LOGP("Completed headers from [" << authority() << "].");`
	`92`	`+ LOGP("Completed headers from [" << opposite() << "].");`
`93`	`93`	`complete();`
`94`	`94`	`}`
`95`	`95`
`@@ -111,20 +111,20 @@ void protocol_header_in_31800::handle_organize(const code& ec,`
`111`	`111`	`if (is_zero(height))`
`112`	`112`	`{`
`113`	`113`	`LOGP("Header [" << encode_hash(header_ptr->get_hash()) << "] from ["`
`114`		`- << authority() << "] " << ec.message());`
	`114`	`+ << opposite() << "] " << ec.message());`
`115`	`115`	`}`
`116`	`116`	`else`
`117`	`117`	`{`
`118`	`118`	`LOGR("Header [" << encode_hash(header_ptr->get_hash()) << ":"`
`119`		`- << height << "] from [" << authority() << "] " << ec.message());`
	`119`	`+ << height << "] from [" << opposite() << "] " << ec.message());`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`stop(ec);`
`123`	`123`	`return;`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`LOGP("Header [" << encode_hash(header_ptr->get_hash()) << ":" << height`
`127`		`- << "] from [" << authority() << "] " << ec.message());`
	`127`	`+ << "] from [" << opposite() << "] " << ec.message());`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`// This could be the end of a catch-up sequence, or a singleton announcement.`
`@@ -138,7 +138,7 @@ void protocol_header_in_31800::complete() NOEXCEPT`
`138`	`138`	`{`
`139`	`139`	`subscribed = true;`
`140`	`140`	`SUBSCRIBE_CHANNEL(inventory, handle_receive_inventory, _1, _2);`
`141`		`- LOGP("Subscribed to block announcements at [" << authority() << "].");`
	`141`	`+ LOGP("Subscribed to block announcements at [" << opposite() << "].");`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`@@ -199,13 +199,13 @@ get_headers protocol_header_in_31800::create_get_headers(`
`199`	`199`	`if (is_one(hashes.size()))`
`200`	`200`	`{`
`201`	`201`	`LOGP("Request headers after [" << encode_hash(hashes.front())`
`202`		`- << "] from [" << authority() << "].");`
	`202`	`+ << "] from [" << opposite() << "].");`
`203`	`203`	`}`
`204`	`204`	`else`
`205`	`205`	`{`
`206`		`- LOGP("Request headers (" << hashes.size() << ") after ["`
`207`		`- << encode_hash(hashes.front()) << "] from ["`
`208`		`- << authority() << "].");`
	`206`	`+ LOGP("Request headers (" << hashes.size()`
	`207`	`+ << ") after [" << encode_hash(hashes.front())`
	`208`	`+ << "] from [" << opposite() << "].");`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`return { std::move(hashes) };`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ void protocol_header_in_70012::complete() NOEXCEPT`
`36`	`36`	`{`
`37`	`37`	`subscribed = true;`
`38`	`38`	`SEND(send_headers{}, handle_send, _1);`
`39`		`- LOGP("Subscribed to header announcements at [" << authority() << "].");`
	`39`	`+ LOGP("Subscribed to header announcements at [" << opposite() << "].");`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`// Must come after subscribed is updated.`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ bool protocol_header_out_70012::do_announce(header_t link) NOEXCEPT`
`100`	`100`	`if (was_announced(hash))`
`101`	`101`	`{`
`102`	`102`	`LOGP("Suppress " << encode_hash(hash) << " to ["`
`103`		`- << authority() << "].");`
	`103`	`+ << opposite() << "].");`
`104`	`104`	`return true;`
`105`	`105`	`}`
`106`	`106`
`@@ -112,7 +112,7 @@ bool protocol_header_out_70012::do_announce(header_t link) NOEXCEPT`
`112`	`112`	`return true;`
`113`	`113`	`}`
`114`	`114`
`115`		`- LOGN("Announce " << encode_hash(hash) << " to [" << authority() << "].");`
	`115`	`+ LOGN("Announce " << encode_hash(hash) << " to [" << opposite() << "].");`
`116`	`116`	`SEND(headers{ { ptr } }, handle_send, _1);`
`117`	`117`	`return true;`
`118`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,14 +135,14 @@ void protocol_performer::do_handle_performance(const code& ec) NOEXCEPT`
`135`	`135`	`// Caused only by performance(zero\|xxx) - had outstanding work.`
`136`	`136`	`if (ec == error::stalled_channel \|\| ec == error::slow_channel)`
`137`	`137`	`{`
`138`		`- LOGP("Channel dropped [" << authority() << "] " << ec.message());`
	`138`	`+ LOGP("Channel dropped [" << opposite() << "] " << ec.message());`
`139`	`139`	`stop(ec);`
`140`	`140`	`return;`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`if (ec)`
`144`	`144`	`{`
`145`		`- LOGF("Performance failure [" << authority() << "] " << ec.message());`
	`145`	`+ LOGF("Performance failure [" << opposite() << "] " << ec.message());`
`146`	`146`	`stop(ec);`
`147`	`147`	`return;`
`148`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ void protocol_transaction_out_106::send_transaction(const code& ec,`
`163`	`163`	`const auto witness = item.is_witness_type();`
`164`	`164`	`if (!node_witness_ && witness)`
`165`	`165`	`{`
`166`		`- LOGR("Unsupported witness get_data from [" << authority() << "].");`
	`166`	`+ LOGR("Unsupported witness get_data from [" << opposite() << "].");`
`167`	`167`	`stop(network::error::protocol_violation);`
`168`	`168`	`return;`
`169`	`169`	`}`
`@@ -176,7 +176,7 @@ void protocol_transaction_out_106::send_transaction(const code& ec,`
`176`	`176`	`if (!ptr)`
`177`	`177`	`{`
`178`	`178`	`LOGR("Requested tx " << encode_hash(item.hash)`
`179`		`- << " from [" << authority() << "] not found.");`
	`179`	`+ << " from [" << opposite() << "] not found.");`
`180`	`180`
`181`	`181`	`// This tx could not have been advertised to the peer.`
`182`	`182`	`stop(system::error::not_found);`