                                       :head "master",
                                       :pull-requests {}
                                       :branches {"master" #{2}}
-                                      :schema {:type :geschichte, :version 1}}}}}
+                                      :schema {:type :geschichte, :version 1}}}}
+                  :users #{"john"}, :geschichte.p2p.auth/authed true}
 
      ;; ack
      (>!! out {:topic :meta-pubed

                                      :pull-requests {},
                                      :schema {:type :geschichte, :version 1}}}},
                  :peer "CLIENT",
                  :topic :meta-pub}
     ;; ack
     (>!! out {:topic :meta-pubed

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

         ;; 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))
         _ (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)
