                         ;; instead.
                         ;; That destroys functional purity, so is not
                         ;; an option.
-                        (log2/flush-logs! logger
-                                          (log2/info internal-log-state
-                                                     ::succeeded
-                                                     "Forwarded"
-                                                     {::buffer-size size
-                                                      ::specs/send-buf send-buf
-                                                      ::send-from triggerer
-                                                      ::success succeeded})))
+                        (log/flush-logs! logger
+                                         (log/info internal-log-state
+                                                   ::succeeded
+                                                   "Forwarded"
+                                                   {::buffer-size size
+                                                    ::specs/send-buf send-buf
+                                                    ::send-from triggerer
+                                                    ::success succeeded})))
                       (fn [failed]
-                        (log2/flush-logs! logger
-                                          (log2/error internal-log-state
-                                                      ::failed
-                                                      ;; This will trigger again, won't
-                                                      ;; it? (i.e. we'll keep trying to
-                                                      ;; send until we get an ACK)
-                                                      "Forwarding. Q: Do we care?"
-                                                      {::buffer-size size
-                                                       ::specs/send-buf send-buf
-                                                       ::send-from triggerer
-                                                       ::failure failed}))))
+                        (log/flush-logs! logger
+                                         (log/error internal-log-state
+                                                    ::failed
+                                                    ;; This will trigger again, won't
+                                                    ;; it? (i.e. we'll keep trying to
+                                                    ;; send until we get an ACK)
+                                                    "Forwarding. Q: Do we care?"
+                                                    {::buffer-size size
+                                                     ::specs/send-buf send-buf
+                                                     ::send-from triggerer
+                                                     ::failure failed}))))
     caller-log-state))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (let [size (count send-buf)
        succeeded? (dfrd/future (->parent send-buf))
        triggerer (utils/pre-log message-loop-name)
        [caller-log-state internal-log-state] (log2/fork log-state ::block->parent!)]
    (dfrd/on-realized succeeded?
                      (fn [succeeded]
                        ;; If I'm going to set send-eof-processed,

                ;; And this seems like the most obvious location.
                log-state (as-> (if (s/valid? ::specs/send-buf send-buf)
                                  log-state
                                  (log/warn log-state
                                            label
                                            "Illegal outgoing buffer"
                                            {::problem (s/explain-data ::specs/send-buf send-buf)}))
                              log-state
                            (log/debug log-state
                                       label
                                       "Sending bytes to parent"
                                       {::buffer-size n
                                        ::specs/send-buf send-buf})
                            ;; TODO: This includes one of the side-effects that I really should
                            ;; be accumulating rather than calling willy-nilly.
                            (block->parent! message-loop-name logger log-state ->parent send-buf)
                            (log/debug log-state
                                       label
                                       (str "Calculating earliest time among un-ACK'd block(s)"
                                            "\n(totally distinct from un-sent)")
                                       {::un-ackd-block-count (count un-ackd-blocks)
                                        ::un-sent-block-count (count (get-in state''
                                                                             [::specs/outgoing ::specs/un-sent-blocks]))}))]
;;;      408: earliestblocktime_compute()
            (-> (assoc state'' ::log/state log-state)
                (assoc-in [::specs/outgoing ::specs/earliest-time]
                          (help/earliest-block-time message-loop-name un-ackd-blocks))
                (update ::specs/outgoing dissoc ::specs/next-block-queue)))
