                (b-t/bytes= extension client-extension)
                (b-t/bytes= server-extension server-extension))
       (decrypt-actual-cookie (assoc this
-                                    ::log2/state log-state)
+                                    ::log/state log-state)
                              rcvd))))
 
 (s/fdef received-response

                                                                         ::state/server-extension
                                                                         ::state/server-security
                                                                         ::state/shared-secrets])
                                                           ::log2/state log-state
                                                           ::shared/packet message))]
            (let [this (into this decrypted)
                  {:keys [::shared/my-keys]} this
                  server-short (get-in this
                                       [::state/server-security
                                        ::specs/public-short])
                  log-state (log2/debug log-state
                                        ::cookie->vouch
                                        "Managed to decrypt the cookie")]
              (assert server-short (str "Missing ::specs/public-short among\n"
                                        (keys (::state/server-security this))
                                        "\namong bigger-picture\n"

    ^bytes client-nonce-suffix ::K/client-nonce-suffix
    ^bytes cookie ::K/cookie
    :as rcvd}]
  (let [log-state (log/info log-state
                            ::decrypt-actual-cookie
                            "Getting ready to try to extract cookie"
                            {::raw-cookie cookie
                             ::human-readable (shared/bytes->string cookie)})
        {^bytes text ::shared/text
         ^bytes working-nonce ::shared/working-nonce} work-area]
    (assert working-nonce (str "Missing nonce buffer amongst\n"
                               (keys work-area)
                               "\nin\n"
                               (keys this)))
    (let [log-state (log/info log-state
                              ::decrypt-actual-cookie
                              "Copying nonce prefix"
                              {::src K/cookie-nonce-prefix
                               ::dst working-nonce})]
      (b-t/byte-copy! working-nonce K/cookie-nonce-prefix)
      (b-t/byte-copy! working-nonce
                      K/server-nonce-prefix-length
                      K/server-nonce-suffix-length
                      client-nonce-suffix)
      (let [log-state (log/info log-state
                                ::decrypt-actual-cookie
                                "Copying encrypted cookie"
                                {::target text
                                 ::this this
                                 ::my-keys (keys this)})]
        (b-t/byte-copy! text 0 K/cookie-frame-length cookie)
        (let [shared (::state/client-short<->server-long shared-secrets)]
          (when-not shared
            (throw (ex-info "Missing client-short<->server-long secret"
                            {::state/shared-secrets shared-secrets})))
          (let [log-state (log/info log-state
                                    ::decrypt-actual-cookie
                                    "Trying to decrypt"
                                    {::shared/text  (b-t/->string text)
                                     ::shared/working-nonce (b-t/->string working-nonce)
                                     ::client-short<->server-long (b-t/->string shared)})]
            ;; TODO: If/when an exception is thrown here, it would be nice
            ;; to notify callers immediately
            (try
              (let [{log-state ::log/state
                     decrypted ::crypto/unboxed} (crypto/open-after log-state text 0 144 working-nonce shared)
                    {server-short-pk ::K/s'
                     server-cookie ::K/black-box
