     (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?)

    (if (and box
             (>= (count box) (+ box-offset box-length))
             (>= box-length K/box-zero-bytes))
      (let [log-state (log2/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)]

          (let [channel (.getChannel (RandomAccessFile. f "rw"))]
            (try
              (let [lock (.lock channel 0 Long/MAX_VALUE false)
                    log-state (log/info log-state
                                        ::reload-nonce
                                        "Lock acquired")]
                (try
                  (let [nonce-counter (io/file path "noncecounter")]
                    (when-not (.exists nonce-counter)
