     (try
       (open-after log-state crypto-box 0 crypto-length nonce shared-key)
       (catch Exception ex
-        {::weald/state (log2/exception log-state
+        {::weald/state (log/exception log-state
                                       ex
                                       ::open-box
                                       "Failed to open box")}))))
 
-(defn decompose-box
-  "Open a crypto box and decompose its bytes"
-  [log-state tmplt nonce-prefix nonce-suffix crypto-box shared-key]
-  (let [{log-state ::weald/state
-         :keys [::unboxed]
-         :as opened} (open-box log-state
-                               nonce-prefix
-                               nonce-suffix
-                               crypto-box
-                               shared-key)]
-    (if unboxed
-      (let [result (serial/decompose-array tmplt unboxed)]
-        {::weald/state log-state
-         ::serial/decomposed result})
-      opened)))
 
 (s/fdef random-array
   :args (s/cat :n integer?)

                      (with-open [counter (io/output-stream nonce-counter)]
                        ;; FIXME: What's a good initial value?
                        (.write counter (byte-array 8))))
                    (let [log-state (log2/debug log-state
                                                ::reload-nonce
                                                "Opening"
                                                {::nonce-file-name nonce-counter})]
                      (with-open [counter (io/input-stream nonce-counter)]
                        (let [log-state (log2/debug log-state
                                                    ::reload-nonce
                                                    "Nonce counter file opened for reading")
                              data (bytes data)
                              bytes-read (.read counter data 0 8)
                              log-state (log2/debug log-state
                                                    ::reload-nonce
                                                    "Read bytes"
                                                    {::byte-count bytes-read})]
                          (when (not= bytes-read 8)
                            (log2/flush-logs! logger log-state)
                            (throw (ex-info "Nonce counter file too small"
                                            {::contents (b-t/->string data)
                                             ::length bytes-read})))

    (if (and box
             (>= (count box) (+ box-offset box-length))
             (>= box-length K/box-zero-bytes))
      (let [log-state (log/debug log-state
                                 ::open-after
                                 "Box is large enough")]
        (let [n (+ box-length K/box-zero-bytes)
              cipher-text (byte-array n)
              plain-text (byte-array n)]
