       ;; It kind-of made sense with the original approach, which involved
       ;; locking down strict access from a single thread, using an agent.
       ;; Note that this approach is worse than I thought at first glance:
-      ;; I'm really just reusing the last-used nonce.
-      ;; That seems wrong all around.
-      ;; c.f. lines 329-334.
+      ;; I'm really just reusing the last-used nonce (which, in theory,
+      ;; should be the one sent by the server for its cookie).
+      ;; That seems wrong all around. After all, the client can send Initiate
+      ;; packets any time it likes.
+      ;; c.f. lines 329-334 in the reference spec.
       (let [working-nonce (byte-array K/nonce-length)
             ;; Just reuse a subset of whatever the server sent us.
             ;; Legal because a) it uses a different prefix and b) it's a different number anyway

          ;; and the packet to send.
          ;; And we shouldn't send it any more of `this` than
          ;; it absolutely needs
          this (cookie->vouch (assoc this ::log/state log-state)
                              cookie-packet)
          this (update this
                       ::log/state
                       #(log/debug %
                                   ::build-and-send-vouch!
                                   "cookie converted to vouch"))]
      (try
        ;; FIXME: Debug only
        (println "Client built Initiate/Vouch. Sending it")
        (throw (RuntimeException. ""))
        (let [base-result (do-send-vouch this)]
          (update base-result ::log/state #(log/flush-logs! logger %)))
        (catch Exception ex
          (update this

  ;; It would be very easy to just wait
  ;; for its minute key to definitely time out, though that seems
  ;; like a naive approach with a terrible user experience.
  [{log-state ::log/state
    :keys [::log/logger]
    :as this}
   packet]
  (if packet
    (let [log-state (log/flush-logs! logger log-state)
          this (assoc this ::log/state log-state)
          {log-state ::log/state
           deferred ::specs/deferred}
          ;; FIXME: Instead of this, have HELLO set up a partial or lexical closure
          ;; that we can use to send packets.
          ;; (it's pretty close)
          ;; Honestly, most of what I'm passing along in here is overkill that
          ;; I set up for debugging.
          (state/do-send-packet this
                                (fn [success]
                                  (log/flush-logs! logger
                                                   (log/info log-state
                                                             ::do-send-vouch
                                                             "Initiate packet sent.\nWaiting for 1st message"
                                                             {::success success}))
                                  (state/final-wait this success))
                                (fn [failure]
                                  ;; Extremely unlikely, but
                                  ;; just for the sake of paranoia
                                  (log/flush-logs! logger
                                                   (log/exception log-state
                                                                  ;; Q: Am I absolutely positive that this will
                                                                  ;; always be an exception?
                                                                  ;; A: Even if it isn't the logger needs to be
                                                                  ;; able to cope with other problems
                                                                  failure
                                                                  ::do-send-vouch
                                                                  "Sending Initiate packet failed!"
                                                                  {::problem failure}))
                                  (throw (ex-info "Failed to send cookie->vouch response"
                                                  (assoc this
                                                         :problem failure))))
                                (state/current-timeout this)
                                ::sending-vouch-timed-out
                                packet)]
      (assoc this
             ::log/state log-state
             ::specs/deferred deferred))
    (assoc this
           ::log/state (log/warn log-state
                                 ::do-send-vouch
                                 "No message bytes to send")
           ::specs/deferred (dfrd/success-deferred ::nothing-to-send))))

(s/fdef build-inner-vouch
  :args (s/cat :this ::vouch-building-params)
