diag: Log adaptor message routing on both sides.

The adaptor setup phase flows silently through the server (AuthManager
only logs handling failures, not successes) and through the client
runJob loop (which logs only when a handler takes >=250ms). That
makes it hard to diagnose a stuck swap: a participant that never
receives the relayed AdaptorLocked looks identical to one where the
inbound handler is blocked inside the cgo XMR wallet.

Add four log lines, all at INFO, to distinguish those cases on the
next simnet run:

- client handleAdaptorMsg: log route + matchID on entry, and route +
  matchID + dispatch elapsed time + err on exit.

- server AdaptorCoordinators.Handle: log the inbound route + matchID +
  phase before c.Handle, and the resulting phase + err after.

- server dex.adaptorRouter: log each outbound relay (route, matchID,
  role, user, err).

No behavior change. Test rig Core{} in TestHandleAdaptorMsg now sets
log: tLogger so handleAdaptorMsg doesn't nil-deref the logger.

Revert (or downgrade to Tracef) once the simnet swap is green.

Author: JoeGruffins

client/core/adaptorswap_bridge.go

@@ -493,7 +493,16 @@ func handleAdaptorMsg(c *Core, _ *dexConnection, msg *msgjson.Message) error {
 	if err != nil {
 		return fmt.Errorf("decode %s: %w", msg.Route, err)
 	}
-	if err := c.adaptorMgr.Handle(msg.Route, matchID, payload); err != nil {
+	// Diagnostic: make the inbound adaptor route + dispatch outcome
+	// visible in the log so stuck handlers (e.g. a blocked XMR send)
+	// can be distinguished from dropped messages. Matched by the
+	// dispatch-complete log below.
+	c.log.Infof("adaptor msg inbound route=%s match=%s", msg.Route, matchID)
+	start := time.Now()
+	err = c.adaptorMgr.Handle(msg.Route, matchID, payload)
+	c.log.Infof("adaptor msg dispatch route=%s match=%s elapsed=%s err=%v",
+		msg.Route, matchID, time.Since(start), err)
+	if err != nil {
 		if IsInformational(err) {
 			return nil
 		}

client/core/adaptorswap_bridge_test.go

@@ -153,7 +153,7 @@ func TestHandleAdaptorMsg(t *testing.T) {
 	mgr := NewAdaptorSwapManager(&AdaptorSwapManagerConfig{
 		BTC: &bridgeFakeBTC{}, XMR: &bridgeFakeXMR{}, Send: sender,
 	})
-	c := &Core{adaptorMgr: mgr}
+	c := &Core{adaptorMgr: mgr, log: tLogger}
 
 	matchID := order.MatchID{0xAB}
 	if _, err := mgr.StartSwap(&adaptorswap.Config{

server/dex/dex.go

@@ -1038,7 +1038,13 @@ func NewDEX(ctx context.Context, cfg *DexConf) (*DEX, error) {
 		if err != nil {
 			return fmt.Errorf("adaptor router: NewNotification: %w", err)
 		}
-		return authMgr.Send(user, msg)
+		// Diagnostic: log each outbound relay so operators can see
+		// whether a Send failed (user offline, link broken) versus
+		// the participant's handler dropping a delivered message.
+		sendErr := authMgr.Send(user, msg)
+		log.Infof("adaptor router relayed route=%s match=%s to role=%s (user=%s): err=%v",
+			route, matchID, role, user, sendErr)
+		return sendErr
 	})
 	adaptorCoords = swap.NewAdaptorCoordinators(adaptor.Config{
 		Router:  adaptorRouter,

server/swap/adaptor_bridge.go

@@ -105,7 +105,16 @@ func (cc *AdaptorCoordinators) Handle(route string, matchID order.MatchID, paylo
 	if err != nil {
 		return err
 	}
-	return c.Handle(evt)
+	// Diagnostic: make inbound adaptor events visible in the server log
+	// and report whether the coordinator accepted them. Lets the
+	// operator tell "message never arrived" apart from "coordinator
+	// rejected it".
+	log.Infof("adaptor coordinator inbound route=%s match=%s phase=%s",
+		route, matchID, c.Phase())
+	err = c.Handle(evt)
+	log.Infof("adaptor coordinator dispatched route=%s match=%s phase=%s err=%v",
+		route, matchID, c.Phase(), err)
+	return err
 }
 
 // Dispatch feeds a non-message event (chain observation, timeout)