          handler (create-http-kit-handler! "ws://127.0.0.1:9090/")
          ;; remote server to sync to
          remote-store (<!! (new-mem-store))
+         local-users {"john" "haskell" "jane" "lisp"}
+         input-users {"john" "haskell" "jane" "lisp"}
+         auth-fn (fn [users] (go (into {} (filter #(users (key %)) input-users ))))
+         cred-fn (fn [token] (if (= (:password token) (get local-users (:username token))) true nil))
          _ (def remote-peer (server-peer handler remote-store (comp (partial logger log-atom :remote-core)
                                                                     (partial fetch remote-store)
-                                                                    (partial publish-on-request remote-store)
-                                                                    (partial auth ))))
+                                                                    (partial publish-on-request remote-store))))
 
          ;; start it as its own server (usually you integrate it in ring e.g.)
          _ (start remote-peer)
          ;; local peer (e.g. used by a stage)
          local-store (<!! (new-mem-store))
-        local-users {"john" "P4ssw0rd"
-                     "jane" "lisp"}
-        input-users {"john" "P4ssw0rd"
-                     "jane" "lisp"}
-         auth-fn (fn [users] (go (into {} (filter #(users (key %)) input-users ))))
-         cred-fn (fn [token] (if (= (:password token) (get local-users (:username token)))
-                              true
-                              nil))
          _ (def local-peer (client-peer "CLIENT" local-store (comp (partial logger log-atom :local-core)
                                                                    (partial fetch local-store)
                                                                    (partial publish-on-request local-store)

                                   :branches {"master" #{2}}
                                   :schema {:type :geschichte
                                            :version 1}}}}})
     ;; the peer replies with a request for missing commit values
     (<!! in) => {:topic :fetch,
                  :ids #{1 2}}

                                      :pull-requests {},
                                      :schema {:type :geschichte, :version 1}}}},
                  :peer "CLIENT",
                  :users #{"john"}
                  :geschichte.p2p.auth/authed true
                  :topic :meta-pub}
     ;; ack
     (>!! out {:topic :meta-pubed
