diff --git a/configure.ac b/configure.ac
index 338b4a8..8bac554 100644
--- a/configure.ac
+++ b/configure.ac
@@ -101,11 +101,13 @@ AC_CONFIG_FILES([Makefile
                  src/tools/Makefile
                  src/core/Makefile
                  src/service/Makefile
-                 src/app/Makefile
+                 src/frost/Makefile
                  test/Makefile
                  test/core/Makefile
                  test/p2p/Makefile
                  test/service/Makefile
+                 test/frost/Makefile
+                 test/testlib/Makefile
                  contrib/Makefile])
 
 
diff --git a/contrib/catch/catch.hpp b/contrib/catch/catch.hpp
index ccd5749..1712c95 100644
--- a/contrib/catch/catch.hpp
+++ b/contrib/catch/catch.hpp
@@ -10690,6 +10690,31 @@ void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator
 }
 
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+
+template<typename E>
+std::string translateIfNestedException(E &e, std::size_t level) {
+    try {
+        std::rethrow_if_nested(e);
+        return std::string();
+    }
+    catch( std::exception& e1 ) {
+        return std::string("\n") + std::string(level*2, ' ') + e1.what() + translateIfNestedException(e1, level + 1);
+    }
+    catch( std::string& msg ) {
+        return std::string("\n") + std::string(level*2, ' ') + msg;
+    }
+    catch( std::nested_exception& e1 ) {
+        return std::string("\n") + std::string(level*2, ' ') + "Unknown exception" + translateIfNestedException(e1, level + 1);
+    }
+    catch( const char* msg ) {
+        return std::string("\n") + std::string(level*2, ' ') + msg;
+    }
+    catch(...) {
+        return std::string("\n") + std::string(level*2, ' ') + "Unknown exception";
+    }
+}
+
 std::string ExceptionTranslatorRegistry::translateActiveException() const {
     try {
 #ifdef __OBJC__
@@ -10719,11 +10744,14 @@ std::string ExceptionTranslatorRegistry::translateActiveException() const {
         std::rethrow_exception(std::current_exception());
     }
     catch( std::exception& ex ) {
-        return ex.what();
+        return std::string(ex.what()) + translateIfNestedException(ex, 1);
     }
     catch( std::string& msg ) {
         return msg;
     }
+    catch( std::nested_exception& ex ) {
+        return "Unknown exception" + translateIfNestedException(ex, 1);
+    }
     catch( const char* msg ) {
         return msg;
     }
diff --git a/contrib/cex/async_result.hpp b/contrib/cex/async_result.hpp
new file mode 100644
index 0000000..cceefd0
--- /dev/null
+++ b/contrib/cex/async_result.hpp
@@ -0,0 +1,359 @@
+#pragma once
+
+#include <tuple>
+#include <memory>
+#include <concepts>
+
+namespace cex {
+
+template <typename RES>
+class async_result_base
+{
+protected:
+    async_result_base() = default;
+public:
+    virtual ~async_result_base() = default;
+    virtual void operator()(const RES& res) = 0;
+    virtual void operator()(RES&& res) = 0;
+    virtual void on_error() = 0;
+};
+
+template <typename RES>
+class async_result_base<RES&>
+{
+protected:
+    async_result_base() = default;
+public:
+    virtual ~async_result_base() = default;
+    virtual void operator()(RES& res) = 0;
+    virtual void on_error() = 0;
+};
+
+
+template <>
+class async_result_base<void>
+{
+protected:
+    async_result_base() = default;
+public:
+    virtual ~async_result_base() = default;
+    virtual void operator()() = 0;
+    virtual void on_error() = 0;
+};
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result;
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result<RES, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...> : public async_result_base<RES>
+{
+    SUCCESS_HANDLER m_res;
+    ERROR_HANDLER m_err;
+    std::tuple<ARGS...> m_args;
+public:
+    async_result(const SUCCESS_HANDLER& res, const ERROR_HANDLER& err, ARGS&&... args)
+        : m_res(res), m_err(err), m_args(std::forward<ARGS>(args)...)
+    {}
+
+    async_result(const async_result& other) = default;
+    ~async_result() override = default;
+
+    async_result& operator=(const async_result& other) = default;
+
+    void operator()(const RES& res) override
+    { std::apply(m_res, std::tuple_cat(std::make_tuple(res), std::move(m_args))); }
+
+    void operator()(RES&& res) override
+    { std::apply(m_res, std::tuple_cat(std::make_tuple(std::forward<RES>(res)), std::move(m_args))); }
+
+    void on_error() override
+    { std::apply(m_err, std::move(m_args)); }
+
+    const async_result& forward() const
+    { return *this; }
+
+    async_result clone() const
+    { return async_result(*this); }
+};
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result<RES&, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...> : public async_result_base<RES&>
+{
+    SUCCESS_HANDLER m_res;
+    ERROR_HANDLER m_err;
+    std::tuple<ARGS...> m_args;
+public:
+    async_result(const SUCCESS_HANDLER& res, const ERROR_HANDLER& err, ARGS&&... args)
+            : m_res(res), m_err(err), m_args(std::forward<ARGS>(args)...)
+    {}
+
+    async_result(const async_result& other) = default;
+    ~async_result() override = default;
+
+    async_result& operator=(const async_result& other) = default;
+
+    void operator()(RES& res) override
+    { std::apply(m_res, std::tuple_cat(std::make_tuple(res), std::move(m_args))); }
+
+    void on_error() override
+    { std::apply(m_err, std::move(m_args)); }
+
+    const async_result& forward() const
+    { return *this; }
+
+    async_result clone() const
+    { return async_result(*this); }
+};
+
+template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result<void, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...> : public async_result_base<void>
+{
+    SUCCESS_HANDLER m_res;
+    ERROR_HANDLER m_err;
+    std::tuple<ARGS...> m_args;
+public:
+    async_result(const SUCCESS_HANDLER& res, const ERROR_HANDLER& err, ARGS&&... args)
+            : m_res(res), m_err(err), m_args(std::forward<ARGS>(args)...)
+    {}
+
+    async_result(const async_result& other) = default;
+    ~async_result() override = default;
+
+    async_result& operator=(const async_result& other) = default;
+
+    void operator()() override
+    { std::apply(m_res, std::move(m_args)); }
+
+    void on_error() override
+    { std::apply(m_err, std::move(m_args)); }
+
+    const async_result& forward() const
+    { return *this; }
+
+    async_result clone() const
+    { return async_result(*this); }
+};
+
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result<RES, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...> : public async_result_base<RES>
+{
+    SUCCESS_HANDLER m_res;
+    ERROR_HANDLER m_err;
+    std::tuple<ARGS...> m_args;
+public:
+    async_result(SUCCESS_HANDLER&& res, ERROR_HANDLER&& err, ARGS&&... args)
+            : m_res(std::move(res)), m_err(std::move(err)), m_args(std::forward<ARGS>(args)...)
+    {}
+
+    async_result(async_result&& other) noexcept = default;
+    ~async_result() override = default;
+
+    async_result& operator=(async_result&& other) noexcept = default;
+
+    void operator()(const RES& res) override
+    { std::apply(m_res, std::tuple_cat(std::make_tuple(res), std::move(m_args))); }
+
+    void operator()(RES&& res) override
+    { std::apply(m_res, std::tuple_cat(std::make_tuple(std::forward<RES>(res)), std::move(m_args))); }
+
+    void on_error() override
+    { std::apply(m_err, std::move(m_args)); }
+
+    async_result&& forward()
+    { return std::move(*this); }
+};
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result<RES&, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...> : public async_result_base<RES&>
+{
+    SUCCESS_HANDLER m_res;
+    ERROR_HANDLER m_err;
+    std::tuple<ARGS...> m_args;
+public:
+    async_result(SUCCESS_HANDLER&& res, ERROR_HANDLER&& err, ARGS&&... args)
+            : m_res(std::move(res)), m_err(std::move(err)), m_args(std::forward<ARGS>(args)...)
+    {}
+
+    async_result(async_result&& other) noexcept = default;
+    ~async_result() override = default;
+
+    async_result& operator=(async_result&& other) noexcept = default;
+
+    void operator()(RES& res) override
+    { std::apply(m_res, std::tuple_cat(std::make_tuple(res), std::move(m_args))); }
+
+    void on_error() override
+    { std::apply(m_err, std::move(m_args)); }
+
+    async_result&& forward()
+    { return std::move(*this); }
+};
+
+
+template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+class async_result<void, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...> : public async_result_base<void>
+{
+    SUCCESS_HANDLER m_res;
+    ERROR_HANDLER m_err;
+    std::tuple<ARGS...> m_args;
+public:
+    async_result(SUCCESS_HANDLER&& res, ERROR_HANDLER&& err, ARGS&&... args)
+            : m_res(std::move(res)), m_err(std::move(err)), m_args(std::forward<ARGS>(args)...)
+    {}
+
+    async_result(async_result&& other) noexcept = default;
+    ~async_result() override = default;
+
+    async_result& operator=(async_result&& other) noexcept = default;
+
+    void operator()() override
+    { std::apply(std::move(m_res), std::move(m_args)); }
+
+    void on_error() override
+    { std::apply(m_err, std::move(m_args)); }
+
+    async_result&& forward()
+    { return std::move(*this); }
+
+};
+
+
+template <typename RES>
+class shared_async_result : public async_result_base<RES>
+{
+    std::shared_ptr<async_result_base<RES>> m_handler;
+public:
+
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "google-explicit-constructor"
+    template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+    shared_async_result(const async_result<RES, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>& res)
+        : m_handler(std::make_shared<async_result<RES, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>>(res))
+    {}
+
+    template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+    shared_async_result(async_result<RES, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>&& res)
+        : m_handler(std::make_shared<async_result<RES, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>>(move(res)))
+    {}
+#pragma clang diagnostic pop
+
+    shared_async_result(const shared_async_result& other) : m_handler(other.m_handler) {}
+    shared_async_result(shared_async_result&& other) noexcept : m_handler(std::move(other.m_handler)) {}
+
+    ~shared_async_result() override = default;
+
+    shared_async_result& operator=(const shared_async_result& other) = default;
+    shared_async_result& operator=(shared_async_result&& other) noexcept = default;
+
+    void operator()(const RES& res) override
+    { (*m_handler)(res); }
+
+    void operator()(RES&& res) override
+    { (*m_handler)(std::move(res));; }
+
+    void on_error() override
+    { m_handler->on_error(); }
+
+    shared_async_result& forward()
+    { return *this; }
+};
+
+template <typename RES>
+class shared_async_result<RES&> : public async_result_base<RES&>
+{
+    std::shared_ptr<async_result_base<RES&>> m_handler;
+public:
+
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "google-explicit-constructor"
+    template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+    shared_async_result(const async_result<RES&, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>& res)
+            : m_handler(std::make_shared<async_result<RES&, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>>(res))
+    {}
+
+    template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+    shared_async_result(async_result<RES&, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>&& res)
+            : m_handler(std::make_shared<async_result<RES&, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>>(move(res)))
+    {}
+#pragma clang diagnostic pop
+
+    shared_async_result(const shared_async_result& other) : m_handler(other.m_handler) {}
+    shared_async_result(shared_async_result&& other) noexcept : m_handler(std::move(other.m_handler)) {}
+
+    ~shared_async_result() override = default;
+
+    shared_async_result& operator=(const shared_async_result& other) = default;
+    shared_async_result& operator=(shared_async_result&& other) noexcept = default;
+
+    void operator()(RES& res) override
+    { (*m_handler)(res); }
+
+    void on_error() override
+    { m_handler->on_error(); }
+
+    shared_async_result& forward()
+    { return *this; }
+};
+
+template <>
+class shared_async_result<void> : public async_result_base<void>
+{
+    std::shared_ptr<async_result_base<void>> m_handler;
+public:
+
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "google-explicit-constructor"
+    template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+    shared_async_result(const async_result<void, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>& res)
+            : m_handler(std::make_shared<async_result<void, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>>(res))
+    {}
+
+    template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+    shared_async_result(async_result<void, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>&& res)
+            : m_handler(std::make_shared<async_result<void, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>>(std::move(res)))
+    {}
+#pragma clang diagnostic pop
+
+    shared_async_result(const shared_async_result& other) : m_handler(other.m_handler) {}
+    shared_async_result(shared_async_result&& other) noexcept : m_handler(std::move(other.m_handler)) {}
+
+    ~shared_async_result() override = default;
+
+    shared_async_result& operator=(const shared_async_result& other) = default;
+    shared_async_result& operator=(shared_async_result&& other) noexcept = default;
+
+    void operator()() override
+    { (*m_handler)(); }
+
+    void on_error() override
+    { m_handler->on_error(); }
+
+    shared_async_result& forward()
+    { return *this; }
+};
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+async_result<RES, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...> make_async_result(const SUCCESS_HANDLER& on_success, const ERROR_HANDLER& on_error, ARGS&& ... args)
+{
+    return async_result<RES, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>(on_success, on_error, std::forward<ARGS>(args)...);
+}
+
+template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+async_result<void, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...> make_async_result(const SUCCESS_HANDLER& on_success, const ERROR_HANDLER& on_error, ARGS&& ... args)
+{
+    return async_result<void, const SUCCESS_HANDLER&, const ERROR_HANDLER&, ARGS...>(on_success, on_error, std::forward<ARGS>(args)...);
+}
+
+template <typename RES, typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+async_result<RES, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...> make_async_result(SUCCESS_HANDLER&& on_success, ERROR_HANDLER&& on_error, ARGS&& ... args)
+{
+    return async_result<RES, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>(std::move(on_success), std::move(on_error), std::forward<ARGS>(args)...);
+}
+
+template <typename SUCCESS_HANDLER, typename ERROR_HANDLER, typename ...ARGS>
+async_result<void, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...> make_async_result(SUCCESS_HANDLER&& on_success, ERROR_HANDLER&& on_error, ARGS&& ... args)
+{
+    return async_result<void, SUCCESS_HANDLER&&, ERROR_HANDLER&&, ARGS...>(std::move(on_success), std::move(on_error), std::forward<ARGS>(args)...);
+}
+}
\ No newline at end of file
diff --git a/contrib/cex/fixsizevector.hpp b/contrib/cex/fixsizevector.hpp
index 09f7e6e..ba53d6e 100644
--- a/contrib/cex/fixsizevector.hpp
+++ b/contrib/cex/fixsizevector.hpp
@@ -2,6 +2,9 @@
 
 #include <vector>
 #include <stdexcept>
+#include <compare>
+
+#include "cex_defs.hpp"
 
 namespace cex {
 
@@ -39,16 +42,16 @@ class fixsize_vector : protected std::vector<Tp, Alloc> {
 public:
 
 
-    fixsize_vector() noexcept : base(SIZE) {}
-    explicit fixsize_vector(const allocator_type& a) noexcept : base(SIZE, a) {}
-    explicit fixsize_vector(const value_type& v) noexcept : base(SIZE, v) {}
-    fixsize_vector(const value_type& v, const allocator_type& a) noexcept : base(SIZE, v, a) {}
+    fixsize_vector() CEXCXX_NOEXCEPT : base(SIZE) {}
+    explicit fixsize_vector(const allocator_type& a) CEXCXX_NOEXCEPT : base(SIZE, a) {}
+    explicit fixsize_vector(const value_type& v) CEXCXX_NOEXCEPT : base(SIZE, v) {}
+    fixsize_vector(const value_type& v, const allocator_type& a) CEXCXX_NOEXCEPT : base(SIZE, v, a) {}
 
     fixsize_vector(const fixsize_vector& v) : base(v) {}
-    fixsize_vector(fixsize_vector&& v) noexcept : base(std::move(v)) {}
+    fixsize_vector(fixsize_vector&& v) CEXCXX_NOEXCEPT : base(std::move(v)) {}
 
-    fixsize_vector(const base& v) : base(check_size(v)) {}
-    fixsize_vector(base&& v) noexcept : base(check_resize(std::move(v))) {}
+    explicit fixsize_vector(const base& v) : base(check_size(v)) {}
+    explicit fixsize_vector(base&& v) CEXCXX_NOEXCEPT : base(check_resize(std::move(v))) {}
 
     fixsize_vector(const fixsize_vector& v, const allocator_type& a) : base(v, a) {}
     fixsize_vector(fixsize_vector&& v, const allocator_type& a) : base(std::move(v), a) {}
@@ -59,13 +62,13 @@ class fixsize_vector : protected std::vector<Tp, Alloc> {
     fixsize_vector(I f, I l, const allocator_type& a = allocator_type()) : base(SIZE, a)
     { assign(f, l); }
 
-    ~fixsize_vector() noexcept = default;
+    ~fixsize_vector() CEXCXX_NOEXCEPT = default;
 
     fixsize_vector& operator=(const fixsize_vector& x) { base::operator=(x); return *this; }
-    fixsize_vector& operator=(fixsize_vector&& x) noexcept { base::operator=(std::move(x)); return *this; }
+    fixsize_vector& operator=(fixsize_vector&& x) CEXCXX_NOEXCEPT { base::operator=(std::move(x)); return *this; }
 
     fixsize_vector& operator=(const base& x) { base::operator=(check_size(x)); return *this; }
-    fixsize_vector& operator=(base&& x) noexcept { base::operator=(check_resize(std::move(x))); return *this; }
+    fixsize_vector& operator=(base&& x) CEXCXX_NOEXCEPT { base::operator=(check_resize(std::move(x))); return *this; }
 
     fixsize_vector& operator=(std::initializer_list<value_type> l) { base::operator=(check_size(l)); return *this; }
 
@@ -81,7 +84,8 @@ class fixsize_vector : protected std::vector<Tp, Alloc> {
 
     void swap(base& x) { base::swap(check_size(x)); }
 
-    operator std::vector<value_type, allocator_type>&(){ return reinterpret_cast<std::vector<value_type, allocator_type>&>(*this); }
+    explicit operator base&(){ return reinterpret_cast<base&>(*this); }
+    explicit operator const base&() const { return reinterpret_cast<const base&>(*this); }
 
     using base::begin;
     using base::cbegin;
@@ -107,24 +111,39 @@ class fixsize_vector : protected std::vector<Tp, Alloc> {
     using base::data;
 };
 
-template< class T, size_t SIZE1, size_t SIZE2, class Alloc >
-bool operator==(const fixsize_vector<T, SIZE1, Alloc>& x1, const fixsize_vector<T, SIZE2, Alloc>& x2)
-{ return reinterpret_cast<const std::vector<T, Alloc>&>(x1) == reinterpret_cast<const std::vector<T, Alloc>&>(x2); }
+template< class T, size_t SIZE1, size_t SIZE2, class A1, class A2 >
+CEXCXX20_CONSTEXPR bool operator==(const fixsize_vector<T, SIZE1, A1>& x1, const fixsize_vector<T, SIZE2, A2>& x2)
+{ return reinterpret_cast<const std::vector<T, A1>&>(x1) == reinterpret_cast<const std::vector<T, A2>&>(x2); }
+
+#if __cplusplus >= 202002L
+
+template< class T, size_t SIZE1, /*size_t SIZE2, */class A1/*, class A2*/ >
+constexpr std::strong_ordering operator<=>(const fixsize_vector<T, SIZE1, A1>& x1, const fixsize_vector<T, SIZE1, A1>& x2)
+{ return reinterpret_cast<const std::vector<T, A1>&>(x1) <=> reinterpret_cast<const std::vector<T, A1>&>(x2); }
+
+#else
+
+template< class T, size_t SIZE1, size_t SIZE2, class A1, class A2 >
+bool operator<(const fixsize_vector<T, SIZE1, A1>& x1, const fixsize_vector<T, SIZE2, A2>& x2)
+{ return reinterpret_cast<const std::vector<T, A1>&>(x1) < reinterpret_cast<const std::vector<T, A2>&>(x2); }
+
+#endif
 
-template< class T, size_t SIZE, class Alloc >
-bool operator==(const fixsize_vector<T, SIZE, Alloc>& x1, const std::vector<T, Alloc>& x2)
-{ return reinterpret_cast<const std::vector<T, Alloc>&>(x1) == x2; }
 
-template< class T, size_t SIZE, class Alloc >
-bool operator==(const std::vector<T, Alloc>& x1, const fixsize_vector<T, SIZE, Alloc>& x2)
-{ return x1 == reinterpret_cast<const std::vector<T, Alloc>&>(x2); }
+//template< class T, size_t SIZE, class A1, class A2 >
+//bool operator==(const fixsize_vector<T, SIZE, A1>& x1, const std::vector<T, A2>& x2)
+//{ return reinterpret_cast<const std::vector<T, A1>&>(x1) == x2; }
+//
+//template< class T, size_t SIZE, class A1, class A2 >
+//bool operator==(const std::vector<T, A1>& x1, const fixsize_vector<T, SIZE, A2>& x2)
+//{ return x1 == reinterpret_cast<const std::vector<T, A2>&>(x2); }
 
-template <class STREAM, class T, size_t SIZE, class Alloc>
-STREAM& operator << (STREAM& s, const fixsize_vector<T, SIZE, Alloc>& x)
+template <class STREAM, class T, size_t SIZE, class A>
+STREAM& operator << (STREAM& s, const fixsize_vector<T, SIZE, A>& x)
 { return s.write(x.data(), SIZE); }
 
-template <class STREAM, class T, size_t SIZE, class Alloc>
-STREAM& operator >> (STREAM& s, fixsize_vector<T, SIZE, Alloc>& x)
+template <class STREAM, class T, size_t SIZE, class A>
+STREAM& operator >> (STREAM& s, fixsize_vector<T, SIZE, A>& x)
 { return s.read(x.data(), SIZE); }
 
 }
diff --git a/contrib/cex/wrapstream.hpp b/contrib/cex/wrapstream.hpp
index e9b63de..4d28501 100644
--- a/contrib/cex/wrapstream.hpp
+++ b/contrib/cex/wrapstream.hpp
@@ -22,7 +22,7 @@ class stream {
 
 private:
     container_type m_container;
-    iterator m_read_it;
+    const_iterator m_read_it;
 public:
     stream() : m_container(), m_read_it(m_container.begin()) {}
     explicit stream(container_type&& container) : m_container(std::move(container)), m_read_it(m_container.cbegin()) {}
@@ -44,8 +44,7 @@ class stream {
         return *this;
     }
 
-
-    template<typename V>
+    template<std::assignable_from<value_type> V>
     stream& write(const V& elements)
     {
         auto pos = position();
@@ -55,6 +54,16 @@ class stream {
         return *this;
     }
 
+    template<template <class> class SPAN, typename V>
+    stream& write(const SPAN<V>& elements)
+    {
+        auto pos = position();
+        std::transform(elements.begin(), elements.end(), cex::smartinserter(m_container, m_container.end()), [](const V& v){ return static_cast<value_type>(v); });
+        m_read_it = m_container.begin();
+        std::advance(m_read_it, pos);
+        return *this;
+    }
+
     const value_type& get()
     { return *m_read_it++; }
 
@@ -62,23 +71,57 @@ class stream {
     {
         if (m_container.end() - m_read_it < count) throw std::range_error("Not enough data to read");
 
-        iterator end_it = m_read_it + count;
+        const_iterator end_it = m_read_it + count;
         std::transform(m_read_it, end_it, p, [&](const auto& v){ return v; });
         m_read_it = end_it;
         return *this;
     }
 
-    template <typename V>
-    stream& read(const V& elements)
+    template <std::constructible_from<value_type> V>
+    stream& read(V& elements)
+    {
+        if (m_container.end() - m_read_it < elements.size()) throw std::range_error("Not enough data to read");
+
+        const_iterator end_it = m_read_it + elements.size();
+        std::transform(m_read_it, end_it, elements.begin(), [&](const auto& v){ return V(v); });
+        m_read_it = end_it;
+        return *this;
+    }
+
+    template <std::assignable_from<value_type> V>
+    stream& read(V& elements)
     {
         if (m_container.end() - m_read_it < elements.size()) throw std::range_error("Not enough data to read");
 
-        iterator end_it = m_read_it + elements.size();
+        const_iterator end_it = m_read_it + elements.size();
         std::transform(m_read_it, end_it, elements.begin(), [&](const auto& v){ return v; });
         m_read_it = end_it;
         return *this;
     }
 
+    template <typename V>
+    stream& read(V& elements)
+    {
+        if (m_container.end() - m_read_it < elements.size()) throw std::range_error("Not enough data to read");
+
+        const_iterator end_it = m_read_it + elements.size();
+        std::transform(m_read_it, end_it, elements.begin(), [&](const auto& v){ return static_cast<V>(v); });
+        m_read_it = end_it;
+        return *this;
+    }
+
+
+    template <template <class> class SPAN, typename V>
+    stream& read(const SPAN<V>& span)
+    {
+        if (m_container.end() - m_read_it < span.size()) throw std::range_error("Not enough data to read");
+
+        const_iterator end_it = m_read_it + span.size();
+        std::transform(m_read_it, end_it, span.begin(), [&](const auto& v){ return static_cast<V>(v); });
+        m_read_it = end_it;
+        return *this;
+    }
+
     template <class I>
     void append(I begin, I end)
     {
@@ -135,9 +178,9 @@ class stream {
     const_iterator end() const
     { return m_container.end(); }
 
-    const value_type* data() const
-    { return m_container.data(); }
-
+//    const value_type* data() const
+//    { return m_container.data(); }
+//
     size_type size() const
     { return m_container.size(); }
 };
diff --git a/src/Makefile.am b/src/Makefile.am
index b20bf37..f859b2f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,2 +1,2 @@
-SUBDIRS = common service core app tools
+SUBDIRS = common frost service core tools
 
diff --git a/src/app/Makefile.am b/src/app/Makefile.am
deleted file mode 100644
index 64a0999..0000000
--- a/src/app/Makefile.am
+++ /dev/null
@@ -1,17 +0,0 @@
-
-AM_CPPFLAGS = \
- -I$(top_srcdir)/node/src \
- -I$(top_srcdir)/node/src/univalue/include \
- -I$(top_srcdir)/node/src/consensus \
- -I$(top_srcdir)/node/src/script \
- -I$(top_srcdir)/node/src/support \
- -I$(top_srcdir)/contrib/secp256k1/include \
- -I$(top_srcdir)/src/common \
- -I$(top_srcdir)/src/p2p \
- -I$(top_srcdir)/src/core \
- -I$(top_srcdir)/contrib/cex
-
-
-noinst_LTLIBRARIES = libl15-app.la
-libl15_app_la_SOURCES = \
-	signing_mgr.cpp
diff --git a/src/app/signing_mgr.cpp b/src/app/signing_mgr.cpp
deleted file mode 100644
index 167d9e7..0000000
--- a/src/app/signing_mgr.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "signing_mgr.hpp"
\ No newline at end of file
diff --git a/src/app/signing_mgr.hpp b/src/app/signing_mgr.hpp
deleted file mode 100644
index 7d61f86..0000000
--- a/src/app/signing_mgr.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "signer_api.hpp"
-#include "chain_api.hpp"
-
-namespace l15::app {
-
-class SigningManager {
-public:
-};
-
-
-}
diff --git a/src/common/common.hpp b/src/common/common.hpp
index d729554..1d16a0f 100644
--- a/src/common/common.hpp
+++ b/src/common/common.hpp
@@ -31,7 +31,8 @@ typedef std::vector<uint8_t> bytevector;
 typedef std::vector<std::string> stringvector;
 
 
-typedef cex::fixsize_vector<uint8_t, 32> seckey;
+typedef cex::fixsize_vector<uint8_t, 32> scalar;
+typedef scalar seckey;
 typedef cex::fixsize_vector<uint8_t, 33> compressed_pubkey;
 
 class xonly_pubkey : public cex::fixsize_vector<uint8_t, 32>
@@ -130,16 +131,6 @@ struct equal_to<T*>
     { return *x == *y; }
 };
 
-template <typename T>
-struct less : std::less<T> {};
-
-template <>
-struct less<xonly_pubkey>
-{
-    bool operator()(const xonly_pubkey& x, const xonly_pubkey& y) const
-    { return x.get_vector() < y.get_vector(); }
-};
-
 
 template<>
 struct hash<secp256k1_xonly_pubkey> : std::__hash_base<size_t, secp256k1_xonly_pubkey>
diff --git a/src/common/common_error.hpp b/src/common/common_error.hpp
index 8115fc0..e96368e 100644
--- a/src/common/common_error.hpp
+++ b/src/common/common_error.hpp
@@ -4,10 +4,12 @@
 
 namespace l15 {
 
-class Error : std::exception {
+class Error : public std::exception {
     const std::string m_details;
 public:
     Error() noexcept = default;
+    Error(const Error&) = default;
+    Error(Error&&) noexcept = default;
     explicit Error(std::string&& details) noexcept : m_details(move(details)) {}
     ~Error() override = default;
 
@@ -41,4 +43,50 @@ class SignatureError : public Error {
 
 };
 
+template <typename STREAM>
+void print_error(const Error& e, STREAM& out, size_t level = 0);
+
+template <typename STREAM>
+void print_error(const std::exception& e, STREAM& out, size_t level = 0);
+
+template <typename E, typename STREAM>
+void rethrow_nested_to_print(const E& e, STREAM& out, size_t level) {
+    try {
+        std::rethrow_if_nested(e);
+    }
+    catch (const Error &nested) {
+        print_error(nested, out, level+1);
+    }
+    catch (const std::exception &nested) {
+        print_error(nested, out, level+1);
+    }
+
+}
+
+template <typename STREAM>
+void print_error(const Error& e, STREAM& out, size_t level) {
+    out << std::string(level, ' ') << e.what() << ": " << e.details() << "\n";
+    rethrow_nested_to_print(e, out, level);
+}
+
+template <typename STREAM>
+void print_error(const std::exception& e, STREAM& out, size_t level) {
+    out << e.what() << "\n";
+    rethrow_nested_to_print(e, out, level);
+}
+
+template <typename STREAM>
+void print_error(STREAM& out) noexcept {
+    try {
+        std::rethrow_exception(std::current_exception());
+    }
+    catch(const Error& e) {
+        print_error(e, out);
+    }
+    catch(const std::exception& e) {
+        print_error(e, out);
+    }
+}
+
+
 }
\ No newline at end of file
diff --git a/src/core/signer_api.cpp b/src/core/signer_api.cpp
index 6c29173..eb67d4e 100644
--- a/src/core/signer_api.cpp
+++ b/src/core/signer_api.cpp
@@ -4,11 +4,13 @@
 #include <sstream>
 #include <type_traits>
 #include <future>
+#include <ranges>
 
 #include "smartinserter.hpp"
 #include "algorithm.hpp"
 
 #include "util/strencodings.h"
+#include "crypto/sha256.h"
 
 #include "secp256k1_schnorrsig.h"
 
@@ -19,21 +21,24 @@ using namespace p2p;
 
 SignerApi::SignerApi(ChannelKeys &&keypair,
                      size_t cluster_size,
-                     size_t threshold_size,
-                     error_handler e)
+                     size_t threshold_size)
 
     : m_ctx(keypair.Secp256k1Context())
     , mKeypair(keypair)
     , mKeyShare(m_ctx)
+    , m_keyshare_random_session()
     , m_nonce_count(0)
     , m_threshold_size(threshold_size)
     , m_peers_data(cluster_size)
+    , m_keycommit_count(0)
     , m_keyshare_count(0)
     , m_vss_hash()
     , m_key_handler()
     , m_secnonces()
+    , m_secnonces_mutex()
     , mHandlers()
-    , m_err_handler(std::move(e))
+    , m_err_handler([](){})
+    , m_operation_seqnum(1)
 {
     mHandlers[(size_t)FROST_MESSAGE::NONCE_COMMITMENTS] = &SignerApi::AcceptNonceCommitments;
     mHandlers[(size_t)FROST_MESSAGE::KEY_COMMITMENT] = &SignerApi::AcceptKeyShareCommitment;
@@ -41,23 +46,45 @@ SignerApi::SignerApi(ChannelKeys &&keypair,
     mHandlers[(size_t)FROST_MESSAGE::SIGNATURE_COMMITMENT] = &SignerApi::AcceptSignatureCommitment;
     mHandlers[(size_t)FROST_MESSAGE::SIGNATURE_SHARE] = &SignerApi::AcceptSignatureShare;
 
-    AddPeer(xonly_pubkey(mKeypair.GetLocalPubKey()), [this](p2p::frost_message_ptr&& m){ Accept(*m); });
+    AddPeer(xonly_pubkey(mKeypair.GetLocalPubKey()), [this](const xonly_pubkey& pk, p2p::frost_message_ptr&& m){ Accept(*m); });
 }
 
-void SignerApi::Accept(const FrostMessage& m)
+bool SignerApi::CheckReadyToSign(const operation_id& opid) const
 {
-    if (m.protocol_id != PROTOCOL::FROST) {
-        m_err_handler(WrongProtocol(static_cast<std::underlying_type<PROTOCOL>::type>(m.protocol_id)));
-        return;
+    bool res = mKeyShare.GetPubKey() != mKeyShare.GetLocalPubKey();
+
+    if (res) {
+        try {
+            for (const auto &peer_data: m_peers_data) {
+                GetCorrespondingNonceId(opid, peer_data.first);
+            }
+            res = true;
+        }
+        catch (...) {
+            res = false;
+        }
     }
+    return res;
+}
 
-    if (static_cast<uint16_t>(m.id) < static_cast<uint16_t>(FROST_MESSAGE::MESSAGE_ID_COUNT)) {
-        //std::clog << (stringstream() << std::hex << std::this_thread::get_id() << " [" << hex(mKeypair.GetPubKey()).substr(0, 8) << "] " << m.ToString()).str() << std::endl;
+void SignerApi::Accept(const FrostMessage& m)
+{
+    try {
+        if (m.protocol_id != PROTOCOL::FROST) {
+            throw WrongProtocol(static_cast<std::underlying_type<PROTOCOL>::type>(m.protocol_id));
+        }
+
+        if (static_cast<uint16_t>(m.id) < static_cast<uint16_t>(FROST_MESSAGE::MESSAGE_ID_COUNT)) {
+            //std::clog << (stringstream() << std::hex << std::this_thread::get_id() << " [" << hex(mKeypair.GetPubKey()).substr(0, 8) << "] " << m.ToString()).str() << std::endl;
 
-        (this->*mHandlers[static_cast<uint16_t>(m.id)])(m);
+            (this->*mHandlers[static_cast<uint16_t>(m.id)])(m);
+        }
+        else {
+            throw WrongMessage(m);
+        }
     }
-    else {
-        m_err_handler(WrongMessage(m));
+    catch(...) {
+        m_err_handler();
     }
 }
 
@@ -67,20 +94,28 @@ void SignerApi::AcceptNonceCommitments(const FrostMessage &m)
     const auto& message = reinterpret_cast<const NonceCommitments&>(m);
 
     if (m_peers_data.contains(message.pubkey)) {
-        auto& ephemeral_pubkeys = m_peers_data[message.pubkey].ephemeral_pubkeys;
-        std::for_each(message.nonce_commitments.begin(), message.nonce_commitments.end(), [&ephemeral_pubkeys](const secp256k1_frost_pubnonce& pubnonce)
+        auto& peer_data = m_peers_data.at(message.pubkey);
+
+        std::unique_lock lock(*peer_data.ephemeral_pubkeys_mutex);
+
+        for (const auto& pubnonce: message.nonce_commitments)
         {
-            if (!ephemeral_pubkeys.empty()) {
-                operation_id lastopid = ephemeral_pubkeys.nth(ephemeral_pubkeys.size() - 1)->first;
-                ephemeral_pubkeys[lastopid+1] = pubnonce;
+            scalar nonceid;
+            CSHA256().Write(pubnonce.data, sizeof(pubnonce.data)).Finalize(nonceid.data());
+
+            auto pubnonce_data_it = peer_data.ephemeral_pubkeys.find(nonceid);
+            if (pubnonce_data_it == peer_data.ephemeral_pubkeys.end()) {
+                peer_data.ephemeral_pubkeys.emplace(nonceid, std::make_tuple(pubnonce, std::optional<operation_id>()));
             }
             else {
-                ephemeral_pubkeys[0] = pubnonce;
+                if (memcmp(std::get<0>(pubnonce_data_it->second).data, pubnonce.data, sizeof(pubnonce.data)) != 0) {
+                    throw SigNonceIdCollision(nonceid);
+                }
             }
-        });
+        }
     }
     else {
-        m_err_handler(PeerNotFoundError(message.pubkey));
+        throw PeerNotFoundError(message.pubkey);
     }
 }
 
@@ -92,10 +127,14 @@ void SignerApi::AcceptKeyShareCommitment(const FrostMessage &m)
     if (peer_it != m_peers_data.end()/*
         && peer_it->second.keyshare_commitment.empty()*/)
     {
+        bool was_empty = peer_it->second.keyshare_commitment.empty();
         peer_it->second.keyshare_commitment = message.share_commitment;
+        if (was_empty && ++m_keycommit_count >= m_peers_data.size()) {
+            (*m_key_commits_handler)();
+        }
     }
     else {
-        m_err_handler(PeerNotFoundError(message.pubkey));
+        throw PeerNotFoundError(message.pubkey);
     }
 }
 
@@ -105,25 +144,26 @@ void SignerApi::AcceptKeyShare(const FrostMessage &m)
 
     auto peer_it = m_peers_data.find(message.pubkey);
     if (peer_it == m_peers_data.end()) {
-        m_err_handler(PeerNotFoundError(message.pubkey));
+        throw PeerNotFoundError(message.pubkey);
     }
     else if (!peer_it->second.keyshare_commitment.empty()) {
 
         if (peer_it->second.keyshare.has_value()) {
             if (memcmp(peer_it->second.keyshare->data, message.share.data, sizeof(secp256k1_frost_share)) != 0) {
-                m_err_handler(WrongMessageData(message));
+                throw WrongMessageData(message);
             }
         }
         else {
             peer_it->second.keyshare = message.share;
 
             if (++m_keyshare_count >= m_peers_data.size()) {
+                //std::clog << "KeyShare api received" << std::endl;
                 (*m_key_handler)();
             }
         }
     }
     else {
-        m_err_handler(OutOfOrderMessageError(message));
+        throw OutOfOrderMessageError(message);
     }
 }
 
@@ -133,14 +173,35 @@ void SignerApi::AcceptSignatureCommitment(const p2p::FrostMessage& m)
 
     auto peer_it = m_peers_data.find(message.pubkey);
     if (peer_it == m_peers_data.end()) {
-        m_err_handler(PeerNotFoundError(message.pubkey));
+        throw PeerNotFoundError(message.pubkey);
     }
-    else if ((mKeyShare.GetPubKey() != mKeyShare.GetLocalPubKey()) // Means aggregated pub key is assigned
-            && (peer_it->second.ephemeral_pubkeys.find(message.operation_id) != peer_it->second.ephemeral_pubkeys.end()))
-    {
+    else if (mKeyShare.GetPubKey() != mKeyShare.GetLocalPubKey()) { // Means aggregated pub key is assigned
+
+        std::shared_lock lock(*peer_it->second.ephemeral_pubkeys_mutex);
+
+        auto pubnonce_it = peer_it->second.ephemeral_pubkeys.find(message.nonce_id);
+        if (pubnonce_it == peer_it->second.ephemeral_pubkeys.end()) {
+            throw SigNonceNotAwailable((std::ostringstream() << "nonceid: " << hex(message.nonce_id)).str());
+        }
+
+        auto& pubnonce_data = pubnonce_it->second;
+        if (!get<1>(pubnonce_data).has_value()) {
+            get<1>(pubnonce_data) = std::make_optional(message.operation_id);
+        }
+        else if (*get<1>(pubnonce_data) != message.operation_id) {
+            throw OperationIdCollision(message.operation_id);
+        }
+
+        lock.unlock();
+
+        if (std::get<1>(pubnonce_data).has_value() && *std::get<1>(pubnonce_data) != message.operation_id) {
+            throw OperationIdCollision(message.operation_id);
+        }
+        std::get<1>(pubnonce_data).emplace(message.operation_id);
+
         secp256k1_xonly_pubkey peer_pk = message.pubkey.get(m_ctx);
 
-        [[maybe_unused]] std::unique_lock read_lock(m_sig_share_mutex);
+        std::unique_lock read_lock(m_sig_share_mutex);
 
         auto opit = m_sigops_cache.find(message.operation_id);
         if (opit == m_sigops_cache.end()) {
@@ -172,7 +233,7 @@ void SignerApi::AcceptSignatureCommitment(const p2p::FrostMessage& m)
         }
     }
     else {
-        m_err_handler(OutOfOrderMessageError(message));
+        throw OutOfOrderMessageError(message);
     }
 }
 
@@ -182,7 +243,7 @@ void SignerApi::AcceptSignatureShare(const FrostMessage &m)
 
     auto peer_it = m_peers_data.find(message.pubkey);
     if (peer_it == m_peers_data.end()) {
-        m_err_handler(PeerNotFoundError(message.pubkey));
+        throw PeerNotFoundError(message.pubkey);
     }
     else if (mKeyShare.GetPubKey() != mKeyShare.GetLocalPubKey()) // Means aggregated pub key is assigned
     {
@@ -192,7 +253,7 @@ void SignerApi::AcceptSignatureShare(const FrostMessage &m)
 
             sigops_cache::iterator op_it = m_sigops_cache.find(message.operation_id);
             if (op_it == m_sigops_cache.end()) {
-                m_err_handler(SignatureError((std::stringstream() << "Signature operation is not found: " << message.ToString()).str()));
+                throw SignatureError((std::stringstream() << "Signature operation is not found: " << message.ToString()).str());
             }
             else {
                 op = &*op_it;
@@ -212,10 +273,9 @@ void SignerApi::AcceptSignatureShare(const FrostMessage &m)
                     shares_lock.unlock();
                     //-----------------//
 
-                    std::stringstream errbuf;
-                    errbuf << "Peer is already provided different sig share: " << message.operation_id << '/' << HexStr(message.pubkey);
-                    m_err_handler(SignatureError(errbuf.str()));
-                    return;
+                    std::ostringstream errbuf;
+                    errbuf << "Peer is already provided different sig share: " << hex(message.operation_id) << '/' << hex(message.pubkey);
+                    throw SignatureError(errbuf.str());
                 }
             }
         }
@@ -223,10 +283,9 @@ void SignerApi::AcceptSignatureShare(const FrostMessage &m)
             shares_lock.unlock();
             //-----------------//
 
-            std::stringstream errbuf;
-            errbuf << '[' << hex(mKeypair.GetPubKey()).substr(0, 8) << "] "<< "Peer is not registered to participate in signature: " << message.operation_id << '/' << HexStr(message.pubkey);
-            m_err_handler(SignatureError(errbuf.str()));
-            return;
+            std::ostringstream errbuf;
+            errbuf << '[' << hex(mKeypair.GetPubKey()).substr(0, 8) << "] "<< "Peer is not registered to participate in signature: " << hex(message.operation_id) << '/' << HexStr(message.pubkey);
+            throw SignatureError(errbuf.str());
         }
 
         if (SigOpSigShareCount(*op) == m_threshold_size && SigOpSigSharesReceived(*op)) {
@@ -237,16 +296,19 @@ void SignerApi::AcceptSignatureShare(const FrostMessage &m)
         }
     }
     else {
-        m_err_handler(OutOfOrderMessageError(message));
+        throw OutOfOrderMessageError(message);
     }
 }
 
 
 void SignerApi::CommitNonces(size_t count)
 {
-    std::unique_ptr<NonceCommitments> message = std::make_unique<NonceCommitments>(xonly_pubkey(mKeypair.GetPubKey()));
+    std::unique_ptr<NonceCommitments> message = std::make_unique<NonceCommitments>(m_operation_seqnum++, xonly_pubkey(mKeypair.GetPubKey()));
     message->nonce_commitments.reserve(count);
 
+    std::vector<std::pair<operation_id, std::tuple<secp256k1_frost_secnonce, std::optional<operation_id>>>> secnonces;
+    secnonces.reserve(count);
+
     for (size_t i = 0; i < count; ++i) {
         seckey session_key = mKeypair.GetStrongRandomKey();
         secp256k1_frost_secnonce secnonce;
@@ -256,19 +318,23 @@ void SignerApi::CommitNonces(size_t count)
             throw SignatureError("Pubnonce generation error");
         }
 
-        m_secnonces.emplace_back(secnonce);
+        scalar nonceid;
+        CSHA256().Write(pubnonce.data, sizeof(pubnonce.data)).Finalize(nonceid.data());
+
+        secnonces.emplace_back(move(nonceid), std::make_tuple(secnonce, std::optional<operation_id>()));
         message->nonce_commitments.emplace_back(pubnonce);
     }
 
     Publish(move(message));
 
+    std::unique_lock lock(m_secnonces_mutex);
+    m_secnonces.insert(std::make_move_iterator(secnonces.begin()), std::make_move_iterator(secnonces.end()));
     m_nonce_count += count;
 }
 
-void SignerApi::DistributeKeySharesImpl()
+void SignerApi::CommitKeySharesImpl()
 {
-    seckey session;
-    GetStrongRandBytes(session);
+    GetStrongRandBytes(m_keyshare_random_session);
 
     secp256k1_keypair keypair;
     if (!secp256k1_keypair_create(m_ctx, &keypair, mKeypair.GetLocalPrivKey().data())) {
@@ -278,24 +344,32 @@ void SignerApi::DistributeKeySharesImpl()
     //TODO: Optimization is needed by parallelisation (but only when secp256k1_frost is optimized at commitment generation)
 
     secp256k1_frost_share tmp_share;
-    std::unique_ptr<KeyShareCommitment> message = std::make_unique<KeyShareCommitment>(xonly_pubkey(mKeypair.GetPubKey()));
+    std::unique_ptr<KeyShareCommitment> message = std::make_unique<KeyShareCommitment>(m_operation_seqnum++, xonly_pubkey(mKeypair.GetPubKey()));
     message->share_commitment.resize(m_threshold_size);
 
     secp256k1_xonly_pubkey thispk = mKeypair.GetPubKey().get(m_ctx);
 
     if (!secp256k1_frost_share_gen(m_ctx,
                                    message->share_commitment.data(), &(tmp_share),
-                                   session.data(), &keypair, &thispk, m_threshold_size)) {
+                                   m_keyshare_random_session.data(), &keypair, &thispk, m_threshold_size)) {
         throw SignatureError("FROST share generation error");
     }
 
     Publish(move(message));
+}
+
+void SignerApi::DistributeKeySharesImpl()
+{
+    secp256k1_keypair keypair;
+    if (!secp256k1_keypair_create(m_ctx, &keypair, mKeypair.GetLocalPrivKey().data())) {
+        throw WrongKeyError();
+    }
 
     SendToPeers<KeyShare>([&](KeyShare& m, const xonly_pubkey& remote_pk, const RemoteSignerData& s){
         secp256k1_xonly_pubkey pk = remote_pk.get(m_ctx);
         if (!secp256k1_frost_share_gen(m_ctx,
                                        nullptr, &(m.share),
-                                       session.data(), &keypair, &pk, m_threshold_size)) {
+                                       m_keyshare_random_session.data(), &keypair, &pk, m_threshold_size)) {
             throw SignatureError("secp256k1_frost_share_gen");
         }
     });
@@ -355,7 +429,7 @@ void SignerApi::AggregateKey()
     mKeyShare.SetAggregatePubKey(std::move(agg_pubkey));
 }
 
-signature SignerApi::AggregateSignature(operation_id opid)
+signature SignerApi::AggregateSignature(const operation_id& opid)
 {
     signature sig_agg;
     std::vector<secp256k1_frost_partial_sig> sigshares_data(m_threshold_size);
@@ -367,7 +441,7 @@ signature SignerApi::AggregateSignature(operation_id opid)
 
         auto op_it = m_sigops_cache.find(opid);
         if (op_it == m_sigops_cache.end()) {
-            throw SignatureError((std::stringstream() << "Signature operation is not found: " << opid).str());
+            throw SignatureError((std::stringstream() << "Signature operation is not found: " << hex(opid).substr(0, 8) << "...").str());
         }
         op = &*op_it;
     }
@@ -391,12 +465,12 @@ signature SignerApi::AggregateSignature(operation_id opid)
     }
 }
 
-void SignerApi::InitSignatureImpl(operation_id opid)
+void SignerApi::InitSignatureImpl(const operation_id& opid)
 {
-    Publish(std::make_unique<SignatureCommitment>(xonly_pubkey(mKeypair.GetLocalPubKey()), opid));
+    Publish(std::make_unique<SignatureCommitment>(m_operation_seqnum++, xonly_pubkey(mKeypair.GetLocalPubKey()), opid, SelectNonceId(opid)));
 }
 
-void SignerApi::PreprocessSignature(const uint256 &datahash, operation_id opid)
+void SignerApi::PreprocessSignature(const scalar &datahash, const operation_id& opid)
 {
     sigops_cache::value_type* op;
     {
@@ -404,7 +478,7 @@ void SignerApi::PreprocessSignature(const uint256 &datahash, operation_id opid)
 
         auto op_it = m_sigops_cache.find(opid);
         if (op_it == m_sigops_cache.end()) {
-            throw SignatureError((stringstream() << "Signature operation is not found: " << opid).str());
+            throw SignatureError((stringstream() << "Signature operation is not found: " << hex(opid).substr(0,8) << "...").str());
         }
         op = &*op_it;
     }
@@ -424,17 +498,20 @@ void SignerApi::PreprocessSignature(const uint256 &datahash, operation_id opid)
     cex::for_each(std::execution::par, sigshares.begin(), sigshares.end(), [&](const auto& ss)
     {
         xonly_pubkey peer_pk(m_ctx, ss.first);
-        const RemoteSignerData& peer = m_peers_data[peer_pk];
+        const RemoteSignerData& peer = m_peers_data.at(peer_pk);
+
+        std::shared_lock peer_lock(*peer.ephemeral_pubkeys_mutex);
+        auto pubnonce_it = peer.ephemeral_pubkeys.find(GetCorrespondingNonceId(opid, peer_pk));
 
-        auto pubnonce_it = peer.ephemeral_pubkeys.find(opid);
         if (pubnonce_it == peer.ephemeral_pubkeys.end()) {
             throw SignatureError((stringstream() << "No pubnonce from: " << hex(peer_pk)).str());
         }
+        peer_lock.unlock(); // Unlock as search has been completed.
 
         {
             [[maybe_unused]] std::lock_guard lock(m);
 
-            pubnonces.emplace_back(&(pubnonce_it->second));
+            pubnonces.emplace_back(&(get<0>(pubnonce_it->second)));
             pubkeys.emplace_back(&(ss.first));
         }
     });
@@ -450,7 +527,7 @@ void SignerApi::PreprocessSignature(const uint256 &datahash, operation_id opid)
 
 }
 
-void SignerApi::DistributeSigShares(operation_id opid)
+void SignerApi::DistributeSigShares(const operation_id& opid)
 {
     secp256k1_frost_session* session;
     {
@@ -458,30 +535,31 @@ void SignerApi::DistributeSigShares(operation_id opid)
 
         auto op_it = m_sigops_cache.find(opid);
         if (op_it == m_sigops_cache.end() || !SigOpSession(*op_it).has_value()) {
-            throw SignatureError((std::stringstream() << "Signature operation is not found: " << opid).str());
+            throw SignatureError((std::stringstream() << "Signature operation is not found: " << hex(opid).substr(0, 8) << "...").str());
         }
 
         session = &(SigOpSession(*op_it).value());
     }
 
-    auto secnonce_it = m_secnonces.begin();
-    std::advance(secnonce_it, opid);
+    std::shared_lock secnonces_lock(m_secnonces_mutex);
+    auto& secnonce = get<0>(m_secnonces.at(GetCorrespondingNonceId(opid, mKeypair.GetLocalPubKey())));
+    secnonces_lock.unlock();
 
     secp256k1_frost_share keyshare;
     std::copy(mKeyShare.GetLocalPrivKey().begin(), mKeyShare.GetLocalPrivKey().end(), keyshare.data);
 
     secp256k1_frost_partial_sig sigshare;
-    if (!secp256k1_frost_partial_sign(m_ctx, &sigshare, &*secnonce_it, &keyshare, session, nullptr)) {
+    if (!secp256k1_frost_partial_sign(m_ctx, &sigshare, &secnonce, &keyshare, session, nullptr)) {
         throw SignatureError("Signing error");
     }
 
-    std::unique_ptr<SignatureShare> message = std::make_unique<SignatureShare>(xonly_pubkey(mKeypair.GetPubKey()), opid);
+    std::unique_ptr<SignatureShare> message = std::make_unique<SignatureShare>(m_operation_seqnum++, xonly_pubkey(mKeypair.GetPubKey()), opid);
     secp256k1_frost_partial_sig_serialize(m_ctx, message->share.data(), &sigshare);
 
     Publish(move(message));
 }
 
-void SignerApi::Verify(const uint256 &message, const signature &signature) const
+void SignerApi::Verify(const scalar &message, const signature &signature) const
 {
     secp256k1_xonly_pubkey pubkey = mKeyShare.GetPubKey().get(m_ctx);
 
@@ -491,10 +569,44 @@ void SignerApi::Verify(const uint256 &message, const signature &signature) const
 
 }
 
-void SignerApi::ClearSignatureCache(operation_id opid)
+void SignerApi::ClearSignatureCache(const operation_id& opid)
 {
     [[maybe_unused]] std::unique_lock write_lock(m_sig_share_mutex);
     m_sigops_cache.erase(opid);
 }
 
+operation_id SignerApi::SelectNonceId(const operation_id &opid)
+{
+    std::unique_lock lock(m_secnonces_mutex);
+    for (auto& secnonce: m_secnonces) {
+        if (!std::get<1>(secnonce.second).has_value()) {
+            std::get<1>(secnonce.second) = std::make_optional<operation_id>(opid);
+            return secnonce.first;
+        }
+    }
+    throw SigNonceNotAwailable((std::ostringstream() << "new opid: " << hex(opid)).str());
+}
+
+
+operation_id SignerApi::GetCorrespondingNonceId(const operation_id &opid, const xonly_pubkey& peer_pk) const
+{
+    auto peer_it = m_peers_data.find(peer_pk);
+    if (peer_it != m_peers_data.end()) {
+
+        auto nonce_it = std::find_if(peer_it->second.ephemeral_pubkeys.begin(),
+                                     peer_it->second.ephemeral_pubkeys.end(),
+                                     [&opid](const auto& e){ return get<1>(e.second).has_value() && (*get<1>(e.second) == opid); });
+
+        if (nonce_it != peer_it->second.ephemeral_pubkeys.end()) {
+            return nonce_it->first;
+        }
+        else {
+            throw SigNonceNotAwailable((std::ostringstream() << "opid: " << hex(opid)).str());
+        }
+    }
+    else {
+        throw UnknownPeer(hex(peer_pk));
+    }
+}
+
 } // l15
\ No newline at end of file
diff --git a/src/core/signer_api.hpp b/src/core/signer_api.hpp
index 7f14035..c38aa32 100644
--- a/src/core/signer_api.hpp
+++ b/src/core/signer_api.hpp
@@ -6,11 +6,11 @@
 #include <array>
 #include <cmath>
 #include <execution>
-#include <boost/container/flat_map.hpp>
 #include <atomic>
 #include <mutex>
 #include <shared_mutex>
 #include <unordered_map>
+#include <map>
 #include <functional>
 #include <type_traits>
 
@@ -30,14 +30,14 @@
 
 namespace l15::core {
 
-typedef size_t operation_id;
+typedef scalar operation_id;
 
 class PeerNotFoundError : public Error {
 public:
     explicit PeerNotFoundError(const xonly_pubkey& pk) : Error(hex(pk)) {}
 
     const char* what() const noexcept override
-    { return "PeerNotFoundError"; }
+    { return "P                                                                                                                                                                                                                                                     eerNotFoundError"; }
 };
 
 class OutOfOrderMessageError : public Error {
@@ -65,17 +65,38 @@ class KeyAggregationError : public KeyError {
     { return "KeyAggregationError"; }
 
 };
-class WrongOperationId : public Error {
+
+class SigNonceIdCollision : public Error {
+public:
+    explicit SigNonceIdCollision(const operation_id& id) : Error(hex(id)) {}
+    ~SigNonceIdCollision() override = default;
+
+    const char* what() const noexcept override
+    { return "OperationIdCollision"; }
+};
+
+
+class OperationIdCollision : public Error {
 public:
-    explicit WrongOperationId(operation_id id) : opid(id) {}
-    ~WrongOperationId() override = default;
+    explicit OperationIdCollision(operation_id id) : opid(id) {}
+    ~OperationIdCollision() override = default;
 
     const char* what() const noexcept override
-    { return "WrongOperationId"; }
+    { return "OperationIdCollision"; }
 
     operation_id opid;
 };
 
+class SigNonceNotAwailable : public Error {
+public:
+    explicit SigNonceNotAwailable(std::string&& details) noexcept : Error(move(details)) {}
+    ~SigNonceNotAwailable() override = default;
+
+    const char* what() const noexcept override
+    { return "SigNonceNotAwailable"; }
+
+};
+
 class SignerApi;
 
 struct MovingBinderBase
@@ -102,19 +123,35 @@ struct MovingBinder : MovingBinderBase
 };
 
 template <typename Callable, typename... Args>
-MovingBinder<Callable, Args...> make_callable_with_signer(Callable f, Args&&... args)
+MovingBinder<Callable, Args...> make_moving_callable(Callable f, Args&&... args)
 { return MovingBinder<Callable, Args...>(move(f), std::forward<Args>(args)...); }
 
 
-typedef std::function<void(Error&&)> error_handler;
 typedef std::function<void()> general_handler;
 typedef std::function<void(operation_id)> sigop_handler;
 
+typedef std::function<void(p2p::frost_message_ptr)> frost_publish_handler;
+typedef std::function<void(const xonly_pubkey& peer_pk, p2p::frost_message_ptr)> frost_peer_link_handler;
 
 struct RemoteSignerData
 {
-    mutable p2p::frost_link_handler link;
-    boost::container::flat_map<operation_id, secp256k1_frost_pubnonce> ephemeral_pubkeys;
+    explicit RemoteSignerData(frost_peer_link_handler&& l)
+        : link(move(l))
+        , ephemeral_pubkeys()
+        , ephemeral_pubkeys_mutex(std::make_unique<std::shared_mutex>())
+        , keyshare_commitment()
+        , keyshare() {}
+
+    RemoteSignerData(RemoteSignerData&& r)
+        : link(move(r.link))
+        , ephemeral_pubkeys(move(r.ephemeral_pubkeys))
+        , ephemeral_pubkeys_mutex(move(r.ephemeral_pubkeys_mutex))
+        , keyshare_commitment(move(r.keyshare_commitment))
+        , keyshare(move(r.keyshare)) {}
+
+    mutable frost_peer_link_handler link;
+    std::map<operation_id, std::tuple<secp256k1_frost_pubnonce, std::optional<operation_id>>> ephemeral_pubkeys;
+    std::unique_ptr<std::shared_mutex> ephemeral_pubkeys_mutex;
 
     std::vector<secp256k1_pubkey> keyshare_commitment; // k
     std::optional<secp256k1_frost_share> keyshare;
@@ -129,20 +166,24 @@ class SignerApi
     const secp256k1_context* m_ctx;
     ChannelKeys mKeypair;
     ChannelKeys mKeyShare;
+    seckey m_keyshare_random_session;
 
     size_t m_nonce_count;
 
-    p2p::frost_link_handler m_publisher;
+    frost_publish_handler m_publisher;
 
     const size_t m_threshold_size;
     peers_data_type m_peers_data;
 
+    std::atomic<size_t> m_keycommit_count;
     std::atomic<size_t> m_keyshare_count;
-    uint256 m_vss_hash;
+    scalar m_vss_hash;
 
+    std::unique_ptr<MovingBinderBase> m_key_commits_handler;
     std::unique_ptr<MovingBinderBase> m_key_handler;
 
-    std::list<secp256k1_frost_secnonce> m_secnonces;
+    std::map<operation_id, std::tuple<secp256k1_frost_secnonce, std::optional<operation_id>>> m_secnonces;
+    std::shared_mutex m_secnonces_mutex;
 
     std::array<void(SignerApi::*)(const p2p::FrostMessage& m), (size_t)p2p::FROST_MESSAGE::MESSAGE_ID_COUNT> mHandlers;
 
@@ -164,11 +205,13 @@ class SignerApi
                 std::unique_ptr<MovingBinderBase>  // all_signature_shares_received_handler
             > sigop_cache;
 
-    typedef boost::container::flat_map<operation_id, sigop_cache> sigops_cache;
+    typedef std::map<operation_id, sigop_cache> sigops_cache;
 
     sigops_cache m_sigops_cache;
 
-    const error_handler m_err_handler;
+    general_handler m_err_handler;
+
+    std::atomic_uint16_t m_operation_seqnum;
 
     void Publish(p2p::frost_message_ptr&& data)
     {
@@ -180,10 +223,10 @@ class SignerApi
     void SendToPeers(std::function<void(DATA&, const xonly_pubkey&, const RemoteSignerData&)> datagen) {
         cex::for_each(std::execution::par, m_peers_data.begin(), m_peers_data.end(), [&](const auto& peer)
         {
-            std::unique_ptr<DATA> data = std::make_unique<DATA>(xonly_pubkey(mKeypair.GetLocalPubKey()));
+            std::unique_ptr<DATA> data = std::make_unique<DATA>(m_operation_seqnum++, xonly_pubkey(mKeypair.GetLocalPubKey()));
             datagen(*data, peer.first, peer.second);
             if (mKeypair.GetLocalPubKey() != peer.first) {
-                peer.second.link(move(data));
+                peer.second.link(peer.first, move(data));
             }
             else {
                 Accept(*data);
@@ -209,14 +252,20 @@ class SignerApi
     static std::unique_ptr<MovingBinderBase>& SigOpSigSharesReceived(sigops_cache::value_type& op_val)
     { return std::get<5>(op_val.second); }
 
+    void CommitKeySharesImpl();
     void DistributeKeySharesImpl();
-    void InitSignatureImpl(operation_id opid);
+    void InitSignatureImpl(const operation_id& opid);
+
+    operation_id SelectNonceId(const operation_id& opid);
+    operation_id GetCorrespondingNonceId(const operation_id& opid, const xonly_pubkey& peer_pk) const;
 
 public:
     SignerApi(ChannelKeys &&keypair,
               size_t cluster_size,
-              size_t threshold_size,
-              error_handler e);
+              size_t threshold_size);
+
+    void SetErrorHandler(general_handler f)
+    { m_err_handler = f; }
 
     const xonly_pubkey& GetLocalPubKey() const
     { return mKeypair.GetLocalPubKey(); }
@@ -227,8 +276,9 @@ class SignerApi
     size_t GetNonceCount() const noexcept
     { return m_nonce_count; }
 
+    bool CheckReadyToSign(const operation_id& opid) const;
 
-    void SetPublisher(p2p::frost_link_handler h)
+    void SetPublisher(frost_publish_handler h)
     { m_publisher = move(h); }
 
     // Methods to access internal data to use by tests
@@ -237,9 +287,6 @@ class SignerApi
     const seckey& GetSecKey() const
     { return mKeypair.GetLocalPrivKey(); }
 
-    const std::list<secp256k1_frost_secnonce>& GetSecNonceList() const
-    { return m_secnonces; }
-
     // -----------------------------------------------
 
     template<typename LINK>
@@ -251,17 +298,38 @@ class SignerApi
 
     void Accept(const p2p::FrostMessage& m);
 
+    template<typename Callable>
+    void CommitKeyShares(const Callable& key_commits_received_handler)
+    {
+        m_key_commits_handler = std::make_unique<MovingBinder<Callable>>(key_commits_received_handler);
+        CommitKeySharesImpl();
+    }
+
     template<typename Callable, typename... Args>
-    void DistributeKeyShares(Callable key_shares_received_handler, Args&&... args)
+    void CommitKeyShares(Callable&& key_commits_received_handler, Args&&... args)
     {
-        m_key_handler = std::make_unique<MovingBinder<Callable, Args...>>(move(key_shares_received_handler), std::forward<Args>(args)...);
+        m_key_commits_handler = std::make_unique<MovingBinder<Callable, Args...>>(std::forward<Callable>(key_commits_received_handler), std::forward<Args>(args)...);
+        CommitKeySharesImpl();
+    }
+
+    template<typename Callable>
+    void DistributeKeyShares(const Callable& key_shares_received_handler)
+    {
+        m_key_handler = std::make_unique<MovingBinder<Callable>>(key_shares_received_handler);
+        DistributeKeySharesImpl();
+    }
+
+    template<typename Callable, typename... Args>
+    void DistributeKeyShares(Callable&& key_shares_received_handler, Args&&... args)
+    {
+        m_key_handler = std::make_unique<MovingBinder<Callable, Args...>>(std::forward<Callable>(key_shares_received_handler), std::forward<Args>(args)...);
         DistributeKeySharesImpl();
     }
 
     void CommitNonces(size_t count);
 
     template<typename Callable1, typename Callable2>
-    void InitSignature(operation_id opid,
+    void InitSignature(const operation_id& opid,
                        Callable1&& all_sig_commitments_received_handler,
                        Callable2&& all_sig_shares_received_handler,
                        bool participate = true)
@@ -276,14 +344,14 @@ class SignerApi
                         sigshare_peers_cache(m_threshold_size),
                         (size_t)0,
                         std::make_unique<std::mutex>(),
-                        std::make_unique<Callable1>(std::forward<Callable1>(all_sig_commitments_received_handler)),
-                        std::make_unique<Callable2>(std::forward<Callable2>(all_sig_shares_received_handler)));
+                        std::make_unique<MovingBinder<Callable1>>(std::forward<Callable1>(all_sig_commitments_received_handler)),
+                        std::make_unique<MovingBinder<Callable2>>(std::forward<Callable2>(all_sig_shares_received_handler)));
 
                 m_sigops_cache.emplace(opid, move(peers_cache));
             }
             else {
-                SigOpCommitmentsReceived(*opit) = std::make_unique<Callable1>(move(all_sig_commitments_received_handler));
-                SigOpSigSharesReceived(*opit) = std::make_unique<Callable2>(move(all_sig_shares_received_handler));
+                SigOpCommitmentsReceived(*opit) = std::make_unique<MovingBinder<Callable1>>(std::forward<Callable1>(all_sig_commitments_received_handler));
+                SigOpSigSharesReceived(*opit) = std::make_unique<MovingBinder<Callable2>>(std::forward<Callable2>(all_sig_shares_received_handler));
             }
         }
 
@@ -293,15 +361,51 @@ class SignerApi
         }
     }
 
-    void PreprocessSignature(const uint256 &datahash, operation_id opid);
-    void DistributeSigShares(operation_id opid);
+    void PreprocessSignature(const scalar &datahash, const operation_id& opid);
+
+
+    template<typename Callable, typename... Args>
+    void DistributeSigShares(const operation_id& opid, Callable&& sig_shares_received_handler, Args&&... args)
+    {
+        {
+            std::unique_lock write_lock(m_sig_share_mutex);
+
+            auto opit = m_sigops_cache.find(opid);
+            if (opit != m_sigops_cache.end()) {
+                SigOpSigSharesReceived(*opit) = std::make_unique<MovingBinder<Callable, Args...>>(std::forward<Callable>(sig_shares_received_handler), std::forward<Args>(args)...);
+            }
+            else {
+                throw OperationIdCollision(opid);
+            }
+        }
+        DistributeSigShares(opid);
+    }
+
+    template<typename Callable>
+    void DistributeSigShares(const operation_id& opid, Callable&& sig_shares_received_handler)
+    {
+        {
+            std::unique_lock write_lock(m_sig_share_mutex);
+
+            auto opit = m_sigops_cache.find(opid);
+            if (opit != m_sigops_cache.end()) {
+                SigOpSigSharesReceived(*opit) = std::make_unique<MovingBinder<Callable>>(std::forward<Callable>(sig_shares_received_handler));
+            }
+            else {
+                throw OperationIdCollision(opid);
+            }
+        }
+        DistributeSigShares(opid);
+    }
+
+    void DistributeSigShares(const operation_id& opid);
 
-    void Verify(const uint256& message, const signature& signature) const;
+    void Verify(const scalar& message, const signature& signature) const;
 
     void AggregateKey();
-    signature AggregateSignature(operation_id opid);
+    signature AggregateSignature(const operation_id& opid);
 
-    void ClearSignatureCache(operation_id opid);
+    void ClearSignatureCache(const operation_id& opid);
 private:
 
     void AcceptNonceCommitments(const p2p::FrostMessage& m);
diff --git a/src/frost/Makefile.am b/src/frost/Makefile.am
new file mode 100644
index 0000000..c536c2f
--- /dev/null
+++ b/src/frost/Makefile.am
@@ -0,0 +1,13 @@
+AM_CPPFLAGS = \
+ -I$(top_srcdir)/node/src \
+ -I$(top_srcdir)/contrib/secp256k1/include \
+ -I$(top_srcdir)/contrib/cex \
+ -I$(top_srcdir)/contrib/cli11 \
+ -I$(top_srcdir)/src/common \
+ -I$(top_srcdir)/src/p2p \
+ -I$(top_srcdir)/src/service \
+ -I$(top_srcdir)/src/core
+
+
+noinst_LTLIBRARIES = libl15-frost.la
+libl15_frost_la_SOURCES = frost_signer.cpp frost_steps.cpp
\ No newline at end of file
diff --git a/src/frost/frost_common.hpp b/src/frost/frost_common.hpp
new file mode 100644
index 0000000..458ec2a
--- /dev/null
+++ b/src/frost/frost_common.hpp
@@ -0,0 +1,90 @@
+#pragma once
+
+#include "common.hpp"
+#include "common_error.hpp"
+#include "channel_keys.hpp"
+#include "signer_api.hpp"
+#include "signer_service.hpp"
+
+
+namespace l15::frost {
+
+enum FrostStatus: uint16_t
+{
+    Ready = 0,
+    InProgress = 1,
+    Completed = 2,
+    Confirmed = 4,
+    Error = 8
+};
+
+class FrostSigner;
+
+
+class WrongFrostState: public Error
+{
+public:
+    explicit WrongFrostState(std::string&& details) noexcept : Error(move(details)) {}
+    const char* what() const noexcept override { return "WrongFrostState"; }
+};
+
+inline uint16_t get_send_status(uint16_t full_status)
+{ return full_status >> 8; }
+
+inline uint16_t set_send_status(uint16_t status)
+{ return status << 8; }
+
+inline uint16_t get_recv_status(uint16_t full_status)
+{ return full_status & 0x0ff; }
+
+inline uint16_t set_recv_status(uint16_t status)
+{ return status & 0x0ff; }
+
+inline std::string translate(FrostStatus s)
+{
+    switch (s) {
+    case FrostStatus::Ready:
+        return "Ready";
+    case FrostStatus::InProgress:
+        return "InProgress";
+    case FrostStatus::Completed:
+        return "Completed";
+    case FrostStatus::Confirmed:
+        return "Confirmed";
+    case FrostStatus::Error:
+        return "Error";
+    }
+    throw std::runtime_error((std::ostringstream() << "Wrong FrostStatus: " << static_cast<uint16_t>(s)).str());
+}
+
+
+namespace details {
+
+struct message_status
+{
+    p2p::frost_message_ptr message;
+    FrostStatus status;
+
+    bool operator<(const message_status &other) const
+    { return message->id < other.message->id; }
+};
+
+
+enum class OperationType : uint16_t
+{
+    nonce, key, sign
+};
+
+struct OperationMapId
+{
+    core::operation_id opid;
+    OperationType optype;
+
+    std::string describe() const;
+};
+
+bool operator<(const OperationMapId &op1, const OperationMapId &op2);
+
+}
+
+}
diff --git a/src/frost/frost_signer.cpp b/src/frost/frost_signer.cpp
new file mode 100644
index 0000000..5e2d6d9
--- /dev/null
+++ b/src/frost/frost_signer.cpp
@@ -0,0 +1,283 @@
+#include "frost_signer.hpp"
+
+#include <algorithm>
+#include <deque>
+#include <concepts>
+#include <atomic>
+#include <list>
+
+#include <tbb/concurrent_unordered_map.h>
+
+
+namespace l15::frost {
+
+namespace rgs = std::ranges;
+namespace vs = std::views;
+
+
+//====================================================================================================================
+
+
+//====================================================================================================================
+
+class FrostOperation : public FrostOperationBase
+{
+
+    template<typename CALLABLE, typename... ARGS>
+    bool MessageQueueImpl(CALLABLE action, ARGS&&... args);
+
+    template<typename CALLABLE, typename... ARGS>
+    FrostStatus MessageProcImpl(CALLABLE action, ARGS&&... args);
+
+public:
+    explicit FrostOperation(std::shared_ptr<FrostStep> startStep): FrostOperationBase(startStep)
+    { }
+
+    bool CheckAndQueueSendingMessage(FrostSigner &signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m) override
+    { return MessageQueueImpl(&FrostStep::CheckAndQueueSend, signer, peer_pk, m); }
+
+    FrostStatus HandleSend(FrostSigner& signer, const std::optional<const xonly_pubkey> &peer_pk) override
+    { return MessageProcImpl(&FrostStep::MessageSend, signer, peer_pk); }
+
+    bool CheckAndQueueReceivedMessage(FrostSigner &signer, p2p::frost_message_ptr m) override
+    { return MessageQueueImpl(&FrostStep::CheckAndQueueReceive, signer, m); }
+
+    FrostStatus HandleReceive(FrostSigner& signer, const xonly_pubkey &peer_pk) override
+    { return MessageProcImpl(&FrostStep::MessageReceive, signer, peer_pk); }
+};
+
+//====================================================================================================================
+
+template <typename CALLABLE, typename... ARGS>
+bool FrostOperation::MessageQueueImpl(CALLABLE action, ARGS&&... args)
+{
+    for (auto& step: Steps()) {
+        if ((step.get()->*action)(std::forward<ARGS>(args)...))
+            return true;
+    }
+    return false;
+}
+
+template <typename CALLABLE, typename... ARGS>
+FrostStatus FrostOperation::MessageProcImpl(CALLABLE action, ARGS&&... args)
+{
+    FrostStatus res = FrostStatus::InProgress;
+    std::vector<std::shared_ptr<FrostStep>> check_steps;
+    check_steps.reserve(Steps().size());
+
+    for (const auto& step: Steps()) {
+        //stepState->MessageIsSent(peer_pk, m);
+        // or
+        //stepState->MessageIsReceived(m);
+        bool check_completed = (step.get()->*action)(std::forward<ARGS>(args)...);
+        /*if (check_completed) {
+            check_steps.emplace_back(move(step));
+        }
+        else */if (step->IsConfirmed() && !step->GetNextStep()) {
+            res = FrostStatus::Completed;
+        }
+    }
+
+    // use mutex to avoid race condition in starting of operation's steps
+//    {   std::lock_guard steps_lock(m_steps_mutex);
+//
+//        auto completed_it = rgs::find_if(check_steps, [](auto& s)
+//        {
+//            return (s->IsCompleted() && s->GetNextStep() && s->GetNextStep()->Status() == FrostStatus::Ready);
+//        });
+//        if (completed_it != check_steps.end()) {
+//            (*completed_it)->GetNextStep()->Start();
+//        }
+//    }
+
+    return res;
+}
+
+//====================================================================================================================
+
+void FrostSigner::HandleError()
+{ m_error_handler(); }
+
+void FrostSigner::Send(const xonly_pubkey &peer_pk, p2p::frost_message_ptr m)
+{
+    auto opt_peer_pk =  std::make_optional<const xonly_pubkey>(peer_pk);
+    std::vector<details::OperationMapId> completed;
+
+    {   std::shared_lock oplock(m_op_mutex);
+
+        for(auto& op : mOperations) {
+            if (op.second->CheckAndQueueSendingMessage(*this, opt_peer_pk, m)) {
+                if (op.second->HandleSend(*this, opt_peer_pk) == FrostStatus::Completed) {
+                    completed.reserve(mOperations.size());
+                    completed.push_back(op.first);
+                }
+                break;
+            }
+        }
+    }
+
+    if (!completed.empty()) {
+        std::unique_lock oplock(m_op_mutex);
+        for(auto opid: completed) {
+            mOperations.erase(opid);
+        }
+    }
+}
+
+void FrostSigner::Publish(p2p::frost_message_ptr m)
+{
+    std::optional<const xonly_pubkey> empty_pk;
+    std::vector<details::OperationMapId> completed;
+
+    { std::shared_lock oplock(m_op_mutex);
+
+        for(auto& op : mOperations) {
+            if (op.second->CheckAndQueueSendingMessage(*this, empty_pk, m)) {
+                if (op.second->HandleSend(*this, empty_pk) == FrostStatus::Completed) {
+                    completed.reserve(mOperations.size());
+                    completed.push_back(op.first);
+                }
+                break;
+            }
+        }
+    }
+
+    if (!completed.empty()) {
+        std::unique_lock oplock(m_op_mutex);
+        for(auto opid: completed) {
+            mOperations.erase(opid);
+        }
+    }
+}
+
+void FrostSigner::Receive(p2p::frost_message_ptr m)
+{
+    std::vector<details::OperationMapId> completed;
+
+    { std::shared_lock oplock(m_op_mutex);
+
+        for(auto& op : mOperations) {
+            if (op.second->CheckAndQueueReceivedMessage(*this, m)) {
+                if (op.second->HandleReceive(*this, m->pubkey) == FrostStatus::Completed) {
+                    completed.reserve(mOperations.size());
+                    completed.push_back(op.first);
+                }
+            }
+        }
+    }
+
+    if (!completed.empty()) {
+        std::unique_lock oplock(m_op_mutex);
+        for(auto opid: completed) {
+            mOperations.erase(opid);
+        }
+    }
+}
+
+void FrostSigner::Start()
+{
+    auto ws = weak_from_this();
+    mSignerApi->SetErrorHandler([ws](){
+        auto signer = ws.lock();
+        if (signer) {
+            signer->HandleError();
+        }
+
+    });
+    mSignerApi->SetPublisher([ws](p2p::frost_message_ptr m){
+        auto signer = ws.lock();
+        if (signer) {
+            signer->Publish(move(m));
+        }
+    });
+
+    rgs::for_each(m_peers_cache | vs::transform([](auto& p)->const xonly_pubkey&{return p.first; }), [this, ws](const auto &peer){
+        mSignerApi->AddPeer(xonly_pubkey(peer), [ws](const xonly_pubkey& peer_pk, p2p::frost_message_ptr m){
+            auto signer = ws.lock();
+            if (signer) {
+                signer->Send(peer_pk, move(m));
+            }
+        });
+    });
+
+    mPeerService->Connect(mSignerApi->GetLocalPubKey(), [ws](p2p::frost_message_ptr m) {
+        auto signer = ws.lock();
+        if (signer) {
+            signer->Receive(move(m));
+        }
+    });
+
+    details::OperationMapId opid {core::operation_id(0), details::OperationType::nonce};
+    mOperations.emplace(opid, std::make_shared<FrostOperation>(std::make_shared<NonceCommit>(shared_from_this(), opid)));
+}
+
+std::shared_ptr<FrostOperationBase> FrostSigner::NewKeyAgg()
+{
+    details::OperationMapId opid {core::operation_id(0), details::OperationType::key};
+    auto op = std::make_shared<FrostOperation>(std::make_shared<KeyCommit>(this->shared_from_this(), opid));
+
+    std::unique_lock oplock(m_op_mutex);
+
+    if(mOperations.size() > 1)
+        throw WrongFrostState("concurent aggpk??");
+
+    auto opres = mOperations.emplace(opid, op);
+
+    if (!opres.second) {
+        throw FrostOperationFailure(opid);
+    }
+
+    return op;
+}
+
+std::shared_ptr<FrostOperationBase> FrostSigner::GetCommitNonces()
+{
+    details::OperationMapId opid {core::operation_id(0), details::OperationType::nonce};
+    std::unique_lock oplock(m_op_mutex);
+    return mOperations[opid];
+}
+
+std::shared_ptr<FrostOperationBase> FrostSigner::NewSign(const scalar& message, const core::operation_id& opid)
+{
+    details::OperationMapId opmapid {opid, details::OperationType::sign};
+
+    auto op = std::make_shared<FrostOperation>(std::make_shared<SigCommit>(this->shared_from_this(), opmapid, message));
+
+    std::unique_lock oplock(m_op_mutex);
+    auto opres = mOperations.emplace(opmapid, op);
+
+    if (!opres.second) {
+        throw FrostOperationFailure(opmapid);
+    }
+
+    return op;
+}
+
+void FrostSigner::Verify(const scalar& message, const signature& sig) const
+{ mSignerApi->Verify(message, sig); }
+
+namespace details {
+
+bool operator< (const OperationMapId& op1, const OperationMapId& op2) {
+    if (op1.optype == OperationType::sign && op2.optype == OperationType::sign)
+        return op1.opid < op2.opid;
+    else
+        return op1.optype < op2.optype;
+}
+
+std::string OperationMapId::describe() const
+{
+    switch (optype) {
+    case OperationType::nonce:
+        return "nonce";
+    case OperationType::key:
+        return "keyagg";
+    case OperationType::sign:
+        return (std::ostringstream() << "sign/" << hex(opid)).str();
+    }
+    throw std::runtime_error((std::ostringstream() << "Wrong optype: " << static_cast<uint16_t>(optype)).str());
+}
+
+} // namespace details
+
+}
\ No newline at end of file
diff --git a/src/frost/frost_signer.hpp b/src/frost/frost_signer.hpp
new file mode 100644
index 0000000..bc1f248
--- /dev/null
+++ b/src/frost/frost_signer.hpp
@@ -0,0 +1,156 @@
+#pragma once
+
+#include <memory>
+#include <ranges>
+#include <future>
+#include <deque>
+#include <map>
+
+#include <tbb/concurrent_priority_queue.h>
+
+#include "common.hpp"
+#include "common_error.hpp"
+#include "channel_keys.hpp"
+#include "signer_api.hpp"
+#include "signer_service.hpp"
+
+#include "frost_common.hpp"
+#include "frost_steps.hpp"
+
+namespace l15::frost {
+
+// FrostSigner API is currently WIP prototype.
+// The main focus is at internal state machine so far.
+
+
+
+
+class FrostOperationBase
+{
+    std::deque<std::shared_ptr<FrostStep>> mSteps;
+public:
+    explicit FrostOperationBase(std::shared_ptr<FrostStep> startStep)
+    {
+        mSteps.emplace_back(startStep);
+        while (auto step = mSteps.back()->GetNextStep()) {
+            mSteps.emplace_back(move(step));
+        }
+    }
+
+    virtual ~FrostOperationBase() = default;
+
+    std::deque<std::shared_ptr<FrostStep>>& Steps()
+    { return mSteps; }
+
+    template <std::derived_from<FrostStep> STEP, typename RES, std::derived_from<cex::async_result_base<RES>> RES_HANDLER, typename ... ARGS>
+    void Start(RES_HANDLER&& handler, ARGS&& ... args)
+    {
+        try {
+            FrostStep &s = *(mSteps.front());
+            STEP &startStep = dynamic_cast<STEP &>(s);
+            return startStep.Start(cex::make_async_result<RES>([](RES&& res, RES_HANDLER&& handler){
+                    handler(std::forward<RES>(res));
+                },[opid = startStep.OperatonId()](RES_HANDLER&& handler){
+                    try {
+                        std::throw_with_nested(FrostOperationFailure(opid));
+                    }
+                    catch(...) {
+                        handler.on_error();
+                    }
+            }, std::forward<RES_HANDLER>(handler)), std::forward<ARGS>(args)...);
+        }
+        catch(...) {
+            std::throw_with_nested(FrostOperationFailure(mSteps.front()->OperatonId()));
+        }
+    }
+
+    template <std::derived_from<FrostStep> STEP, std::derived_from<cex::async_result_base<void>> RES_HANDLER, typename ... ARGS>
+    void Start(RES_HANDLER&& handler, ARGS&& ... args)
+    {
+        try {
+            FrostStep &s = *(mSteps.front());
+            STEP &startStep = dynamic_cast<STEP &>(s);
+            return startStep.Start(cex::make_async_result<void>([](RES_HANDLER&& handler){
+                handler();
+            },[opid = startStep.OperatonId()](RES_HANDLER&& handler){
+                try {
+                    std::throw_with_nested(FrostOperationFailure(opid));
+                }
+                catch(...) {
+                    handler.on_error();
+                }
+            }, std::forward<RES_HANDLER>(handler)), std::forward<ARGS>(args)...);
+        }
+        catch(...) {
+            std::throw_with_nested(FrostOperationFailure(mSteps.front()->OperatonId()));
+        }
+    }
+
+    virtual bool CheckAndQueueSendingMessage(FrostSigner &signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m)=0;
+    virtual FrostStatus HandleSend(FrostSigner& signer, const std::optional<const xonly_pubkey> &peer_pk)=0;
+    virtual bool CheckAndQueueReceivedMessage(FrostSigner &signer, p2p::frost_message_ptr m)=0;
+    virtual FrostStatus HandleReceive(FrostSigner& signer, const xonly_pubkey &peer_pk)=0;
+};
+
+
+class FrostSigner : public FrostSignerBase, public std::enable_shared_from_this<FrostSigner>
+{
+    friend class FrostOperation;
+    friend class FrostStep;
+    friend class NonceCommit;
+    friend class KeyCommit;
+    friend class KeyShare;
+    friend class SigCommit;
+    friend class SigAgg;
+
+    std::map<details::OperationMapId, std::shared_ptr<FrostOperationBase>> mOperations;
+    std::shared_mutex m_op_mutex;
+
+    std::function<void()> m_error_handler = [](){};
+
+private:
+
+
+    void Send(const xonly_pubkey& peer_pk, p2p::frost_message_ptr m);
+    void Publish(p2p::frost_message_ptr m);
+    void HandleError() override;
+
+    void Receive(p2p::frost_message_ptr m);
+
+    std::shared_ptr<FrostOperationBase> NewKeyAgg();
+    std::shared_ptr<FrostOperationBase> GetCommitNonces();
+    std::shared_ptr<FrostOperationBase> NewSign(const scalar& message, const core::operation_id& opid);
+
+public:
+
+    explicit FrostSigner(
+            core::ChannelKeys keypair, std::ranges::input_range auto&& peers,
+            std::shared_ptr<signer_service::SignerService> signerService,
+            std::shared_ptr<p2p::P2PInterface<xonly_pubkey, p2p::FrostMessage>> peerService)
+            : FrostSignerBase(keypair, peers, signerService, peerService)
+            , mOperations(), m_op_mutex()
+    {}
+
+    ~FrostSigner() override = default;
+
+    void SetErrorHandler(std::function<void()> h)
+    { m_error_handler = h; }
+
+    void Start();
+
+    template <std::derived_from<cex::async_result_base<const xonly_pubkey&>> RES>
+    void AggregateKey(RES&& handler)
+    { NewKeyAgg()->Start<KeyCommit, const xonly_pubkey&>(std::forward<RES>(handler)); }
+
+    template <std::derived_from<cex::async_result_base<void>> RES>
+    void CommitNonces(size_t count, RES&& handler)
+    { GetCommitNonces()->Start<NonceCommit>(std::forward<RES>(handler), count); }
+
+    template <std::derived_from<cex::async_result_base<signature>> RES>
+    void Sign(const scalar& message, const core::operation_id& opid, RES&& handler)
+    { NewSign(message, opid)->Start<SigCommit, signature>(std::forward<RES>(handler)); }
+
+    void Verify(const scalar& message, const signature& sig) const;
+};
+
+}
\ No newline at end of file
diff --git a/src/frost/frost_steps.cpp b/src/frost/frost_steps.cpp
new file mode 100644
index 0000000..1e953e0
--- /dev/null
+++ b/src/frost/frost_steps.cpp
@@ -0,0 +1,346 @@
+
+#include <algorithm>
+#include <ranges>
+#include <deque>
+#include <memory>
+
+#include "frost_steps.hpp"
+#include "frost_signer.hpp"
+
+namespace l15::frost {
+
+namespace rgs = std::ranges;
+namespace vs = std::views;
+
+
+namespace {
+
+details::message_queue& send_queue(details::peer_messages& cache)
+{ return std::get<0>(cache); }
+
+std::shared_mutex& send_mutex(details::peer_messages& cache)
+{ return *std::get<1>(cache); }
+
+details::message_queue& recv_queue(details::peer_messages& cache)
+{ return std::get<2>(cache); }
+
+std::shared_mutex& recv_mutex(details::peer_messages& cache)
+{ return *std::get<3>(cache); }
+
+void push_with_priority(details::message_queue& queue, p2p::frost_message_ptr m)
+{
+    auto it = std::find_if(queue.rbegin(), queue.rend(), [&](const auto &s) {
+        return s.message->id <= m->id;
+    });
+    if (it == queue.rend() || it->message->id != m->id) {
+        details::message_status s = {m, FrostStatus::Ready};
+        queue.emplace(it.base(), move(s));
+    }
+    else {
+        it->message = move(m);
+    }
+
+    queue.emplace_back(details::message_status{m, FrostStatus::Ready});
+    std::sort(queue.begin(), queue.end());
+}
+
+}
+
+
+bool FrostStep::CheckAndQueueSendImpl(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m,
+                                      p2p::FROST_MESSAGE frost_step)
+{
+    bool res;
+    bool is_completed = (get_send_status(m_status) & (uint16_t)FrostStatus::Completed);
+    if ((res = m->id == frost_step && !is_completed )) {
+        if (peer_pk) {
+            auto peer_it = signer.PeersCache().find(*peer_pk);
+            if ((res = peer_it != signer.PeersCache().end())) {
+                std::unique_lock lock(send_mutex(peer_it->second));
+                push_with_priority(send_queue(peer_it->second), m);
+            }
+            else {
+                throw p2p::WrongAddress(hex(*peer_pk));
+            }
+        }
+        else {
+            std::for_each(std::execution::par, signer.PeersCache().begin(), signer.PeersCache().end(), [m](auto& peer){
+                std::unique_lock lock(send_mutex(peer.second));
+                push_with_priority(send_queue(peer.second), m);
+            });
+        }
+    }
+    return res;
+}
+
+bool FrostStep::CheckAndQueueReceiveImpl(FrostSignerBase& signer, p2p::frost_message_ptr m, p2p::FROST_MESSAGE frost_step)
+{
+    bool res = false;
+    if ((m->id == frost_step && !(get_recv_status(m_status) & (uint16_t) FrostStatus::Completed) )) {
+        auto peer_it = signer.PeersCache().find(m->pubkey);
+        if ((res = peer_it != signer.PeersCache().end())) {
+            std::unique_lock lock(recv_mutex(peer_it->second));
+            push_with_priority(recv_queue(peer_it->second), m);
+        }
+        else {
+            throw p2p::WrongAddress(hex(m->pubkey));
+        }
+
+        // Check the step is already started (means start to send its messages)
+        res = (get_send_status(m_status) & (uint16_t)FrostStatus::InProgress);
+    }
+    return res;
+}
+
+void FrostStep::DefaultSend(FrostSignerBase& signer, const xonly_pubkey& peer_pk, details::message_status& send_status, uint16_t confirm_seq) const
+{
+    if (send_status.status != FrostStatus::Confirmed) { //Check the message status
+
+        p2p::frost_message_ptr send_msg = send_status.message->Copy();
+
+        send_msg->confirmed_sequence = confirm_seq;
+
+        signer.PeerService().Send(peer_pk, send_msg, [s = mSigner](){
+            //TODO: send_status.status = FrostStatus::Error
+            if (auto signer = s.lock()) signer->HandleError();
+        });
+
+        send_status.status = FrostStatus::Completed;
+    }
+}
+
+bool FrostStep::DefaultReceive(FrostSignerBase& signer, details::message_status &recv_status) const
+{
+    if (recv_status.status == FrostStatus::Ready) {
+        recv_status.status = FrostStatus::InProgress; //Really, excessive since the message processing happens under mutex lock
+        signer.SignerService().Accept(signer.SignerApi(), recv_status.message);
+        recv_status.status = FrostStatus::Completed;
+        return true;
+    }
+    // else it's a duplicate of some already accepted message
+    return false;
+}
+
+
+bool NonceCommit::MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk)
+{
+    if (peer_pk) throw std::runtime_error("NonceCommit: send with peer pubkey");
+
+    for (auto &peer: signer.PeersCache()) {
+        uint16_t confirm_seq = 0;
+        {   std::shared_lock recv_lock(recv_mutex(peer.second));
+            if (!recv_queue(peer.second).empty())
+                confirm_seq = rgs::max(recv_queue(peer.second) | vs::transform([](auto &s) { return s.message->confirmed_sequence; }));
+        }
+
+        std::unique_lock send_lock(send_mutex(peer.second));
+
+        auto send_it = rgs::find_if(send_queue(peer.second), [](const auto& s){
+            return s.message->id == p2p::FROST_MESSAGE::NONCE_COMMITMENTS && s.status == FrostStatus::Ready;
+        });
+        if (send_it != send_queue(peer.second).end()) {
+            DefaultSend(signer, peer.first, *send_it, confirm_seq);
+        }
+    }
+
+    return false;
+}
+
+bool NonceCommit::MessageReceive(FrostSignerBase& signer, details::peer_messages &peer_cache)
+{
+    std::unique_lock recv_lock(recv_mutex(peer_cache));
+
+    auto recv_it = rgs::find_if(recv_queue(peer_cache), [](const auto& s){
+        return s.message->id == p2p::FROST_MESSAGE::NONCE_COMMITMENTS && s.status == FrostStatus::Ready;
+    });
+    if (recv_it != recv_queue(peer_cache).end()) {
+        DefaultReceive(signer, *recv_it);
+    }
+    return false;
+}
+
+
+bool KeyShare::MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk)
+{
+    uint16_t status = SendStatus();
+    if ((!(status & FrostStatus::InProgress)) || (status & FrostStatus::Completed))
+        return false;
+
+    if (!peer_pk) throw std::runtime_error("KeyShare: send without peer pubkey");
+
+    auto &peer = signer.PeersCache().at(*peer_pk);
+
+    uint16_t confirm_seq = 0;
+    {   std::shared_lock recv_lock(recv_mutex(peer));
+        if (!recv_queue(peer).empty())
+            confirm_seq = rgs::max(recv_queue(peer) | vs::transform([](auto &s) { return s.message->confirmed_sequence; }));
+    }
+
+    std::unique_lock send_lock(send_mutex(peer));
+
+    auto send_it = rgs::find_if(send_queue(peer), [](const auto &s) {
+        return s.message->id == p2p::FROST_MESSAGE::KEY_SHARE && s.status == FrostStatus::Ready;
+    });
+    if (send_it != send_queue(peer).end()) {
+        DefaultSend(signer, *peer_pk, *send_it, confirm_seq);
+
+        if (++keyshares_sent >= (signer.N - 1)) {
+            SendStatus(FrostStatus::Completed);
+
+            if (IsCompleted()) {
+                std::clog << (std::ostringstream() << "KeyShare p2p completed: " << hex(signer.SignerApi()->GetLocalPubKey()).substr(0, 8)).str() << std::endl;
+            }
+
+            return true;
+        }
+    }
+    return false;
+}
+
+bool KeyShare::MessageReceive(FrostSignerBase& signer, details::peer_messages &peer_cache)
+{
+    std::unique_lock recv_lock(recv_mutex(peer_cache));
+
+    auto recv_it = rgs::find_if(recv_queue(peer_cache), [](const auto& s){
+        return s.message->id == p2p::FROST_MESSAGE::KEY_SHARE && s.status == FrostStatus::Ready;
+    });
+    if (recv_it != recv_queue(peer_cache).end() && DefaultReceive(signer, *recv_it) && ++keyshares_received >= (signer.N - 1)) {
+        RecvStatus(FrostStatus::Completed);
+
+        if (IsCompleted()) {
+            std::clog << (std::ostringstream() << "KeyShare p2p completed: " << hex(signer.SignerApi()->GetLocalPubKey()).substr(0, 8)).str() << std::endl;
+        }
+
+        return true;
+    }
+    return false;
+}
+
+bool KeyCommit::MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk)
+{
+    uint16_t status = SendStatus();
+    if ((!(status & FrostStatus::InProgress)) || (status & FrostStatus::Completed))
+        return false;
+
+    if (peer_pk) throw std::runtime_error("KeyCommit send with peer pubkey");
+
+    for (auto &peer: signer.PeersCache()) {
+        uint16_t confirm_seq = 0;
+        {   std::shared_lock recv_lock(recv_mutex(peer.second));
+            if (!recv_queue(peer.second).empty())
+                confirm_seq = rgs::max(recv_queue(peer.second)|vs::transform([](auto& s){ return s.message->confirmed_sequence; }));
+        }
+
+        std::unique_lock send_lock(send_mutex(peer.second));
+
+        auto send_it = rgs::find_if(send_queue(peer.second), [](const auto& s){
+            return s.message->id == p2p::FROST_MESSAGE::KEY_COMMITMENT && s.status == FrostStatus::Ready;
+        });
+        if (send_it != send_queue(peer.second).end()) {
+            DefaultSend(signer, peer.first, *send_it, confirm_seq);
+        }
+    }
+    SendStatus(FrostStatus::Completed);
+    return true;
+}
+
+bool KeyCommit::MessageReceive(FrostSignerBase& signer, details::peer_messages &peer_cache)
+{
+    std::unique_lock recv_lock(recv_mutex(peer_cache));
+    auto recv_it = rgs::find_if(recv_queue(peer_cache), [](const auto& s){
+        return s.message->id == p2p::FROST_MESSAGE::KEY_COMMITMENT && s.status == FrostStatus::Ready;
+    });
+    if (recv_it != recv_queue(peer_cache).end() && DefaultReceive(signer, *recv_it) && ++commitments_received >= (signer.N - 1)) {
+        RecvStatus(FrostStatus::Completed);
+        return true;
+    }
+    return false;
+}
+
+bool SigAgg::MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk)
+{
+    uint16_t status = SendStatus();
+    if ((!(status & FrostStatus::InProgress)) || (status & FrostStatus::Completed))
+        return false;
+
+    if (peer_pk) throw std::runtime_error("SigAgg: send with peer pubkey");
+
+    //auto &peer = signer.PeersCache().at(*peer_pk);
+    for (auto &peer: signer.PeersCache()) {
+
+        uint16_t confirm_seq = 0;
+        {   std::shared_lock recv_lock(recv_mutex(peer.second));
+            if (!recv_queue(peer.second).empty())
+                confirm_seq = rgs::max(recv_queue(peer.second)|vs::transform([](auto& s){ return s.message->confirmed_sequence; }));
+        }
+
+        std::unique_lock send_lock(send_mutex(peer.second));
+
+        auto send_it = rgs::find_if(send_queue(peer.second), [](const auto &s) {
+            return s.message->id == p2p::FROST_MESSAGE::SIGNATURE_SHARE && s.status == FrostStatus::Ready;
+        });
+        if (send_it != send_queue(peer.second).end()) {
+            DefaultSend(signer, peer.first, *send_it, confirm_seq);
+        }
+    }
+
+    SendStatus(FrostStatus::Completed);
+    return true;
+}
+
+bool SigAgg::MessageReceive(FrostSignerBase& signer, details::peer_messages &peer_cache)
+{
+    std::unique_lock recv_lock(recv_mutex(peer_cache));
+
+    auto recv_it = rgs::find_if(recv_queue(peer_cache), [](const auto& s){
+        return s.message->id == p2p::FROST_MESSAGE::SIGNATURE_SHARE && s.status == FrostStatus::Ready;
+    });
+    if (recv_it != recv_queue(peer_cache).end() && DefaultReceive(signer, *recv_it) && ++sigshares_received >= (signer.K - 1)) {
+        RecvStatus(FrostStatus::Completed);
+        return true;
+    }
+    return false;
+}
+
+bool SigCommit::MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk)
+{
+    uint16_t status = SendStatus();
+    if ((!(status & FrostStatus::InProgress)) || (status & FrostStatus::Completed))
+        return false;
+
+    if (peer_pk) throw std::runtime_error("SigCommit: send with peer pubkey");
+
+    for (auto &peer: signer.PeersCache()) {
+        uint16_t confirm_seq = 0;
+        {   std::shared_lock recv_lock(recv_mutex(peer.second));
+            if (!recv_queue(peer.second).empty())
+                confirm_seq = rgs::max(recv_queue(peer.second)|vs::transform([](auto& s){ return s.message->confirmed_sequence; }));
+        }
+
+        std::unique_lock send_lock(send_mutex(peer.second));
+
+        auto send_it = rgs::find_if(send_queue(peer.second), [](const auto& s){
+            return s.message->id == p2p::FROST_MESSAGE::SIGNATURE_COMMITMENT && s.status == FrostStatus::Ready;
+        });
+        if (send_it != send_queue(peer.second).end()) {
+            DefaultSend(signer, peer.first, *send_it, confirm_seq);
+        }
+    }
+    SendStatus(FrostStatus::Completed);
+    return true;
+}
+
+bool SigCommit::MessageReceive(FrostSignerBase& signer, details::peer_messages &peer_cache)
+{
+    std::unique_lock recv_lock(recv_mutex(peer_cache));
+
+    auto recv_it = rgs::find_if(recv_queue(peer_cache), [](const auto& s){
+        return s.message->id == p2p::FROST_MESSAGE::SIGNATURE_COMMITMENT && s.status == FrostStatus::Ready;
+    });
+    if (recv_it != recv_queue(peer_cache).end() && DefaultReceive(signer, *recv_it) && ++commitments_received >= (signer.K - 1)) {
+        RecvStatus(FrostStatus::Completed);
+        return true;
+    }
+    return false;
+}
+}
\ No newline at end of file
diff --git a/src/frost/frost_steps.hpp b/src/frost/frost_steps.hpp
new file mode 100644
index 0000000..9512c38
--- /dev/null
+++ b/src/frost/frost_steps.hpp
@@ -0,0 +1,423 @@
+#pragma once
+
+#include <concepts>
+
+#include "frost_common.hpp"
+#include "async_result.hpp"
+
+namespace l15::frost {
+
+namespace details {
+
+typedef std::deque<details::message_status> message_queue;
+typedef std::unique_ptr<std::shared_mutex> shared_mutex_ptr;
+typedef std::tuple<message_queue, shared_mutex_ptr, message_queue, shared_mutex_ptr> peer_messages;
+typedef std::unordered_map<xonly_pubkey, peer_messages, l15::hash<xonly_pubkey>> operation_cache;
+
+}
+
+class FrostOperationFailure: public Error
+{
+    const details::OperationMapId mFailOpId;
+public:
+    explicit FrostOperationFailure(details::OperationMapId op) noexcept
+            : Error(op.describe()), mFailOpId(op) {}
+    FrostOperationFailure(const FrostOperationFailure&) = default;
+    FrostOperationFailure(FrostOperationFailure&&) = default;
+
+    const char* what() const noexcept override
+    { return "FrostOperationFailure"; }
+};
+
+class FrostSignerBase {
+protected:
+    friend class FrostStep;
+    friend class NonceCommit;
+    friend class KeyCommit;
+    friend class KeyShare;
+    friend class SigCommit;
+    friend class SigAgg;
+
+    const size_t N;
+    const size_t K;
+
+    std::shared_ptr<core::SignerApi> mSignerApi;
+    std::shared_ptr<signer_service::SignerService> mSignerService;
+    std::shared_ptr<p2p::P2PInterface<xonly_pubkey, p2p::FrostMessage>> mPeerService;
+
+    details::operation_cache m_peers_cache;
+
+    FrostSignerBase(core::ChannelKeys keypair, std::ranges::input_range auto&& peers,
+                    std::shared_ptr<signer_service::SignerService> signerService,
+                    std::shared_ptr<p2p::P2PInterface<xonly_pubkey, p2p::FrostMessage>> peerService)
+            : N(std::ranges::size(peers)), K((N%2) ? (N+1)/2 : N/2)
+            , mSignerApi(std::make_shared<core::SignerApi>(move(keypair), N, K)), mSignerService(move(signerService)), mPeerService(move(peerService))
+            , m_peers_cache(N)
+    {
+        std::ranges::for_each(peers | std::views::filter([this](auto& p){ return p != mSignerApi->GetLocalPubKey(); }), [this](const auto &peer){
+                    auto& p = m_peers_cache[peer]; // Initialize map with default elements per peer
+                    std::get<1>(p) = std::make_unique<std::shared_mutex>();
+                    std::get<3>(p) = std::make_unique<std::shared_mutex>();
+                });
+    }
+    virtual ~FrostSignerBase() = default;
+
+    signer_service::SignerService& SignerService()
+    { return *mSignerService; }
+
+    p2p::P2PInterface<xonly_pubkey, p2p::FrostMessage>& PeerService()
+    { return *mPeerService; }
+
+    std::shared_ptr<core::SignerApi> SignerApi()
+    { return mSignerApi; }
+
+    details::operation_cache& PeersCache()
+    { return m_peers_cache; }
+
+    virtual void HandleError() = 0;
+
+};
+
+
+struct FrostStep
+{
+    std::weak_ptr<FrostSignerBase> mSigner;
+    details::OperationMapId mOpId;
+    std::atomic<uint16_t> m_status;
+
+    details::OperationMapId OperatonId() const
+    { return mOpId; }
+
+    uint16_t SendStatus() const { return get_send_status(m_status); }
+    void SendStatus(FrostStatus status)
+    {
+        uint16_t cur_status;
+        do {
+            cur_status = m_status;
+            if (get_send_status(cur_status) & (uint16_t)status) {
+                throw WrongFrostState(translate(status) + " step send status is already set");
+            }
+        } while (!m_status.compare_exchange_strong(cur_status, cur_status | set_send_status((uint16_t) status), std::memory_order_relaxed));
+    }
+    uint16_t RecvStatus() const { return get_recv_status(m_status); }
+    void RecvStatus(FrostStatus status)     {
+        uint16_t cur_status;
+        do {
+            cur_status = m_status;
+        } while (!m_status.compare_exchange_strong(cur_status, cur_status | set_recv_status((uint16_t) status), std::memory_order_relaxed));
+    }
+
+    explicit FrostStep(std::weak_ptr<FrostSignerBase>&& signer, details::OperationMapId opid) : mSigner(move(signer)), mOpId(move(opid)), m_status(0) {}
+    virtual ~FrostStep() = default;
+
+    virtual const char *Name() const noexcept = 0;
+
+    FrostStatus Status() const
+    {
+        uint16_t cur_status = m_status;
+        uint16_t send_status = get_send_status(cur_status);
+        uint16_t recv_status = get_recv_status(cur_status);
+        if (send_status == (uint16_t)FrostStatus::Ready) {
+            return FrostStatus::Ready;
+        }
+        else {
+            if ((send_status & (uint16_t)FrostStatus::Confirmed) && (recv_status & (uint16_t)FrostStatus::Confirmed))
+                return FrostStatus::Confirmed;
+            else if ((send_status & ((uint16_t)FrostStatus::Confirmed | (uint16_t)FrostStatus::Completed))
+                     && (recv_status & ((uint16_t)FrostStatus::Confirmed | (uint16_t)FrostStatus::Completed)))
+                return FrostStatus::Completed;
+            else
+                return FrostStatus::InProgress;
+        }
+    }
+    bool IsCompleted() const
+    {
+        uint16_t cur_status = m_status;
+        return (get_send_status(cur_status) & (uint16_t)FrostStatus::Completed) && (get_recv_status(cur_status) & (uint16_t)FrostStatus::Completed);
+    }
+
+    bool IsConfirmed() const
+    {
+        uint16_t cur_status = m_status;
+        return (get_send_status(cur_status) & (uint16_t)FrostStatus::Confirmed) && (get_recv_status(cur_status) & (uint16_t)FrostStatus::Confirmed);
+    }
+
+    void DefaultSend(FrostSignerBase& signer, const xonly_pubkey&, details::message_status&, uint16_t confirm_seq) const;
+    //void DefaultPublish(p2p::FROST_MESSAGE id);
+
+    /// Returns true if message is arrived at a first time (no duplicate is found)
+    bool DefaultReceive(FrostSignerBase& signer, details::message_status &recv_status) const;
+
+    /// return: true if the message passed as urgument is queued
+    bool CheckAndQueueSendImpl(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &, p2p::frost_message_ptr, p2p::FROST_MESSAGE);
+    virtual bool CheckAndQueueSend(FrostSignerBase &signer, const std::optional<const xonly_pubkey> &, p2p::frost_message_ptr) = 0;
+
+    /// Return true if this step is in completed state after sending the message
+    virtual bool MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &) = 0;
+
+    /// return: true if the message passed as urgument is queued
+    bool CheckAndQueueReceiveImpl(FrostSignerBase& signer, p2p::frost_message_ptr, p2p::FROST_MESSAGE);
+    virtual bool CheckAndQueueReceive(FrostSignerBase &signer, p2p::frost_message_ptr) = 0;
+
+    /// Return true if this step is in completed state after receiving the message
+    virtual bool MessageReceive(FrostSignerBase &signer, const xonly_pubkey &) = 0;
+
+    virtual std::shared_ptr<FrostStep> GetNextStep() = 0;
+};
+
+
+
+struct NonceCommit : public FrostStep
+{
+    explicit NonceCommit(std::weak_ptr<FrostSignerBase>&& s, details::OperationMapId opid) : FrostStep(move(s), move(opid)) {
+        assert(mOpId.optype == details::OperationType::nonce && IsZeroArray(mOpId.opid));
+        SendStatus(FrostStatus::InProgress);
+    }
+
+    const char *Name() const noexcept override
+    { return "NonceCommit"; }
+
+    bool CheckAndQueueSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueSendImpl(signer, peer_pk, m, p2p::FROST_MESSAGE::NONCE_COMMITMENTS); }
+
+    bool CheckAndQueueReceive(FrostSignerBase& signer, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueReceiveImpl(signer, m, p2p::FROST_MESSAGE::NONCE_COMMITMENTS); }
+
+    bool MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk) override;
+
+    bool MessageReceive(FrostSignerBase& signer, details::peer_messages& peer_cache);
+
+    bool MessageReceive(FrostSignerBase& signer, const xonly_pubkey &peer_pk) override
+    { return MessageReceive(signer, signer.PeersCache().at(peer_pk)); }
+
+    template<std::derived_from<cex::async_result_base<void>> RES>
+    void Start(RES&& op_handler, size_t count) {
+        auto signer = mSigner.lock();
+        if (signer) {
+            signer->SignerService().CommitSigNonces(signer->SignerApi(), count, std::forward<RES>(op_handler));
+
+            for (auto &peer_cache: signer->PeersCache() | std::views::values) {
+                MessageReceive(*signer, peer_cache);
+            }
+        }
+    }
+
+    std::shared_ptr<FrostStep> GetNextStep() override
+    { return nullptr; }
+};
+
+
+struct KeyShare : public FrostStep
+{
+    std::atomic_size_t keyshares_sent;
+    std::atomic_size_t keyshares_received;
+
+    explicit KeyShare(std::weak_ptr<FrostSignerBase>&& s, details::OperationMapId opid) : FrostStep(move(s), move(opid)), keyshares_sent(0), keyshares_received(0) {}
+
+    const char *Name() const noexcept override
+    { return "KeyShare"; }
+
+    bool CheckAndQueueSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueSendImpl(signer, peer_pk, m, p2p::FROST_MESSAGE::KEY_SHARE); }
+
+    bool CheckAndQueueReceive(FrostSignerBase& signer, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueReceiveImpl(signer, m, p2p::FROST_MESSAGE::KEY_SHARE); }
+
+    bool MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk) override;
+
+    bool MessageReceive(FrostSignerBase& signer, details::peer_messages& peer_cache);
+
+    bool MessageReceive(FrostSignerBase& signer, const xonly_pubkey &peer_pk) override
+    { return MessageReceive(signer, signer.PeersCache().at(peer_pk)); }
+
+    template<std::derived_from<cex::async_result_base<const xonly_pubkey&>> RES>
+    void Start(RES&& op_handler)
+    {
+        if (auto signer = mSigner.lock()) {
+            //clog << (std::ostringstream() << Name() << "::Start() " << hex(signer->SignerApi()->GetLocalPubKey()).substr(0, 8) << ", " << std::this_thread::get_id).str() << std::endl;
+            SendStatus(FrostStatus::InProgress);
+
+            signer->SignerService().NegotiateKey(signer->SignerApi(),
+                cex::make_async_result<const xonly_pubkey&>([ws = mSigner](const xonly_pubkey& aggpk, RES&& op_handler){
+                    auto signer = ws.lock();
+                    if (signer) {
+                        std::clog << (std::ostringstream() << "KeyShare API completed: " << hex(signer->SignerApi()->GetLocalPubKey()).substr(0, 8)).str() << std::endl;
+                        op_handler(aggpk);
+                    }
+                }, [](RES&& op_handler){
+                    op_handler.on_error();
+                }, std::forward<RES>(op_handler)));
+
+            for (auto &peer_cache: signer->PeersCache() | std::views::values) {
+                MessageReceive(*signer, peer_cache);
+            }
+        }
+    }
+
+    std::shared_ptr<FrostStep> GetNextStep() override
+    { return nullptr; }
+};
+
+struct KeyCommit : public FrostStep
+{
+    std::atomic_size_t commitments_received;
+    std::shared_ptr<KeyShare> next_step;
+
+    explicit KeyCommit(std::weak_ptr<FrostSignerBase>&& s, details::OperationMapId opid)
+            : FrostStep(move(s), move(opid)), commitments_received(0), next_step(MakeNextStep())
+    {
+        assert(mOpId.optype == details::OperationType::key && IsZeroArray(mOpId.opid));
+    }
+
+    const char *Name() const noexcept override
+    { return "KeyCommit"; }
+
+    bool CheckAndQueueSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueSendImpl(signer, peer_pk, m, p2p::FROST_MESSAGE::KEY_COMMITMENT); }
+
+    bool CheckAndQueueReceive(FrostSignerBase& signer, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueReceiveImpl(signer, m, p2p::FROST_MESSAGE::KEY_COMMITMENT); }
+
+    bool MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk) override;
+
+    bool MessageReceive(FrostSignerBase& signer, details::peer_messages& peer_cache);
+
+    bool MessageReceive(FrostSignerBase& signer, const xonly_pubkey &peer_pk) override
+    { return MessageReceive(signer, signer.PeersCache().at(peer_pk)); }
+
+    template<std::derived_from<cex::async_result_base<const xonly_pubkey&>> RES>
+    void Start(RES&& op_handler)
+    {
+        if (auto signer = mSigner.lock()) {
+
+            auto shared_handler = cex::shared_async_result<const xonly_pubkey&>(op_handler.forward());
+
+            SendStatus(FrostStatus::InProgress);
+            signer->SignerService().ProcessKeyShareCommitment(signer->SignerApi(),
+                cex::make_async_result<void>([next_step = next_step, signerapi = signer->SignerApi(), shared_handler]() mutable {
+                    std::clog << (std::ostringstream() << "KeyCommit completed: " << hex(signerapi->GetLocalPubKey()).substr(0, 8)).str() << std::endl;
+                    next_step->Start(move(shared_handler));
+                }, [shared_handler]() mutable {
+                    shared_handler.on_error();
+                }));
+
+            for (auto &peer_cache: signer->PeersCache() | std::views::values) {
+                MessageReceive(*signer, peer_cache);
+            }
+        }
+    }
+
+    std::shared_ptr<KeyShare> MakeNextStep()
+    { return std::make_shared<KeyShare>(std::weak_ptr<FrostSignerBase>(mSigner), mOpId); }
+
+
+    std::shared_ptr<FrostStep> GetNextStep() override
+    { return next_step; }
+};
+
+
+struct SigAgg : public FrostStep, std::enable_shared_from_this<SigAgg>
+{
+    std::atomic_size_t sigshares_sent;
+    std::atomic_size_t sigshares_received;
+
+    explicit SigAgg(std::weak_ptr<FrostSignerBase> s, details::OperationMapId opid)
+            : FrostStep(move(s), move(opid))
+            , sigshares_sent(0)
+            , sigshares_received(0)
+    {}
+
+    const char *Name() const noexcept override
+    { return "SigAgg"; }
+
+    bool CheckAndQueueSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueSendImpl(signer, peer_pk, m, p2p::FROST_MESSAGE::SIGNATURE_SHARE); }
+
+    bool CheckAndQueueReceive(FrostSignerBase& signer, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueReceiveImpl(signer, m, p2p::FROST_MESSAGE::SIGNATURE_SHARE); }
+
+    bool MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk) override;
+
+    bool MessageReceive(FrostSignerBase& signer, details::peer_messages& peer_cache);
+
+    bool MessageReceive(FrostSignerBase& signer, const xonly_pubkey &peer_pk) override
+    { return MessageReceive(signer, signer.PeersCache().at(peer_pk)); }
+
+    template<std::derived_from<cex::async_result_base<signature>> RES>
+    void Start(RES&& op_handler)
+    {
+        if (auto signer = mSigner.lock()) {
+            clog << (std::ostringstream() << Name() << "::Start() " << hex(signer->SignerApi()->GetLocalPubKey()).substr(0, 8) << ", " << std::this_thread::get_id).str() << std::endl;
+            SendStatus(FrostStatus::InProgress);
+
+            signer->SignerService().Sign(signer->SignerApi(), OperatonId().opid, std::forward<RES>(op_handler));
+
+            for (auto &peer_cache: signer->PeersCache() | std::views::values) {
+                MessageReceive(*signer, peer_cache);
+            }
+        }
+    }
+
+    std::shared_ptr<FrostStep> GetNextStep() override
+    { return nullptr; }
+};
+
+struct SigCommit : public FrostStep
+{
+    std::atomic_size_t commitments_received;
+    std::shared_ptr<SigAgg> next_step;
+    scalar message;
+
+    std::shared_ptr<SigAgg> MakeNextStep()
+    { return std::make_shared<SigAgg>(mSigner, mOpId); }
+
+    explicit SigCommit(std::weak_ptr<FrostSignerBase>&& s, details::OperationMapId opid, scalar m)
+            : FrostStep(move(s), move(opid)), commitments_received(0), next_step(MakeNextStep()), message(move(m))
+    {
+        assert(mOpId.optype == details::OperationType::sign && !IsZeroArray(mOpId.opid));
+    }
+
+    const char *Name() const noexcept override
+    { return "SigCommit"; }
+
+    bool CheckAndQueueSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueSendImpl(signer, peer_pk, m, p2p::FROST_MESSAGE::SIGNATURE_COMMITMENT); }
+
+    bool CheckAndQueueReceive(FrostSignerBase& signer, p2p::frost_message_ptr m) override
+    { return FrostStep::CheckAndQueueReceiveImpl(signer, m, p2p::FROST_MESSAGE::SIGNATURE_COMMITMENT); }
+
+    bool MessageSend(FrostSignerBase& signer, const std::optional<const xonly_pubkey> &peer_pk) override;
+
+    bool MessageReceive(FrostSignerBase& signer, details::peer_messages& peer_cache);
+
+    bool MessageReceive(FrostSignerBase& signer, const xonly_pubkey &peer_pk) override
+    { return MessageReceive(signer, signer.PeersCache().at(peer_pk)); }
+
+    template<std::derived_from<cex::async_result_base<signature>> RES>
+    void Start(RES&& op_handler) {
+        if (auto signer = mSigner.lock()) {
+
+            auto shared_handler = cex::shared_async_result<signature>(op_handler.forward());
+
+            SendStatus(FrostStatus::InProgress);
+
+            signer->SignerService().ProcessSignatureCommitments(signer->SignerApi(), message, OperatonId().opid, true,
+                cex::make_async_result<void>([next_step=next_step, signerapi=signer->SignerApi(), shared_handler]() mutable {
+                    std::clog << (std::ostringstream() << "SigCommit completed: " << hex(signerapi->GetLocalPubKey()).substr(0, 8)).str() << std::endl;
+                    next_step->Start(move(shared_handler));
+                }, [shared_handler]() mutable {
+                    shared_handler.on_error();
+                }));
+
+            for (auto &peer_cache: signer->PeersCache() | std::views::values) {
+                MessageReceive(*signer, peer_cache);
+            }
+        }
+    }
+
+    std::shared_ptr<FrostStep> GetNextStep() override
+    { return next_step; }
+};
+
+
+}
diff --git a/src/p2p/p2p_frost.hpp b/src/p2p/p2p_frost.hpp
index 5ed13a3..3e91bf1 100644
--- a/src/p2p/p2p_frost.hpp
+++ b/src/p2p/p2p_frost.hpp
@@ -5,6 +5,8 @@
 
 #include "smartinserter.hpp"
 
+#include "crypto/sha256.h"
+
 #include "p2p_protocol.hpp"
 #include "p2p_link.hpp"
 #include "common_frost.hpp"
@@ -13,6 +15,8 @@ namespace l15::p2p {
 
 
 enum class FROST_MESSAGE: uint16_t {
+    NO_VALUE,
+    KEEP_ALIVE = NO_VALUE,
     NONCE_COMMITMENTS,
     KEY_COMMITMENT,
     KEY_SHARE,
@@ -22,6 +26,25 @@ enum class FROST_MESSAGE: uint16_t {
     MESSAGE_ID_COUNT
 };
 
+inline std::string describe(FROST_MESSAGE id)
+{
+    switch(id) {
+    case FROST_MESSAGE::NO_VALUE:
+        return "NO_VALUE/KEEP_ALIVE";
+    case FROST_MESSAGE::NONCE_COMMITMENTS:
+        return "NONCE_COMMITMENTS";
+    case FROST_MESSAGE::KEY_COMMITMENT:
+        return "KEY_COMMITMENT";
+    case FROST_MESSAGE::KEY_SHARE:
+        return "KEY_SHARE";
+    case FROST_MESSAGE::SIGNATURE_COMMITMENT:
+        return "SIGNATURE_COMMITMENT";
+    case FROST_MESSAGE::SIGNATURE_SHARE:
+        return "SIGNATURE_SHARE";
+    default:
+        throw std::runtime_error("Wrong FROST_MESSAGE");
+    }
+}
 
 template <typename STREAM>
 STREAM& operator << (STREAM& s, const FROST_MESSAGE& p)
@@ -34,32 +57,40 @@ STREAM& operator >> (STREAM& s, FROST_MESSAGE& p)
 class FrostMessage;
 
 typedef std::shared_ptr<FrostMessage> frost_message_ptr;
-typedef std::function<void(frost_message_ptr)> frost_link_handler;
+//typedef std::function<void(frost_message_ptr)> frost_link_handler;
 
 class FrostMessage : public Message
 {
 public:
     FROST_MESSAGE id;
+    uint16_t confirmed_sequence;
     xonly_pubkey pubkey;
 
-    FrostMessage(FROST_MESSAGE msg_id, xonly_pubkey&& pk): Message(PROTOCOL::FROST), id(msg_id), pubkey(move(pk)) {}
-    FrostMessage(FrostMessage&& r) noexcept : Message(PROTOCOL::FROST), id(r.id), pubkey(move(r.pubkey)) {}
+    FrostMessage(uint16_t seq, FROST_MESSAGE msg_id, xonly_pubkey&& pk): Message(PROTOCOL::FROST, seq), id(msg_id), confirmed_sequence(0), pubkey(move(pk)) {}
+    FrostMessage(FrostMessage&& r) noexcept : Message(PROTOCOL::FROST, r.sequence), id(r.id), confirmed_sequence(r.confirmed_sequence), pubkey(move(r.pubkey)) {}
+    FrostMessage(const FrostMessage& r) : Message(PROTOCOL::FROST, r.sequence), id(r.id), confirmed_sequence(r.confirmed_sequence), pubkey(r.pubkey) {}
+
+    virtual bool operator==(const FrostMessage& r) const
+    { return id == r.id && pubkey == r.pubkey; }
 
     template <typename STREAM>
     void Serialize(STREAM& stream) const
-    { stream << protocol_id << id << pubkey; }
+    { stream << protocol_id << sequence << confirmed_sequence << id << pubkey; }
 
     template <typename STREAM>
     void Unserialize(STREAM& stream)
-    { stream >> protocol_id >> id >> pubkey; }
+    { stream >> protocol_id >> sequence >> confirmed_sequence >> id >> pubkey; }
 
     ~FrostMessage() override = default;
 
+    virtual frost_message_ptr Copy()
+    { return std::make_shared<FrostMessage>(*this); }
+
     virtual std::string ToString() const
     { return ""; };
 
 protected:
-    FrostMessage() : Message(PROTOCOL::WRONG_PROTOCOL), id(FROST_MESSAGE::MESSAGE_ID_COUNT), pubkey() {}
+    FrostMessage() : Message(), id(FROST_MESSAGE::NO_VALUE), confirmed_sequence(0), pubkey() {}
 
     template<typename STREAM>
     friend frost_message_ptr Unserialize(const secp256k1_context* ctx, STREAM& stream);
@@ -105,14 +136,41 @@ class UnserializeError : public Error {
 
 };
 
+class UnknownPeer: public Error {
+public:
+    explicit UnknownPeer(std::string&& peer) : Error(move(peer)) {}
+
+    const char* what() const noexcept override
+    { return "UnknownPeer"; }
+};
+
+class SendError: public Error {
+public:
+    explicit SendError(std::string&& peer) : Error(move(peer)) {}
+
+    const char* what() const noexcept override
+    { return "SendError"; }
+};
+
+class WrongAddress: public Error {
+public:
+    explicit WrongAddress(std::string&& addr) : Error(move(addr)) {}
+
+    const char* what() const noexcept override
+    { return "WrongAddress"; }
+};
 
 class NonceCommitments : public FrostMessage
 {
 public:
     std::vector<secp256k1_frost_pubnonce> nonce_commitments;
 
-    explicit NonceCommitments(xonly_pubkey&& pk) noexcept : FrostMessage(FROST_MESSAGE::NONCE_COMMITMENTS, move(pk)) {}
+    explicit NonceCommitments(uint16_t sequence, xonly_pubkey&& pk) noexcept : FrostMessage(sequence, FROST_MESSAGE::NONCE_COMMITMENTS, move(pk)) {}
     NonceCommitments(NonceCommitments&& r) noexcept : FrostMessage(move(r)), nonce_commitments(move(r.nonce_commitments)) {}
+    NonceCommitments(const NonceCommitments& ) = default;
+
+    bool operator==(const FrostMessage& r) const override
+    { return false; } // Nonce commitments are not confirmed and cannot be repeated
 
     template <typename STREAM>
     void Serialize(const secp256k1_context* ctx, STREAM& stream) const
@@ -164,11 +222,23 @@ class NonceCommitments : public FrostMessage
         }
     }
 
+    frost_message_ptr Copy() override
+    { return std::make_shared<NonceCommitments>(*this); }
+
     std::string ToString() const override
     {
         std::stringstream buf;
-        buf << "NonceCommitments {pk: " << hex(pubkey).substr(0, 8) << "...}";
-        return move(buf.str());
+        buf << "NonceCommitments {pk: " << hex(pubkey).substr(0, 8) << "...";
+
+        for(const auto& pubnonce: nonce_commitments) {
+            scalar nonceid;
+            CSHA256().Write(pubnonce.data, sizeof(pubnonce.data)).Finalize(nonceid.data());
+
+            buf << " " << hex(nonceid).substr(0, 9) << "...";
+        }
+        buf << "}";
+
+        return buf.str();
     }
 
 private:
@@ -183,8 +253,9 @@ class KeyShareCommitment : public FrostMessage
 public:
     std::vector<secp256k1_pubkey> share_commitment;
 
-    explicit KeyShareCommitment(xonly_pubkey&& pk) noexcept : FrostMessage(FROST_MESSAGE::KEY_COMMITMENT, move(pk)) {}
+    explicit KeyShareCommitment(uint16_t sequence, xonly_pubkey&& pk) noexcept : FrostMessage(sequence, FROST_MESSAGE::KEY_COMMITMENT, move(pk)) {}
     KeyShareCommitment(KeyShareCommitment&& r) noexcept: FrostMessage(move(r)), share_commitment(move(r.share_commitment)) {}
+    KeyShareCommitment(const KeyShareCommitment& ) = default;
 
     template <typename STREAM>
     void Serialize(const secp256k1_context* ctx, STREAM& stream) const
@@ -212,7 +283,7 @@ class KeyShareCommitment : public FrostMessage
         FrostMessage::Unserialize(stream);
 
         size_t count = stream.remains() / 33;
-        if (count < 3) {
+        if (count < 2) {
             std::stringstream hexstr;
             hexstr << hex(stream);
             throw UnserializeError(hexstr.str());
@@ -239,6 +310,9 @@ class KeyShareCommitment : public FrostMessage
         }
     }
 
+    frost_message_ptr Copy() override
+    { return std::make_shared<KeyShareCommitment>(*this); }
+
     std::string ToString() const override
     {
         std::stringstream buf;
@@ -258,18 +332,19 @@ class KeyShare : public FrostMessage
 public:
     secp256k1_frost_share share;
 
-    explicit KeyShare(xonly_pubkey&& pk) noexcept : FrostMessage(FROST_MESSAGE::KEY_SHARE, move(pk)) {}
+    explicit KeyShare(uint16_t sequence, xonly_pubkey&& pk) noexcept : FrostMessage(sequence, FROST_MESSAGE::KEY_SHARE, move(pk)), share() {}
     KeyShare(KeyShare&& r) noexcept: FrostMessage(move(r)), share(r.share) {}
+    KeyShare(const KeyShare& ) = default;
 
     template <typename STREAM>
-    void Serialize(const secp256k1_context* ctx, STREAM& stream) const
+    void Serialize(const secp256k1_context* , STREAM& stream) const
     {
         FrostMessage::Serialize(stream);
         stream.write(share.data, sizeof(share.data));
     }
 
     template <typename STREAM>
-    void Unserialize(const secp256k1_context* ctx, STREAM& stream)
+    void Unserialize(const secp256k1_context* , STREAM& stream)
     {
         FrostMessage::Unserialize(stream);
 
@@ -282,6 +357,9 @@ class KeyShare : public FrostMessage
         stream.read(share.data, sizeof(share.data));
     }
 
+    frost_message_ptr Copy() override
+    { return std::make_shared<KeyShare>(*this); }
+
     std::string ToString() const override
     {
         std::stringstream buf;
@@ -299,33 +377,38 @@ class KeyShare : public FrostMessage
 class SignatureCommitment : public FrostMessage
 {
 public:
-    uint32_t operation_id;
-    SignatureCommitment(xonly_pubkey&& pk, uint32_t opid) noexcept : FrostMessage(FROST_MESSAGE::SIGNATURE_COMMITMENT, move(pk)), operation_id(opid) {}
-    SignatureCommitment(SignatureCommitment&& r) noexcept : FrostMessage(move(r)), operation_id(r.operation_id) {}
+    scalar operation_id;
+    scalar nonce_id;
+    SignatureCommitment(uint16_t sequence, xonly_pubkey&& pk, const scalar& opid, const scalar& nonceid) noexcept : FrostMessage(sequence, FROST_MESSAGE::SIGNATURE_COMMITMENT, move(pk)), operation_id(opid), nonce_id(nonceid) {}
+    SignatureCommitment(SignatureCommitment&& r) noexcept = default;
+    SignatureCommitment(const SignatureCommitment& ) = default;
 
     template <typename STREAM>
-    void Serialize(const secp256k1_context* ctx, STREAM& stream) const
+    void Serialize(const secp256k1_context* , STREAM& stream) const
     {
         FrostMessage::Serialize(stream);
-        stream << operation_id;
+        stream << operation_id << nonce_id;
     }
 
     template <typename STREAM>
-    void Unserialize(const secp256k1_context* ctx, STREAM& stream)
+    void Unserialize(const secp256k1_context* , STREAM& stream)
     {
         FrostMessage::Unserialize(stream);
-        stream >> operation_id;
+        stream >> operation_id >> nonce_id;
     }
 
+    frost_message_ptr Copy() override
+    { return std::make_shared<SignatureCommitment>(*this); }
+
     std::string ToString() const override
     {
         std::stringstream buf;
-        buf << "SignatureCommitment {pk: " << hex(pubkey).substr(0, 8) << "...}";
+        buf << "SignatureCommitment {pk: " << hex(pubkey).substr(0, 8) << "..., op: " << hex(operation_id).substr(0, 8) << "... " << hex(nonce_id).substr(0, 8) << "...}";
         return move(buf.str());
     }
 
 private:
-    SignatureCommitment() : FrostMessage(), operation_id(0) {}
+    SignatureCommitment() : FrostMessage(), operation_id(0U), nonce_id(0U) {}
 
     template<typename STREAM>
     friend frost_message_ptr Unserialize(const secp256k1_context* ctx, STREAM& stream);
@@ -334,21 +417,22 @@ class SignatureCommitment : public FrostMessage
 class SignatureShare : public FrostMessage
 {
 public:
-    uint32_t operation_id;
+    scalar operation_id;
     frost_sigshare share;
 
-    SignatureShare(xonly_pubkey&& pk, uint32_t opid) noexcept : FrostMessage(FROST_MESSAGE::SIGNATURE_SHARE, move(pk)), operation_id(opid), share{} {}
+    SignatureShare(uint16_t sequence, xonly_pubkey&& pk, const scalar& opid) noexcept : FrostMessage(sequence, FROST_MESSAGE::SIGNATURE_SHARE, move(pk)), operation_id(opid), share{} {}
     SignatureShare(SignatureShare&& r) noexcept : FrostMessage(move(r)), operation_id(r.operation_id), share(move(r.share)) {}
+    SignatureShare(const SignatureShare& ) = default;
 
     template <typename STREAM>
-    void Serialize(const secp256k1_context* ctx, STREAM& stream) const
+    void Serialize(const secp256k1_context* , STREAM& stream) const
     {
         FrostMessage::Serialize(stream);
         stream << operation_id << share;
     }
 
     template <typename STREAM>
-    void Unserialize(const secp256k1_context* ctx, STREAM& stream)
+    void Unserialize(const secp256k1_context* , STREAM& stream)
     {
         FrostMessage::Unserialize(stream);
 
@@ -361,10 +445,13 @@ class SignatureShare : public FrostMessage
         stream >> operation_id >> share;
     }
 
+    frost_message_ptr Copy() override
+    { return std::make_shared<SignatureShare>(*this); }
+
     std::string ToString() const override
     {
         std::stringstream buf;
-        buf << "SignatureShare {pk: " << hex(pubkey).substr(0, 8) << "... " << hex(share) << '}';
+        buf << "SignatureShare {pk: " << hex(pubkey).substr(0, 8) << "..., op: "  << hex(operation_id).substr(0, 8) << "... "<< hex(share) << '}';
         return move(buf.str());
     }
 
@@ -420,6 +507,9 @@ frost_message_ptr Unserialize(const secp256k1_context* ctx, STREAM& stream)
     FrostMessage header;
     auto pos = stream.position();
     header.Unserialize(stream);
+    if (header.id == FROST_MESSAGE::KEEP_ALIVE) {
+        return std::make_shared<FrostMessage>(move(header));
+    }
     stream.rewind(stream.position() - pos);
 
     switch (header.id) {
diff --git a/src/p2p/p2p_link.hpp b/src/p2p/p2p_link.hpp
index 4adbcd5..bc05813 100644
--- a/src/p2p/p2p_link.hpp
+++ b/src/p2p/p2p_link.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <memory>
+#include <functional>
+#include <sstream>
 
 #include "common_error.hpp"
 #include "p2p_protocol.hpp"
@@ -9,27 +11,40 @@ namespace l15::p2p {
 
 struct Message
 {
-    PROTOCOL protocol_id;
+    PROTOCOL protocol_id; //uint16_t
+    uint16_t sequence;
 
-    Message() noexcept : protocol_id(PROTOCOL::WRONG_PROTOCOL) {}
-    explicit Message(PROTOCOL protocol) noexcept : protocol_id(protocol) {}
+    Message() noexcept : protocol_id(PROTOCOL::WRONG_PROTOCOL), sequence(1) {}
+    explicit Message(PROTOCOL protocol, uint16_t seq) noexcept : protocol_id(protocol), sequence(seq) {}
 
     virtual ~Message() = default;
-
 };
 
 
 class WrongProtocol: public Error {
 public:
-    explicit WrongProtocol(uint16_t protocol) : protocol_id(protocol) {}
+    explicit WrongProtocol(uint16_t protocol) : Error((std::ostringstream() << protocol).str()) {}
     ~WrongProtocol() override = default;
 
     const char* what() const noexcept override
     { return "WrongProtocol"; }
-
-    uint16_t protocol_id;
 };
 
 
+template <class ADDR, class MESSAGE>
+class P2PInterface {
+public:
+    virtual void Publish(std::shared_ptr<MESSAGE>,
+                         std::function<void(const ADDR&, std::shared_ptr<MESSAGE>)> on_send,
+                         std::function<void(const ADDR&, std::shared_ptr<MESSAGE>)> on_error) = 0;
+
+    virtual void Send(const ADDR&, std::shared_ptr<MESSAGE>,
+                      std::function<void()> on_error) = 0;
+
+    virtual void Connect(const ADDR&, std::function<void(std::shared_ptr<MESSAGE>)>) = 0;
+
+    virtual ~P2PInterface() = default;
+};
+
 
 }
\ No newline at end of file
diff --git a/src/service/Makefile.am b/src/service/Makefile.am
index 5285a22..7f39d49 100644
--- a/src/service/Makefile.am
+++ b/src/service/Makefile.am
@@ -1,5 +1,6 @@
 
 AM_CPPFLAGS = $(ZMQ_CPPFLAGS) \
+ -DZMQ_BUILD_DRAFT_API=1 $(ZMQ_CPPFLAGS) \
  -I$(top_srcdir)/node/src \
  -I$(top_srcdir)/node/src/univalue/include \
  -I$(top_srcdir)/node/src/consensus \
@@ -9,6 +10,7 @@ AM_CPPFLAGS = $(ZMQ_CPPFLAGS) \
  -I$(top_srcdir)/src/common \
  -I$(top_srcdir)/src/core \
  -I$(top_srcdir)/src/p2p \
+ -I$(top_srcdir)/src/frost \
  -I$(top_srcdir)/contrib/cex
 
 
diff --git a/src/service/onchain_service.cpp b/src/service/onchain_service.cpp
index df877d6..d419485 100644
--- a/src/service/onchain_service.cpp
+++ b/src/service/onchain_service.cpp
@@ -90,7 +90,7 @@ void OnChainService::MainCycle(std::string&& addr) // NOLINT(performance-unneces
             buffer.clear();
 
             m_block_handler(block.GetBlockHeader());
-            for (const CTransactionRef tx: block.vtx) {
+            for (const auto& tx: block.vtx) {
                 m_tx_handler(*tx);
             }
 ;        }
diff --git a/src/service/signer_service.cpp b/src/service/signer_service.cpp
index 900758a..e47a284 100644
--- a/src/service/signer_service.cpp
+++ b/src/service/signer_service.cpp
@@ -4,98 +4,11 @@
 
 namespace l15::signer_service {
 
-void SignerService::Accept(const xonly_pubkey &pk, p2p::frost_message_ptr msg)
+void SignerService::Accept(std::shared_ptr<core::SignerApi> ps, p2p::frost_message_ptr msg)
 {
-    auto it = m_signers.find(&pk);
-    if (it != m_signers.end()) {
-        std::shared_ptr<core::SignerApi> signer = it->second;
+    ps->Accept(*msg);
 
-        signer->Accept(*msg);
-
-        //mBgService->Serve([=](){ signer->Accept(*msg); });
-    }
-}
-
-
-std::future<const xonly_pubkey&> SignerService::NegotiateKey(const xonly_pubkey &signer_key)
-{
-    auto ps = m_signers[&signer_key];
-
-    std::promise<const xonly_pubkey&> p;
-    auto res = p.get_future();
-
-    mBgService->Serve([this, ps](std::promise<const xonly_pubkey&>&& p1)
-        {
-            ps->DistributeKeyShares([this, ps] (std::promise<const xonly_pubkey&>&& p2)
-                {
-                    mBgService->Serve([ps](std::promise<const xonly_pubkey&>&& p3)
-                    {
-                        ps->AggregateKey();
-                        p3.set_value(ps->GetAggregatedPubKey());
-                    }, move(p2));
-                }, move(p1));
-        }, move(p));
-
-    return move(res);
-}
-
-std::future<void> SignerService::PublishNonces(const xonly_pubkey &signer_key, size_t count)
-{
-    auto ps = m_signers[&signer_key];
-
-    std::promise<void> p;
-    auto res = p.get_future();
-
-    mBgService->Serve([ps, count](std::promise<void>&& p1)
-        {
-            ps->CommitNonces(count);
-            p1.set_value();
-        }, move(p));
-
-    return move(res);
-}
-
-std::future<signature> SignerService::Sign(const xonly_pubkey &signer_key, const uint256 &message, core::operation_id opid)
-{
-
-    auto ps = m_signers[&signer_key];
-
-    std::promise<signature> p;
-    auto res = p.get_future();
-
-    mBgService->Serve([=](std::promise<signature>&& p1)
-        {
-
-            auto comm_recv_hdl =  [=]()
-            {
-                try {
-                    ps->PreprocessSignature(message, opid);
-                    ps->DistributeSigShares(opid);
-                }
-                catch(std::exception& e) {
-                    // TODO: implement error processing here
-                    std::cerr << "Uncaught error: " << e.what() << std::endl;
-                }
-            };
-
-            auto sigshares_recv_hdl = [=](std::promise<signature>&& p2)
-            {
-                try {
-                    p2.set_value(ps->AggregateSignature(opid));
-                }
-                catch(...) {
-                    p2.set_exception(std::current_exception());
-                }
-                ps->ClearSignatureCache(opid);
-            };
-
-            ps->InitSignature(opid,
-                              core::make_callable_with_signer(move(comm_recv_hdl)),
-                              core::make_callable_with_signer(move(sigshares_recv_hdl), move(p1))
-            );
-        }, move(p));
-
-    return move(res);
+    //mBgService->Serve([=](){ ps->Accept(*msg); });
 }
 
 
diff --git a/src/service/signer_service.hpp b/src/service/signer_service.hpp
index f773b82..5d7a3c8 100644
--- a/src/service/signer_service.hpp
+++ b/src/service/signer_service.hpp
@@ -5,35 +5,161 @@
 #include <map>
 #include <mutex>
 
+#include "async_result.hpp"
+
 #include "common.hpp"
 #include "signer_api.hpp"
+#include "generic_service.hpp"
 
 namespace l15 {
 
-namespace service {
-class GenericService;
-}
 
 namespace signer_service {
 
 class SignerService
 {
     std::shared_ptr<service::GenericService> mBgService;
-    std::unordered_map<const xonly_pubkey*, std::shared_ptr<core::SignerApi>, l15::hash<xonly_pubkey*>, l15::equal_to<xonly_pubkey*>> m_signers;
+
 public:
-    explicit SignerService(std::shared_ptr<service::GenericService> bgService) : mBgService(move(bgService)), m_signers() {}
+    explicit SignerService(std::shared_ptr<service::GenericService> bgService) : mBgService(move(bgService)) {}
+
+    void Accept(std::shared_ptr<core::SignerApi> ps, p2p::frost_message_ptr msg);
+
+    template <std::derived_from<cex::async_result_base<void>> RES>
+    void ProcessKeyShareCommitment(std::shared_ptr<core::SignerApi> signer, RES&& handler)
+    {
+        mBgService->Serve([bgService=mBgService,
+                           ws=std::weak_ptr<core::SignerApi>(signer),
+                           shared_handler=cex::shared_async_result<void>(handler.forward())]()mutable{
+            try {
+                if (auto ps = ws.lock()) {
+                    ps->CommitKeyShares([bgService, shared_handler]()mutable{
+                        bgService->Serve([shared_handler]()mutable{
+                            try {
+                                shared_handler();
+                            }
+                            catch(...) {
+                                shared_handler.on_error();
+                            }
+                        });
+                    });
+                }
+                else std::cerr << "Signer API destroyed" << std::endl; }
+            catch (...) {
+                shared_handler.on_error();
+            }
+        });
+
+    }
 
-    void Accept(const xonly_pubkey& pk, p2p::frost_message_ptr msg);
+    template <std::derived_from<cex::async_result_base<const xonly_pubkey&>> RES>
+    void NegotiateKey(std::shared_ptr<core::SignerApi> signer, RES&& handler)
+    {
+        mBgService->Serve([bgService = mBgService,
+                           ws = std::weak_ptr<core::SignerApi>(signer),
+                           shared_handler=cex::shared_async_result<const xonly_pubkey&>(handler.forward())]() mutable {
+            try {
+                if (auto ps = ws.lock()) {
+                    ps->DistributeKeyShares([bgService, ws, shared_handler]() mutable {
+                        bgService->Serve([ws, shared_handler]() mutable {
+                            auto ps(ws.lock());
+                            if (ps) {
+                                try {
+                                    ps->AggregateKey();
+                                    shared_handler(ps->GetAggregatedPubKey());
+                                }
+                                catch (...) {
+                                    shared_handler.on_error();
+                                }
+                            }
+                            else {
+                                std::cerr << "Signer API destroyed" << std::endl;
+                            }
+                        });
+                    });
+                }
+                else {
+                    std::cerr << "Signer API destroyed" << std::endl;
+                }
+            }
+            catch (...) {
+                shared_handler.on_error();
+            }
+        });
+    }
 
-    void AddSigner(std::shared_ptr<core::SignerApi> signer)
-    { m_signers.emplace(&(signer->GetLocalPubKey()), move(signer)); }
+    template <std::derived_from<cex::async_result_base<void>> RES>
+    void CommitSigNonces(std::shared_ptr<core::SignerApi> ps, size_t count, RES&& handler)
+    {
+        mBgService->Serve([ws = std::weak_ptr<core::SignerApi>(ps), count, handler=handler.forward()]() mutable{
+            try {
+                auto ps(ws.lock());
+                if (ps) {
+                    ps->CommitNonces(count);
+                    handler();
+                }
+                else {
+                    std::cerr << "Signer API destroyed" << std::endl;
+                }
+            }
+            catch(...) {
+                handler.on_error();
+            }
+        });
+    }
 
-    void DisposeSigner(const xonly_pubkey& signer_key)
-    { m_signers.erase(&signer_key); }
+    template <std::derived_from<cex::async_result_base<void>> RES>
+    void ProcessSignatureCommitments(std::shared_ptr<core::SignerApi> ps, const scalar& message, const core::operation_id& opid, bool participate, RES&& handler)
+    {
+        auto ws = std::weak_ptr<core::SignerApi>(ps);
+        mBgService->Serve([=, bgService = mBgService, handler = handler.forward()]() mutable {
+            if (auto ps = ws.lock()) {
+                ps->InitSignature(opid, core::make_moving_callable([=, handler = handler.forward()]() mutable {
+                    bgService->Serve([=, handler = handler.forward()]() mutable {
+                        try {
+                            if (auto ps = ws.lock()) {
+                                clog << "[" << hex(ps->GetLocalPubKey()).substr(0,8) << "] do PreprocessSignature" << std::endl;
+                                ps->PreprocessSignature(message, opid);
+                                handler();
+                            }
+                        }
+                        catch (...) {
+                            handler.on_error();
+                        }
+                    });
+                }), [](){}, participate);
+            }
+        });
+    }
 
-    std::future<const xonly_pubkey&> NegotiateKey(const xonly_pubkey& signer_key);
-    std::future<void> PublishNonces(const xonly_pubkey& signer_key, size_t count);
-    std::future<signature> Sign(const xonly_pubkey &signer_key, const uint256 &message, core::operation_id opid);
+    template <std::derived_from<cex::async_result_base<signature>> RES>
+    void Sign(std::shared_ptr<core::SignerApi> ps, const core::operation_id& opid, RES&& handler)
+    {
+        auto ws = std::weak_ptr<core::SignerApi>(ps);
+        auto shared_handler = cex::shared_async_result<signature>(handler.forward());
+        mBgService->Serve([=, bgService = mBgService]() mutable {
+            if (auto ps = ws.lock()) {
+                try {
+                    ps->DistributeSigShares(opid, [=]() mutable {
+                        bgService->Serve([=, shared_handler = move(shared_handler)]() mutable {
+                            if (auto ps = ws.lock()) {
+                                try {
+                                    shared_handler(ps->AggregateSignature(opid));
+                                }
+                                catch (...) {
+                                    shared_handler.on_error();
+                                }
+                                ps->ClearSignatureCache(opid);
+                            }
+                        });
+                    });
+                }
+                catch (...) {
+                    shared_handler.on_error();
+                }
+            }
+        });
+    }
 
 };
 
diff --git a/test/Makefile.am b/test/Makefile.am
index 0c67948..5679cde 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -1,7 +1,8 @@
-SUBDIRS = core service p2p
+SUBDIRS = testlib core service p2p frost
 
 AM_CPPFLAGS = \
- -I$(top_srcdir)/test \
+ -DZMQ_BUILD_DRAFT_API=1 $(ZMQ_CPPFLAGS) \
+ -I$(top_srcdir)/test/testlib \
  -I$(top_srcdir)/contrib \
  -I$(top_srcdir)/contrib/cex \
  -I$(top_srcdir)/contrib/cli11 \
@@ -13,18 +14,19 @@ AM_CPPFLAGS = \
  -I$(top_srcdir)/src/p2p \
  -I$(top_srcdir)/src/tools \
  -I$(top_srcdir)/src/core \
- -I$(top_srcdir)/src/service \
- -I$(top_srcdir)/src/app
+ -I$(top_srcdir)/src/frost \
+ -I$(top_srcdir)/src/service
 
 
-AM_LDFLAGS=$(ZMQ_LDFLAGS) -L$(top_builddir)/node/src -L$(top_builddir)/node/src/crypto
+AM_LDFLAGS=$(ZMQ_LDFLAGS) -L$(top_builddir)/node/src
 
 L15_LIBS = \
-$(top_builddir)/src/app/libl15-app.la \
+$(top_builddir)/src/frost/libl15-frost.la \
 $(top_builddir)/src/service/libl15-srv.la \
 $(top_builddir)/src/core/libl15-core.la \
 $(top_builddir)/src/tools/libl15-tools.la \
 $(top_builddir)/src/common/libl15-common.la \
+$(top_builddir)/test/testlib/libl15-test.la \
 -lbitcoin_common -lbitcoin_util -lbitcoin_consensus \
 $(top_builddir)/node/src/crypto/libbitcoin_crypto_base.la \
 $(top_builddir)/node/src/crypto/libbitcoin_crypto_avx2.la \
@@ -36,7 +38,7 @@ $(BOOST_FILESYSTEM_LIB)
 
 bin_PROGRAMS = signer
 
-signer_SOURCES = zmq_service.cpp signer.cpp
+signer_SOURCES = signer.cpp
 signer_LDADD = $(L15_LIBS) $(ZMQ_LIBS)
 
 
diff --git a/test/core/Makefile.am b/test/core/Makefile.am
index 7c255c4..6aff261 100644
--- a/test/core/Makefile.am
+++ b/test/core/Makefile.am
@@ -1,6 +1,6 @@
 
 AM_CPPFLAGS = \
- -I$(top_srcdir)/test \
+ -I$(top_srcdir)/test/testlib \
  -I$(top_srcdir)/contrib \
  -I$(top_srcdir)/contrib/cex \
  -I$(top_srcdir)/contrib/cli11 \
@@ -12,14 +12,12 @@ AM_CPPFLAGS = \
  -I$(top_srcdir)/src/p2p \
  -I$(top_srcdir)/src/tools \
  -I$(top_srcdir)/src/core \
- -I$(top_srcdir)/src/service \
- -I$(top_srcdir)/src/app
+ -I$(top_srcdir)/src/service
 
 
 AM_LDFLAGS=-L$(top_builddir)/node/src -L$(top_builddir)/node/src/crypto
 
 L15_LIBS = \
-$(top_builddir)/src/app/libl15-app.la \
 $(top_builddir)/src/service/libl15-srv.la \
 $(top_builddir)/src/core/libl15-core.la \
 $(top_builddir)/src/tools/libl15-tools.la \
diff --git a/test/core/test_threshold_sign.cpp b/test/core/test_threshold_sign.cpp
index e17c6ad..2605056 100644
--- a/test/core/test_threshold_sign.cpp
+++ b/test/core/test_threshold_sign.cpp
@@ -44,14 +44,22 @@ TEST_CASE("2-of-3 local")
 
     // Create peers
 
-    general_handler key_hdl = []() {  };
-    sigop_handler new_sigop_hdl = [](operation_id) { };
-    sigop_handler sig_hdl = [](operation_id) { };
-    error_handler error_hdl = [](Error&& e) { FAIL(std::string(e.what()) + ": " + e.details()); };
+    const auto key_hdl = []() {  };
+    const sigop_handler new_sigop_hdl = [](operation_id) { };
+    const sigop_handler sig_hdl = [](operation_id) { };
+    const auto error_hdl = []() {
+        std::ostringstream s;
+        print_error(s);
+        FAIL(s.str());
+    };
+
+    SignerApi signer0(ChannelKeys(wallet.Secp256k1Context()), N, K);
+    SignerApi signer1(ChannelKeys(wallet.Secp256k1Context()), N, K);
+    SignerApi signer2(ChannelKeys(wallet.Secp256k1Context()), N, K);
 
-    SignerApi signer0(ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
-    SignerApi signer1(ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
-    SignerApi signer2(ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
+    signer0.SetErrorHandler(error_hdl);
+    signer1.SetErrorHandler(error_hdl);
+    signer2.SetErrorHandler(error_hdl);
 
     signer0.SetPublisher([&](frost_message_ptr&& m) {
         signer1.Accept(*m);
@@ -68,19 +76,22 @@ TEST_CASE("2-of-3 local")
 
     // Connect peers
 
-    signer0.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](auto m){signer1.Accept(*m);});
-    signer0.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](auto m){signer2.Accept(*m);});
-    signer1.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](auto m){signer0.Accept(*m);});
-    signer1.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](auto m){signer2.Accept(*m);});
-    signer2.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](auto m){signer0.Accept(*m);});
-    signer2.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](auto m){signer1.Accept(*m);});
+    signer0.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](const auto& pk, auto m){signer1.Accept(*m);});
+    signer0.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](const auto& pk, auto m){signer2.Accept(*m);});
+    signer1.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](const auto& pk, auto m){signer0.Accept(*m);});
+    signer1.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](const auto& pk, auto m){signer2.Accept(*m);});
+    signer2.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](const auto& pk, auto m){signer0.Accept(*m);});
+    signer2.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](const auto& pk, auto m){signer1.Accept(*m);});
 
 
     // Negotiate Aggregated Pubkey
+    CHECK_NOTHROW(signer0.CommitKeyShares(key_hdl));
+    CHECK_NOTHROW(signer1.CommitKeyShares(key_hdl));
+    CHECK_NOTHROW(signer2.CommitKeyShares(key_hdl));
 
-    CHECK_NOTHROW(signer0.DistributeKeyShares(key_hdl));
-    CHECK_NOTHROW(signer1.DistributeKeyShares(key_hdl));
-    CHECK_NOTHROW(signer2.DistributeKeyShares(key_hdl));
+    CHECK_NOTHROW(signer0.DistributeKeyShares(key_hdl)); // Check it accepts both lambda
+    CHECK_NOTHROW(signer1.DistributeKeyShares(make_moving_callable(key_hdl))); //and moving callable wrapper
+    CHECK_NOTHROW(signer2.DistributeKeyShares(make_moving_callable(key_hdl)));
 
     CHECK_NOTHROW(signer0.AggregateKey());
     CHECK_NOTHROW(signer1.AggregateKey());
@@ -128,22 +139,22 @@ TEST_CASE("2-of-3 local")
     bytevector message_data32 {'T','h','i','s',' ','i','s',' ','t','e','s','t',' ','d','a','t','a',' ','t','o',' ','b','e',' ','s','i','g','n','e','d','!','!'};
     REQUIRE(message_data32.size() == 32);
 
-    uint256 m(message_data32);
+    scalar m(message_data32);
 
-    CHECK_NOTHROW(signer0.InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0), false));
-    CHECK_NOTHROW(signer1.InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0)));
-    CHECK_NOTHROW(signer2.InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0)));
+    CHECK_NOTHROW(signer0.InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m), false));
+    CHECK_NOTHROW(signer1.InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m)));
+    CHECK_NOTHROW(signer2.InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m)));
 
-    CHECK_NOTHROW(signer0.PreprocessSignature(m, 0));
-    CHECK_NOTHROW(signer1.PreprocessSignature(m, 0));
-    CHECK_NOTHROW(signer2.PreprocessSignature(m, 0));
+    CHECK_NOTHROW(signer0.PreprocessSignature(m, m));
+    CHECK_NOTHROW(signer1.PreprocessSignature(m, m));
+    CHECK_NOTHROW(signer2.PreprocessSignature(m, m));
 
-    CHECK_NOTHROW(signer2.DistributeSigShares(0));
-    CHECK_NOTHROW(signer1.DistributeSigShares(0));
+    CHECK_NOTHROW(signer2.DistributeSigShares(m));
+    CHECK_NOTHROW(signer1.DistributeSigShares(m));
 
-    CHECK_NOTHROW(sig1 = signer1.AggregateSignature(0));
-    CHECK_NOTHROW(sig2 = signer2.AggregateSignature(0));
-    CHECK_NOTHROW(sig0 = signer0.AggregateSignature(0));
+    CHECK_NOTHROW(sig1 = signer1.AggregateSignature(m));
+    CHECK_NOTHROW(sig2 = signer2.AggregateSignature(m));
+    CHECK_NOTHROW(sig0 = signer0.AggregateSignature(m));
 
 
     REQUIRE_FALSE(IsZeroArray(sig1));
@@ -164,20 +175,22 @@ TEST_CASE("Try sign without pubnonce")
 
     // Create peers
 
-    general_handler key_hdl = []() {  };
-    sigop_handler new_sigop_hdl = [](operation_id) { };
-    sigop_handler sig_hdl = [](operation_id) { };
-    error_handler error_hdl = [](Error&& e) {
-        if (std::string("OutOfOrderMessageError") == e.what() || std::string(e.details()).starts_with("SignatureCommitment")) {
-        }
-        else {
-            FAIL(std::string(e.what()) + ": " + e.details());
-        }
+    const general_handler key_hdl = []() {  };
+    const sigop_handler new_sigop_hdl = [](operation_id) { };
+    const sigop_handler sig_hdl = [](operation_id) { };
+    const auto error_hdl = []() {
+        std::ostringstream s;
+        print_error(s);
+        FAIL(s.str());
     };
 
-    SignerApi signer0(ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
-    SignerApi signer1(ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
-    SignerApi signer2(ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
+    SignerApi signer0(ChannelKeys(wallet.Secp256k1Context()), N, K);
+    SignerApi signer1(ChannelKeys(wallet.Secp256k1Context()), N, K);
+    SignerApi signer2(ChannelKeys(wallet.Secp256k1Context()), N, K);
+
+    signer0.SetErrorHandler(error_hdl);
+    signer1.SetErrorHandler(error_hdl);
+    signer2.SetErrorHandler(error_hdl);
 
     signer0.SetPublisher([&](frost_message_ptr&& m) {
         signer1.Accept(*m);
@@ -194,19 +207,23 @@ TEST_CASE("Try sign without pubnonce")
 
     // Connect peers
 
-    signer0.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](auto m){signer1.Accept(*m);});
-    signer0.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](auto m){signer2.Accept(*m);});
-    signer1.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](auto m){signer0.Accept(*m);});
-    signer1.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](auto m){signer2.Accept(*m);});
-    signer2.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](auto m){signer0.Accept(*m);});
-    signer2.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](auto m){signer1.Accept(*m);});
+    signer0.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](const auto& pk, auto m){signer1.Accept(*m);});
+    signer0.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](const auto& pk, auto m){signer2.Accept(*m);});
+    signer1.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](const auto& pk, auto m){signer0.Accept(*m);});
+    signer1.AddPeer(xonly_pubkey(signer2.GetLocalPubKey()), [&signer2](const auto& pk, auto m){signer2.Accept(*m);});
+    signer2.AddPeer(xonly_pubkey(signer0.GetLocalPubKey()), [&signer0](const auto& pk, auto m){signer0.Accept(*m);});
+    signer2.AddPeer(xonly_pubkey(signer1.GetLocalPubKey()), [&signer1](const auto& pk, auto m){signer1.Accept(*m);});
 
 
     // Negotiate Aggregated Pubkey
 
-    CHECK_NOTHROW(signer0.DistributeKeyShares(key_hdl));
-    CHECK_NOTHROW(signer1.DistributeKeyShares(key_hdl));
-    CHECK_NOTHROW(signer2.DistributeKeyShares(key_hdl));
+    CHECK_NOTHROW(signer0.CommitKeyShares(key_hdl));
+    CHECK_NOTHROW(signer1.CommitKeyShares(key_hdl));
+    CHECK_NOTHROW(signer2.CommitKeyShares(key_hdl));
+
+    CHECK_NOTHROW(signer0.DistributeKeyShares(make_moving_callable(key_hdl)));
+    CHECK_NOTHROW(signer1.DistributeKeyShares(make_moving_callable(key_hdl)));
+    CHECK_NOTHROW(signer2.DistributeKeyShares(make_moving_callable(key_hdl)));
 
     CHECK_NOTHROW(signer0.AggregateKey());
     CHECK_NOTHROW(signer1.AggregateKey());
@@ -228,15 +245,15 @@ TEST_CASE("Try sign without pubnonce")
 
     CHECK(signer0.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys.size() == 3);
     CHECK(signer0.Peers().at(signer1.GetLocalPubKey()).ephemeral_pubkeys.size() == 3);
-    CHECK(signer0.Peers().at(signer2.GetLocalPubKey()).ephemeral_pubkeys.size() == 0);
+    CHECK(signer0.Peers().at(signer2.GetLocalPubKey()).ephemeral_pubkeys.empty());
 
     CHECK(signer1.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys.size() == 3);
     CHECK(signer1.Peers().at(signer1.GetLocalPubKey()).ephemeral_pubkeys.size() == 3);
-    CHECK(signer1.Peers().at(signer2.GetLocalPubKey()).ephemeral_pubkeys.size() == 0);
+    CHECK(signer1.Peers().at(signer2.GetLocalPubKey()).ephemeral_pubkeys.empty());
 
     CHECK(signer2.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys.size() == 3);
     CHECK(signer2.Peers().at(signer1.GetLocalPubKey()).ephemeral_pubkeys.size() == 3);
-    CHECK(signer2.Peers().at(signer2.GetLocalPubKey()).ephemeral_pubkeys.size() == 0);
+    CHECK(signer2.Peers().at(signer2.GetLocalPubKey()).ephemeral_pubkeys.empty());
 
     CHECK(signer0.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys == signer1.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys);
     CHECK(signer0.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys == signer2.Peers().at(signer0.GetLocalPubKey()).ephemeral_pubkeys);
@@ -254,15 +271,15 @@ TEST_CASE("Try sign without pubnonce")
     bytevector message_data32 {'T','h','i','s',' ','i','s',' ','t','e','s','t',' ','d','a','t','a',' ','t','o',' ','b','e',' ','s','i','g','n','e','d','!','!'};
     REQUIRE(message_data32.size() == 32);
 
-    uint256 m(message_data32);
+    scalar m(message_data32);
 
-    CHECK_NOTHROW(signer0.InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0), false));
-    CHECK_NOTHROW(signer1.InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0)));
-    CHECK_NOTHROW(signer2.InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0)));
+    CHECK_NOTHROW(signer0.InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m), false));
+    CHECK_NOTHROW(signer1.InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m)));
+    CHECK_THROWS_AS(signer2.InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m)), SigNonceNotAwailable);
 
-    REQUIRE_THROWS(signer0.PreprocessSignature(m, 0));
-    REQUIRE_THROWS(signer1.PreprocessSignature(m, 0));
-    REQUIRE_THROWS(signer2.PreprocessSignature(m, 0));
+    REQUIRE_THROWS(signer0.PreprocessSignature(m, m));
+    REQUIRE_THROWS(signer1.PreprocessSignature(m, m));
+    REQUIRE_THROWS(signer2.PreprocessSignature(m, m));
 
 }
 
@@ -276,23 +293,27 @@ TEST_CASE("500 of 1K local")
     std::vector<std::unique_ptr<SignerApi>> signers;
     signers.reserve(N);
 
-    general_handler key_hdl = []() { };
-    sigop_handler new_sigop_hdl = [](operation_id) { };
-    sigop_handler sig_hdl = [](operation_id) { };
-    error_handler error_hdl = [&](Error&& e) {
-        FAIL(std::string(e.what()) + ": " + e.details());
+    const general_handler key_hdl = []() { };
+    const sigop_handler new_sigop_hdl = [](operation_id) { };
+    const sigop_handler sig_hdl = [](operation_id) { };
+    const auto error_hdl = []() {
+        std::ostringstream s;
+        print_error(s);
+        FAIL(s.str());
     };
 
     std::ranges::transform(
-       std::ranges::common_view(std::views::iota(0) | std::views::take(N)),
+       std::views::iota(0) | std::views::take(N),
        cex::smartinserter(signers, signers.end()),
        [&](int i) {
-           return std::make_unique<SignerApi> (
-                   ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
+           auto s = std::make_unique<SignerApi> (
+                   ChannelKeys(wallet.Secp256k1Context()), N, K);
+           s->SetErrorHandler(error_hdl);
+           return s;
        }
     );
 
-    frost_link_handler publisher = [&signers](frost_message_ptr m) {
+    frost_publish_handler publisher = [&signers](frost_message_ptr m) {
         std::for_each(std::execution::par_unseq, signers.begin(), signers.end(), [&m](const auto& s){
             s->Accept(*m);
         });
@@ -307,7 +328,7 @@ TEST_CASE("500 of 1K local")
                 si->SetPublisher(publisher);
                 for (auto &sj: signers) {
                     if (si != sj) {
-                        si->AddPeer(xonly_pubkey(sj->GetLocalPubKey()), [&sj](auto m){sj->Accept(*m);});
+                        si->AddPeer(xonly_pubkey(sj->GetLocalPubKey()), [&sj](const auto& pk, auto m){sj->Accept(*m);});
                     }
                 }
                 return 0;
@@ -316,6 +337,22 @@ TEST_CASE("500 of 1K local")
         reg_measure.Report(std::clog);
     }
 
+    {
+        TimeMeasure distrib_measure("Commit Key shares");
+        size_t i = 0;
+        std::for_each(signers.begin(), signers.end(), [&](auto& s){
+            distrib_measure.Measure([&](){
+                ++i;
+                s->CommitKeyShares(key_hdl);
+                if(i % 100 == 99)
+                {
+                    std::clog << "Peer " << i << " commited key share" << std::endl;
+                }
+                return 0;
+            });
+        });
+        distrib_measure.Report(std::clog);
+    }
 
     {
         TimeMeasure distrib_measure("Exchange Key shares");
@@ -323,7 +360,7 @@ TEST_CASE("500 of 1K local")
         std::for_each(signers.begin(), signers.end(), [&](auto& s){
             distrib_measure.Measure([&](){
                 ++i;
-                s->DistributeKeyShares(key_hdl);
+                s->DistributeKeyShares(make_moving_callable(key_hdl));
                 if(i % 100 == 99)
                 {
                     std::clog << "Peer " << i << " key share completed" << std::endl;
@@ -366,7 +403,7 @@ TEST_CASE("500 of 1K local")
 
     bytevector message_data32 {'T','h','i','s',' ','i','s',' ','t','e','s','t',' ','d','a','t','a',' ','t','o',' ','b','e',' ','s','i','g','n','e','d','!','!'};
     REQUIRE(message_data32.size() == 32);
-    uint256 m(message_data32);
+    scalar m(message_data32);
 
     std::set<size_t> actual_signers;
 
@@ -382,7 +419,7 @@ TEST_CASE("500 of 1K local")
         TimeMeasure initsig_measure("Init signature");
         std::for_each(std::execution::par_unseq, actual_signers.begin(), actual_signers.end(), [&](auto &i) {
             initsig_measure.Measure([&]() {
-                signers[i]->InitSignature(0, make_callable_with_signer(new_sigop_hdl, 0), make_callable_with_signer(sig_hdl, 0));
+                signers[i]->InitSignature(m, make_moving_callable(new_sigop_hdl, m), make_moving_callable(sig_hdl, m));
                 return 0;
             });
         });
@@ -393,7 +430,7 @@ TEST_CASE("500 of 1K local")
         TimeMeasure preprocsig_measure("Preprocess signature");
         std::for_each(std::execution::par_unseq, actual_signers.begin(), actual_signers.end(), [&](auto &i) {
             preprocsig_measure.Measure([&]() {
-                signers[i]->PreprocessSignature(m, 0);
+                signers[i]->PreprocessSignature(m, m);
                 return 0;
             });
         });
@@ -404,7 +441,7 @@ TEST_CASE("500 of 1K local")
         TimeMeasure distribsig_measure("Distribute sig shares");
         std::for_each(std::execution::par_unseq, actual_signers.begin(), actual_signers.end(), [&](auto &i) {
             distribsig_measure.Measure([&]() {
-                signers[i]->DistributeSigShares(0);
+                signers[i]->DistributeSigShares(m);
                 return 0;
             });
         });
@@ -417,7 +454,7 @@ TEST_CASE("500 of 1K local")
         TimeMeasure aggsig_measure("Aggregate signature");
         std::for_each(std::execution::par_unseq, actual_signers.begin(), actual_signers.end(), [&](auto &i) {
             aggsig_measure.Measure([&]() {
-                signature sig = signers[i]->AggregateSignature(0);
+                signature sig = signers[i]->AggregateSignature(m);
                 {
                     [[maybe_unused]] const std::lock_guard<std::mutex> lock(sig_mutex);
                     final_sigs.emplace_back(std::move(sig));
diff --git a/test/frost/Makefile.am b/test/frost/Makefile.am
new file mode 100644
index 0000000..b9c002c
--- /dev/null
+++ b/test/frost/Makefile.am
@@ -0,0 +1,42 @@
+
+AM_CPPFLAGS = \
+ -DZMQ_BUILD_DRAFT_API=1 $(ZMQ_CPPFLAGS) \
+ -I$(top_srcdir)/test/testlib \
+ -I$(top_srcdir)/contrib \
+ -I$(top_srcdir)/contrib/cex \
+ -I$(top_srcdir)/contrib/cli11 \
+ -I$(top_srcdir)/contrib/secp256k1/include \
+ -I$(top_srcdir)/node/src \
+ -I$(top_srcdir)/node/src/univalue/include \
+ -I$(top_srcdir)/node/src/consensus \
+ -I$(top_srcdir)/src/common \
+ -I$(top_srcdir)/src/p2p \
+ -I$(top_srcdir)/src/tools \
+ -I$(top_srcdir)/src/core \
+ -I$(top_srcdir)/src/service \
+ -I$(top_srcdir)/src/frost
+
+AM_LDFLAGS=-L$(top_builddir)/node/src
+
+L15_LIBS = \
+$(top_builddir)/test/testlib/libl15-test.la \
+$(top_builddir)/src/frost/libl15-frost.la \
+$(top_builddir)/src/service/libl15-srv.la \
+$(top_builddir)/src/core/libl15-core.la \
+$(top_builddir)/src/tools/libl15-tools.la \
+$(top_builddir)/src/common/libl15-common.la \
+-lbitcoin_common -lbitcoin_util -lbitcoin_consensus \
+$(top_builddir)/node/src/crypto/libbitcoin_crypto_base.la \
+$(top_builddir)/node/src/crypto/libbitcoin_crypto_avx2.la \
+$(top_builddir)/node/src/crypto/libbitcoin_crypto_x86_shani.la \
+$(top_builddir)/node/src/crypto/libbitcoin_crypto_sse41.la \
+$(top_builddir)/contrib/secp256k1/libsecp256k1.la \
+$(top_builddir)/node/src/libunivalue.la \
+$(BOOST_FILESYSTEM_LIB)
+
+bin_PROGRAMS = test_frost_signer
+
+test_frost_signer_CPPFLAGS = $(AM_CPPFLAGS) $(ZMQ_CPPFLAGS)
+test_frost_signer_SOURCES = test_frost_signer.cpp
+test_frost_signer_LDADD = $(ZMQ_LDFLAGS) $(L15_LIBS) $(ZMQ_LIBS)
+
diff --git a/test/frost/test_frost_signer.cpp b/test/frost/test_frost_signer.cpp
new file mode 100644
index 0000000..c4d6fe3
--- /dev/null
+++ b/test/frost/test_frost_signer.cpp
@@ -0,0 +1,196 @@
+
+#include <memory>
+#include <future>
+#include <algorithm>
+#include <ranges>
+
+#include "smartinserter.hpp"
+
+
+#define CATCH_CONFIG_MAIN
+#include "catch/catch.hpp"
+
+#include "util/translation.h"
+#include "util/strencodings.h"
+#include "script/interpreter.h"
+#include "script/standard.h"
+
+#include "common.hpp"
+#include "config.hpp"
+
+#include "frost_signer.hpp"
+
+#include "wallet_api.hpp"
+
+#include "generic_service.hpp"
+#include "zmq_service.hpp"
+
+using namespace l15;
+using namespace l15::core;
+using namespace l15::p2p;
+using namespace l15::service;
+using namespace l15::signer_service;
+using namespace l15::frost;
+
+struct ThreeSignersTestWrapper {
+    WalletApi wallet;
+    ChannelKeys keypair0, keypair1, keypair2;
+    std::shared_ptr<service::GenericService> service;
+    std::shared_ptr<SignerService> signerService;
+    std::shared_ptr<ZmqService> peer0, peer1, peer2;
+    std::shared_ptr<FrostSigner> signer0, signer1, signer2;
+
+    ThreeSignersTestWrapper()
+        : keypair0(wallet.Secp256k1Context())
+        , keypair1(wallet.Secp256k1Context())
+        , keypair2(wallet.Secp256k1Context())
+        , service(std::make_shared<service::GenericService>(1))
+        , signerService(std::make_shared<SignerService>(service))
+        , peer0(std::make_shared<ZmqService>(wallet.Secp256k1Context(), service))
+        , peer1(std::make_shared<ZmqService>(wallet.Secp256k1Context(), service))
+        , peer2(std::make_shared<ZmqService>(wallet.Secp256k1Context(), service))
+        , signer0(make_shared<FrostSigner>(keypair0, std::vector<xonly_pubkey>{keypair0.GetLocalPubKey(), keypair1.GetLocalPubKey(), keypair2.GetLocalPubKey()}, signerService, peer0))
+        , signer1(make_shared<FrostSigner>(keypair1, std::vector<xonly_pubkey>{keypair0.GetLocalPubKey(), keypair1.GetLocalPubKey(), keypair2.GetLocalPubKey()}, signerService, peer1))
+        , signer2(make_shared<FrostSigner>(keypair2, std::vector<xonly_pubkey>{keypair0.GetLocalPubKey(), keypair1.GetLocalPubKey(), keypair2.GetLocalPubKey()}, signerService, peer2))
+    {
+        signer0->SetErrorHandler([this](){
+            std::ostringstream stream;
+            stream << "[" << hex(keypair0.GetLocalPubKey()).substr(0,8) << "] ";
+            print_error(stream);
+            FAIL(stream.str());
+        });
+
+        signer1->SetErrorHandler([this](){
+            std::ostringstream stream;
+            stream << "[" << hex(keypair1.GetLocalPubKey()).substr(0,8) << "] ";
+            print_error(stream);
+            FAIL(stream.str());
+        });
+
+        signer2->SetErrorHandler([this](){
+            std::ostringstream stream;
+            stream << "[" << hex(keypair2.GetLocalPubKey()).substr(0,8) << "] ";
+            print_error(stream);
+            FAIL(stream.str());
+        });
+
+        peer0->AddPeer(xonly_pubkey(keypair0.GetLocalPubKey()), "tcp://localhost:12000");
+        peer0->AddPeer(xonly_pubkey(keypair1.GetLocalPubKey()), "tcp://localhost:12001");
+        peer0->AddPeer(xonly_pubkey(keypair2.GetLocalPubKey()), "tcp://localhost:12002");
+
+        peer1->AddPeer(xonly_pubkey(keypair0.GetLocalPubKey()), "tcp://localhost:12000");
+        peer1->AddPeer(xonly_pubkey(keypair1.GetLocalPubKey()), "tcp://localhost:12001");
+        peer1->AddPeer(xonly_pubkey(keypair2.GetLocalPubKey()), "tcp://localhost:12002");
+
+        peer2->AddPeer(xonly_pubkey(keypair0.GetLocalPubKey()), "tcp://localhost:12000");
+        peer2->AddPeer(xonly_pubkey(keypair1.GetLocalPubKey()), "tcp://localhost:12001");
+        peer2->AddPeer(xonly_pubkey(keypair2.GetLocalPubKey()), "tcp://localhost:12002");
+    }
+};
+
+TEST_CASE_METHOD(ThreeSignersTestWrapper, "2-of-3 local")
+{
+    CHECK_NOTHROW(signer0->Start());
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    CHECK_NOTHROW(signer1->Start());
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    CHECK_NOTHROW(signer2->Start());
+
+    std::promise<xonly_pubkey> aggpk_promise0;
+    std::promise<xonly_pubkey> aggpk_promise1;
+    std::promise<xonly_pubkey> aggpk_promise2;
+
+    auto aggpk_res0 = aggpk_promise0.get_future();
+    auto aggpk_res1 = aggpk_promise1.get_future();
+    auto aggpk_res2 = aggpk_promise2.get_future();
+
+    CHECK_NOTHROW(signer0->AggregateKey(cex::make_async_result<const xonly_pubkey&>(
+            [](const xonly_pubkey& aggpk, std::promise<xonly_pubkey>&& p){p.set_value(aggpk);},
+            [](std::promise<xonly_pubkey>&& p){p.set_exception(std::current_exception());},
+            std::move(aggpk_promise0))));
+
+    CHECK_NOTHROW(signer1->AggregateKey(cex::make_async_result<const xonly_pubkey&>(
+            [](const xonly_pubkey& aggpk, std::promise<xonly_pubkey>&& p){p.set_value(aggpk);},
+            [](std::promise<xonly_pubkey>&& p){p.set_exception(std::current_exception());},
+            std::move(aggpk_promise1))));
+
+    CHECK_NOTHROW(signer2->AggregateKey(cex::make_async_result<const xonly_pubkey&>(
+            [](const xonly_pubkey& aggpk, std::promise<xonly_pubkey>&& p){p.set_value(aggpk);},
+            [](std::promise<xonly_pubkey>&& p){p.set_exception(std::current_exception());},
+            std::move(aggpk_promise2))));
+
+    xonly_pubkey aggpk0, aggpk1, aggpk2;
+
+    CHECK_NOTHROW(aggpk0 = aggpk_res0.get());
+    CHECK_NOTHROW(aggpk1 = aggpk_res1.get());
+    CHECK_NOTHROW(aggpk2 = aggpk_res2.get());
+
+    CHECK(aggpk0.get_vector() == aggpk1.get_vector());
+    CHECK(aggpk0.get_vector() == aggpk2.get_vector());
+
+    std::promise<void> nonce_promise0;
+    std::promise<void> nonce_promise1;
+    std::promise<void> nonce_promise2;
+
+    auto nonce_res0 = nonce_promise0.get_future();
+    auto nonce_res1 = nonce_promise1.get_future();
+    auto nonce_res2 = nonce_promise2.get_future();
+
+    signer0->CommitNonces(1, cex::make_async_result<void>(
+            [](std::promise<void>&& p){p.set_value();},
+            [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+            move(nonce_promise0)));
+
+    signer1->CommitNonces(1, cex::make_async_result<void>(
+            [](std::promise<void>&& p){p.set_value();},
+            [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+            move(nonce_promise1)));
+
+    signer2->CommitNonces(1, cex::make_async_result<void>(
+            [](std::promise<void>&& p){p.set_value();},
+            [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+            move(nonce_promise2)));
+
+
+    CHECK_NOTHROW(nonce_res0.wait());
+    CHECK_NOTHROW(nonce_res1.wait());
+    CHECK_NOTHROW(nonce_res2.wait());
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
+
+    bytevector message_data32 {'T','h','i','s',' ','i','s',' ','t','e','s','t',' ','d','a','t','a',' ','t','o',' ','b','e',' ','s','i','g','n','e','d','!','!'};
+    REQUIRE(message_data32.size() == 32);
+
+    scalar m(message_data32);
+
+    std::promise<signature> sig_promise0;
+    std::promise<signature> sig_promise1;
+//    std::promise<signature> sig_promise2;
+//
+    auto sig_res0 = sig_promise0.get_future();
+    auto sig_res1 = sig_promise1.get_future();
+//    auto sig_res2 = sig_promise2.get_future();
+//
+    signer0->Sign(m, m, cex::make_async_result<signature>(
+            [](signature sig, std::promise<signature>&& p){p.set_value(sig);},
+            [](std::promise<signature>&& p){p.set_exception(std::current_exception());},
+            move(sig_promise0)));
+    signer1->Sign(m, m, cex::make_async_result<signature>(
+            [](signature sig, std::promise<signature>&& p){p.set_value(sig);},
+            [](std::promise<signature>&& p){p.set_exception(std::current_exception());},
+            move(sig_promise1)));
+
+    signature sig0, sig1;
+    CHECK_NOTHROW(sig0 = sig_res0.get());
+    CHECK_NOTHROW(sig1 = sig_res1.get());
+
+    std::cout << HexStr(sig0) << std::endl;
+
+    REQUIRE_FALSE(IsZeroArray(sig1));
+    CHECK((sig0 == sig1));
+
+    CHECK_NOTHROW(signer0->Verify(m, sig0));
+
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
+}
diff --git a/test/p2p/Makefile.am b/test/p2p/Makefile.am
index 5a6a31a..504bb66 100644
--- a/test/p2p/Makefile.am
+++ b/test/p2p/Makefile.am
@@ -1,6 +1,5 @@
 
 AM_CPPFLAGS = \
- -I$(top_srcdir)/test \
  -I$(top_srcdir)/contrib \
  -I$(top_srcdir)/contrib/cex \
  -I$(top_srcdir)/contrib/cli11 \
@@ -12,14 +11,12 @@ AM_CPPFLAGS = \
  -I$(top_srcdir)/src/p2p \
  -I$(top_srcdir)/src/tools \
  -I$(top_srcdir)/src/core \
- -I$(top_srcdir)/src/service \
- -I$(top_srcdir)/src/app
+ -I$(top_srcdir)/src/service
 
 
 AM_LDFLAGS=-L$(top_builddir)/node/src -L$(top_builddir)/node/src/crypto
 
 L15_LIBS = \
-$(top_builddir)/src/app/libl15-app.la \
 $(top_builddir)/src/service/libl15-srv.la \
 $(top_builddir)/src/core/libl15-core.la \
 $(top_builddir)/src/tools/libl15-tools.la \
diff --git a/test/p2p/test_p2p_frost.cpp b/test/p2p/test_p2p_frost.cpp
index 517a039..70ba0b8 100644
--- a/test/p2p/test_p2p_frost.cpp
+++ b/test/p2p/test_p2p_frost.cpp
@@ -25,13 +25,14 @@ core::WalletApi w;
 TEST_CASE("FrostMessage")
 {
     l15::xonly_pubkey pk = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
-    FrostMessage m(FROST_MESSAGE::SIGNATURE_SHARE, move(pk));
+    FrostMessage m(2u, FROST_MESSAGE::KEEP_ALIVE, move(pk));
 
     cex::stream<std::deque<uint8_t>> s;
 
-    uint8_t etalon[] = {0, 1, 0, 4, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
+    uint8_t etalon[] = {0, 1, 0, 2, 0, 0, 0, 0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
 
-    CHECK_NOTHROW(m.Serialize(s));
+    REQUIRE_NOTHROW(m.Serialize(s));
+    //m.Serialize(s);
 
     std::clog << l15::hex(s) << std::endl;
 
@@ -40,11 +41,13 @@ TEST_CASE("FrostMessage")
         CHECK((elem == etalon[i++]));
     }
 
-    auto res = Unserialize(w.Secp256k1Context(), s);
+    frost_message_ptr res;
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     FrostMessage *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<FrostMessage *>(res.get())));
 
+    CHECK((m.sequence == m1->sequence));
     CHECK((m.protocol_id == m1->protocol_id));
     CHECK((m.id == m1->id));
     CHECK((m.pubkey == m1->pubkey));
@@ -76,19 +79,21 @@ TEST_CASE("NonceCommitments")
 
     l15::xonly_pubkey pk = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
 
-    NonceCommitments m(move(pk));
+    NonceCommitments m(3u, move(pk));
     m.nonce_commitments.emplace_back(move(pubnonce));
 
     cex::stream<std::deque<uint8_t>> s;
-    CHECK_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
 
     std::clog << l15::hex(s) << std::endl;
 
-    auto res = Unserialize(w.Secp256k1Context(), s);
+    frost_message_ptr res;
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     NonceCommitments *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<NonceCommitments *>(res.get())));
 
+    CHECK((m.sequence == m1->sequence));
     CHECK((m.protocol_id == m1->protocol_id));
     CHECK((m.id == m1->id));
     CHECK((m.pubkey == m1->pubkey));
@@ -97,43 +102,53 @@ TEST_CASE("NonceCommitments")
 
 TEST_CASE("KeyShareCommitment")
 {
-    seckey sk1, sk2;
+    seckey sk1, sk2, sk3;
     do {
         GetStrongRandBytes(sk1);
     } while (!secp256k1_ec_seckey_verify(w.Secp256k1Context(), sk1.data()));
     do {
         GetStrongRandBytes(sk2);
     } while (!secp256k1_ec_seckey_verify(w.Secp256k1Context(), sk2.data()));
+    do {
+        GetStrongRandBytes(sk3);
+    } while (!secp256k1_ec_seckey_verify(w.Secp256k1Context(), sk3.data()));
 
-    secp256k1_pubkey pk1, pk2;
+    secp256k1_pubkey pk1, pk2, pk3;
     if (!secp256k1_ec_pubkey_create(w.Secp256k1Context(), &pk1, sk1.data())) {
         throw WrongKeyError();
     }
-    if (!secp256k1_ec_pubkey_create(w.Secp256k1Context(), &pk2, sk1.data())) {
+    if (!secp256k1_ec_pubkey_create(w.Secp256k1Context(), &pk2, sk2.data())) {
+        throw WrongKeyError();
+    }
+    if (!secp256k1_ec_pubkey_create(w.Secp256k1Context(), &pk3, sk3.data())) {
         throw WrongKeyError();
     }
 
     l15::xonly_pubkey pk = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
 
-    KeyShareCommitment m(move(pk));
+    KeyShareCommitment m(4u, move(pk));
     m.share_commitment.emplace_back(move(pk1));
     m.share_commitment.emplace_back(move(pk2));
+    m.share_commitment.emplace_back(move(pk3));
 
     cex::stream<std::deque<uint8_t>> s;
-    CHECK_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
 
     std::clog << l15::hex(s) << std::endl;
 
-    auto res = Unserialize(w.Secp256k1Context(), s);
+    frost_message_ptr res;
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     KeyShareCommitment *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<KeyShareCommitment *>(res.get())));
 
+    CHECK((m.sequence == m1->sequence));
     CHECK((m.protocol_id == m1->protocol_id));
     CHECK((m.id == m1->id));
     CHECK((m.pubkey == m1->pubkey));
     CHECK((memcmp(m.share_commitment[0].data, m1->share_commitment[0].data, sizeof(secp256k1_pubkey::data))==0));
     CHECK((memcmp(m.share_commitment[1].data, m1->share_commitment[1].data, sizeof(secp256k1_pubkey::data))==0));
+    CHECK((memcmp(m.share_commitment[2].data, m1->share_commitment[2].data, sizeof(secp256k1_pubkey::data))==0));
 }
 
 TEST_CASE("KeyShareCommitment15")
@@ -143,7 +158,7 @@ TEST_CASE("KeyShareCommitment15")
     std::vector<seckey> sk;
     sk.resize(K);
 
-    std::for_each(sk.begin(), sk.end(), [](auto& k) {
+    std::for_each(sk.begin(), sk.end(), [&](auto& k) {
         do {
             GetStrongRandBytes(k);
         } while (!secp256k1_ec_seckey_verify(w.Secp256k1Context(), k.data()));
@@ -151,7 +166,7 @@ TEST_CASE("KeyShareCommitment15")
 
     std::vector<secp256k1_pubkey> pk;
     pk.resize(K);
-    std::transform(sk.begin(), sk.end(), pk.begin(), [](auto& k)
+    std::transform(sk.begin(), sk.end(), pk.begin(), [&](auto& k)
     {
         secp256k1_pubkey p;
         if (!secp256k1_ec_pubkey_create(w.Secp256k1Context(), &p, k.data())) {
@@ -170,7 +185,7 @@ TEST_CASE("KeyShareCommitment15")
 
     l15::xonly_pubkey pk0 = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
 
-    KeyShareCommitment m(move(pk0));
+    KeyShareCommitment m(5u, move(pk0));
     m.share_commitment = move(pk);
 
     std::clog << std::endl;
@@ -187,16 +202,17 @@ TEST_CASE("KeyShareCommitment15")
     std::clog << std::endl;
 
     cex::stream<std::deque<uint8_t>> s;
-    CHECK_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
 
     std::clog << l15::hex(s) << std::endl;
 
     std::shared_ptr<FrostMessage> res;
-    CHECK_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     KeyShareCommitment *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<KeyShareCommitment *>(res.get())));
 
+    CHECK((m.sequence == m1->sequence));
     CHECK((m.protocol_id == m1->protocol_id));
     CHECK((m.id == m1->id));
     CHECK((m.pubkey == m1->pubkey));
@@ -235,17 +251,18 @@ TEST_CASE("KeyShareCommitment15")
 TEST_CASE("KeyShare")
 {
     l15::xonly_pubkey pk = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
-    KeyShare m(move(pk));
+    KeyShare m(6u, move(pk));
     std::transform(m.pubkey.crbegin(), m.pubkey.crend(), m.share.data, [](const auto v){return v;});
 
     cex::stream<std::deque<uint8_t>> s;
 
-    uint8_t etalon[] = {0, 1, 0, 2, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
-                                    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
-                                    0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
-                                    0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
+    uint8_t etalon[] = {0, 1, 0, 6, 0, 0, 0, 3,
+                        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
+                        0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
 
-    CHECK_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
 
     std::clog << l15::hex(s) << std::endl;
 
@@ -254,11 +271,13 @@ TEST_CASE("KeyShare")
         CHECK((elem == etalon[i++]));
     }
 
-    auto res = Unserialize(w.Secp256k1Context(), s);
+    frost_message_ptr res;
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     KeyShare *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<KeyShare *>(res.get())));
 
+    CHECK(m.sequence == m1->sequence);
     CHECK(m.protocol_id == m1->protocol_id);
     CHECK(m.id == m1->id);
     CHECK((m.pubkey == m1->pubkey));
@@ -267,50 +286,62 @@ TEST_CASE("KeyShare")
 
 TEST_CASE("SignatureCommitment")
 {
+    scalar opid(ParseHex("00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF"));
     l15::xonly_pubkey pk = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
-    SignatureCommitment m(move(pk), 0xabcdef);
+    SignatureCommitment m(7u, move(pk), opid, opid);
 
     cex::stream<std::deque<uint8_t>> s;
 
-    uint8_t etalon[] = {0, 1, 0, 3, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+    uint8_t etalon[] = {0, 1, 0, 7, 0, 0, 0, 4,
+                        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
                         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
-                        0x00, 0xab, 0xcd, 0xef};
+                        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        };
 
-    CHECK_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
 
-    std::clog << l15::hex(s) << std::endl;
+    std::clog << "SignatureCommitment:\n" << l15::hex(s) << std::endl;
 
     size_t i = 0;
     for (auto elem: s) {
         CHECK((elem == etalon[i++]));
     }
 
-    auto res = Unserialize(w.Secp256k1Context(), s);
+    frost_message_ptr res;
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     SignatureCommitment *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<SignatureCommitment *>(res.get())));
 
+    CHECK(m.sequence == m1->sequence);
     CHECK(m.protocol_id == m1->protocol_id);
     CHECK(m.id == m1->id);
     CHECK((m.pubkey == m1->pubkey));
-    CHECK(m.operation_id == m1->operation_id);
+    CHECK((m.operation_id == m1->operation_id));
+    CHECK((m.nonce_id == m1->nonce_id));
 }
 
 TEST_CASE("SignatureShare")
 {
+    scalar opid(ParseHex("00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF"));
     l15::xonly_pubkey pk = ParseHex("11223344556677889900AABBCCDDEEFF11223344556677889900AABBCCDDEEFF");
-    SignatureShare m(move(pk), 0xabcdef);
+    SignatureShare m(8u, move(pk), opid);
     std::transform(m.pubkey.crbegin(), m.pubkey.crend(), m.share.begin(), [](const auto v){return v;});
 
     cex::stream<std::deque<uint8_t>> s;
 
-    uint8_t etalon[] = {0, 1, 0, 4, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+    uint8_t etalon[] = {0, 1, 0, 8, 0, 0, 0, 5,
+                        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
                         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
-                        0x00, 0xab, 0xcd, 0xef,
+                        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+                        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
                         0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
                         0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x00, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
 
-    CHECK_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
+    REQUIRE_NOTHROW(m.Serialize(w.Secp256k1Context(), s));
 
     std::clog << l15::hex(s) << std::endl;
 
@@ -319,14 +350,16 @@ TEST_CASE("SignatureShare")
         CHECK((elem == etalon[i++]));
     }
 
-    auto res = Unserialize(w.Secp256k1Context(), s);
+    frost_message_ptr res;
+    REQUIRE_NOTHROW(res = Unserialize(w.Secp256k1Context(), s));
 
     SignatureShare *m1 = nullptr;
     REQUIRE((m1 = dynamic_cast<SignatureShare *>(res.get())));
 
+    CHECK(m.sequence == m1->sequence);
     CHECK(m.protocol_id == m1->protocol_id);
     CHECK(m.id == m1->id);
     CHECK((m.pubkey == m1->pubkey));
-    CHECK(m.operation_id == m1->operation_id);
+    CHECK((m.operation_id == m1->operation_id));
     CHECK((m.share == m1->share));
 }
diff --git a/test/service/Makefile.am b/test/service/Makefile.am
index 9db9ac5..c07ea6b 100644
--- a/test/service/Makefile.am
+++ b/test/service/Makefile.am
@@ -1,6 +1,6 @@
 
 AM_CPPFLAGS = \
- -I$(top_srcdir)/test \
+ -DZMQ_BUILD_DRAFT_API=1 $(ZMQ_CPPFLAGS) \
  -I$(top_srcdir)/contrib \
  -I$(top_srcdir)/contrib/cex \
  -I$(top_srcdir)/contrib/cli11 \
@@ -12,14 +12,12 @@ AM_CPPFLAGS = \
  -I$(top_srcdir)/src/p2p \
  -I$(top_srcdir)/src/tools \
  -I$(top_srcdir)/src/core \
- -I$(top_srcdir)/src/service \
- -I$(top_srcdir)/src/app
+ -I$(top_srcdir)/src/service
 
 
-AM_LDFLAGS=-L$(top_builddir)/node/src -L$(top_builddir)/node/src/crypto
+AM_LDFLAGS=-L$(top_builddir)/node/src
 
 L15_LIBS = \
-$(top_builddir)/src/app/libl15-app.la \
 $(top_builddir)/src/service/libl15-srv.la \
 $(top_builddir)/src/core/libl15-core.la \
 $(top_builddir)/src/tools/libl15-tools.la \
diff --git a/test/service/test_signer_service.cpp b/test/service/test_signer_service.cpp
index f684205..4a321f0 100644
--- a/test/service/test_signer_service.cpp
+++ b/test/service/test_signer_service.cpp
@@ -3,6 +3,8 @@
 #include <future>
 #include <algorithm>
 
+#include "smartinserter.hpp"
+
 
 #define CATCH_CONFIG_MAIN
 #include "catch/catch.hpp"
@@ -30,19 +32,26 @@ using namespace l15::signer_service;
 
 TEST_CASE("2-of-3 local")
 {
+    WalletApi wallet;
+
+    std::shared_ptr<SignerApi> signer0 = std::make_shared<SignerApi>(ChannelKeys(wallet.Secp256k1Context()), 3, 2);
+    std::shared_ptr<SignerApi> signer1 = std::make_shared<SignerApi>(ChannelKeys(wallet.Secp256k1Context()), 3, 2);
+    std::shared_ptr<SignerApi> signer2 = std::make_shared<SignerApi>(ChannelKeys(wallet.Secp256k1Context()), 3, 2);
+
     auto service = std::make_shared<service::GenericService>(3);
     signer_service::SignerService signerService(service);
-    WalletApi wallet;
 
     // Create peers
 
-    error_handler error_hdl = [](Error&& e) {
-        FAIL(std::string(e.what()) + ": " + e.details());
+    auto error_hdl = []() {
+        std::ostringstream s;
+        print_error(s);
+        FAIL(s.str());
     };
 
-    std::shared_ptr<SignerApi> signer0 = std::make_shared<SignerApi>(ChannelKeys(wallet.Secp256k1Context()), 3, 2, error_hdl);
-    std::shared_ptr<SignerApi> signer1 = std::make_shared<SignerApi>(ChannelKeys(wallet.Secp256k1Context()), 3, 2, error_hdl);
-    std::shared_ptr<SignerApi> signer2 = std::make_shared<SignerApi>(ChannelKeys(wallet.Secp256k1Context()), 3, 2, error_hdl);
+    signer0->SetErrorHandler(error_hdl);
+    signer1->SetErrorHandler(error_hdl);
+    signer2->SetErrorHandler(error_hdl);
 
     signer0->SetPublisher([&](frost_message_ptr m) {
         service->Serve([=]() {
@@ -65,29 +74,87 @@ TEST_CASE("2-of-3 local")
 
     // Connect peers
 
-    signer0->AddPeer(xonly_pubkey(signer1->GetLocalPubKey()), [&](frost_message_ptr m){ service->Serve([=]() { signer1->Accept(*m); }); });
-    signer0->AddPeer(xonly_pubkey(signer2->GetLocalPubKey()), [&](frost_message_ptr m){ service->Serve([=]() { signer2->Accept(*m); }); });
-    signer1->AddPeer(xonly_pubkey(signer0->GetLocalPubKey()), [&](frost_message_ptr m){ service->Serve([=]() { signer0->Accept(*m); }); });
-    signer1->AddPeer(xonly_pubkey(signer2->GetLocalPubKey()), [&](frost_message_ptr m){ service->Serve([=]() { signer2->Accept(*m); }); });
-    signer2->AddPeer(xonly_pubkey(signer0->GetLocalPubKey()), [&](frost_message_ptr m){ service->Serve([=]() { signer0->Accept(*m); }); });
-    signer2->AddPeer(xonly_pubkey(signer1->GetLocalPubKey()), [&](frost_message_ptr m){ service->Serve([=]() { signer1->Accept(*m); }); });
+    signer0->AddPeer(xonly_pubkey(signer1->GetLocalPubKey()), [&](const auto& pk, frost_message_ptr m){ signerService.Accept(signer1, m); });
+    signer0->AddPeer(xonly_pubkey(signer2->GetLocalPubKey()), [&](const auto& pk, frost_message_ptr m){ signerService.Accept(signer2, m); });
+    signer1->AddPeer(xonly_pubkey(signer0->GetLocalPubKey()), [&](const auto& pk, frost_message_ptr m){ signerService.Accept(signer0, m); });
+    signer1->AddPeer(xonly_pubkey(signer2->GetLocalPubKey()), [&](const auto& pk, frost_message_ptr m){ signerService.Accept(signer2, m); });
+    signer2->AddPeer(xonly_pubkey(signer0->GetLocalPubKey()), [&](const auto& pk, frost_message_ptr m){ signerService.Accept(signer0, m); });
+    signer2->AddPeer(xonly_pubkey(signer1->GetLocalPubKey()), [&](const auto& pk, frost_message_ptr m){ signerService.Accept(signer1, m); });
+
+    auto commkey_promise0 = std::promise<void>();
+    auto commkey_promise1 = std::promise<void>();
+    auto commkey_promise2 = std::promise<void>();
+
+    auto commkey_res0 = commkey_promise0.get_future();
+    auto commkey_res1 = commkey_promise1.get_future();
+    auto commkey_res2 = commkey_promise2.get_future();
+
+    signerService.ProcessKeyShareCommitment(signer0,
+            cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();},
+                                         [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                         move(commkey_promise0)));
+
+    signerService.ProcessKeyShareCommitment(signer1,
+            cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();},
+                                         [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                         move(commkey_promise1)));
+
+    signerService.ProcessKeyShareCommitment(signer2,
+            cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();},
+                                         [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                         move(commkey_promise2)));
+
+    CHECK_NOTHROW(commkey_res0.wait());
+    CHECK_NOTHROW(commkey_res1.wait());
+    CHECK_NOTHROW(commkey_res2.wait());
+
+    auto aggkey_promise0 = std::promise<xonly_pubkey>();
+    auto aggkey_promise1 = std::promise<xonly_pubkey>();
+    auto aggkey_promise2 = std::promise<xonly_pubkey>();
+
+    auto aggkey_res0 = aggkey_promise0.get_future();
+    auto aggkey_res1 = aggkey_promise1.get_future();
+    auto aggkey_res2 = aggkey_promise2.get_future();
 
-    signerService.AddSigner(signer0);
-    signerService.AddSigner(signer1);
-    signerService.AddSigner(signer2);
+    signerService.NegotiateKey(signer0,
+            cex::make_async_result<const xonly_pubkey&>([](const xonly_pubkey& pk, std::promise<xonly_pubkey>&& p) { p.set_value(pk); },
+                                                 [](std::promise<xonly_pubkey>&& p){p.set_exception(std::current_exception());},
+                                                 move(aggkey_promise0)));
+
+    signerService.NegotiateKey(signer1,
+            cex::make_async_result<const xonly_pubkey&>([](const xonly_pubkey& pk, std::promise<xonly_pubkey>&& p){p.set_value(pk);},
+                                                 [](std::promise<xonly_pubkey>&& p){p.set_exception(std::current_exception());},
+                                                 move(aggkey_promise1)));
+
+    signerService.NegotiateKey(signer2,
+            cex::make_async_result<const xonly_pubkey&>([](const xonly_pubkey& pk, std::promise<xonly_pubkey>&& p){p.set_value(pk);},
+                                                 [](std::promise<xonly_pubkey>&& p){p.set_exception(std::current_exception());},
+                                                 move(aggkey_promise2)));
 
-    auto aggkey_res0 = signerService.NegotiateKey(signer0->GetLocalPubKey());
-    auto aggkey_res1 = signerService.NegotiateKey(signer1->GetLocalPubKey());
-    auto aggkey_res2 = signerService.NegotiateKey(signer2->GetLocalPubKey());
 
     xonly_pubkey shared_pk0, shared_pk1, shared_pk2;
     CHECK_NOTHROW(shared_pk0 = aggkey_res0.get());
     CHECK_NOTHROW(shared_pk1 = aggkey_res1.get());
     CHECK_NOTHROW(shared_pk2 = aggkey_res2.get());
 
-    auto nonce_res0 = signerService.PublishNonces(signer0->GetLocalPubKey(), 2);
-    auto nonce_res1 = signerService.PublishNonces(signer1->GetLocalPubKey(), 2);
-    auto nonce_res2 = signerService.PublishNonces(signer2->GetLocalPubKey(), 2);
+    REQUIRE_FALSE(IsZeroArray(shared_pk0));
+    CHECK((shared_pk0 == shared_pk1));
+    CHECK((shared_pk0 == shared_pk2));
+
+    auto nonce_promise0 = std::promise<void>();
+    auto nonce_promise1 = std::promise<void>();
+    auto nonce_promise2 = std::promise<void>();
+
+    auto nonce_res0 = nonce_promise0.get_future();
+    auto nonce_res1 = nonce_promise1.get_future();
+    auto nonce_res2 = nonce_promise2.get_future();
+
+    signerService.CommitSigNonces(signer0, 2, cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();}, [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                  move(nonce_promise0)));
+    signerService.CommitSigNonces(signer1, 2, cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();}, [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                  move(nonce_promise1)));
+    signerService.CommitSigNonces(signer2, 2, cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();}, [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                  move(nonce_promise2)));
 
     CHECK_NOTHROW(nonce_res0.wait());
     CHECK_NOTHROW(nonce_res1.wait());
@@ -96,19 +163,132 @@ TEST_CASE("2-of-3 local")
     bytevector message_data32 {'T','h','i','s',' ','i','s',' ','t','e','s','t',' ','d','a','t','a',' ','t','o',' ','b','e',' ','s','i','g','n','e','d','!','!'};
     REQUIRE(message_data32.size() == 32);
 
-    uint256 m(message_data32);
+    scalar m(message_data32);
+
+    auto signonce_promise0 = std::promise<void>();
+    auto signonce_promise1 = std::promise<void>();
+    auto signonce_promise2 = std::promise<void>();
 
-    auto sign_res0 = signerService.Sign(signer0->GetLocalPubKey(), m, 0);
-    auto sign_res1 = signerService.Sign(signer1->GetLocalPubKey(), m, 0);
+    auto signonce_res0 = signonce_promise0.get_future();
+    auto signonce_res1 = signonce_promise1.get_future();
+    auto signonce_res2 = signonce_promise2.get_future();
 
-    signature sig0, sig1;
+    signerService.ProcessSignatureCommitments(signer0, m, m, true,  cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();}, [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                                                                                 move(signonce_promise0)));
+    signerService.ProcessSignatureCommitments(signer1, m, m, false, cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();}, [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                                                                                 move(signonce_promise1)));
+    signerService.ProcessSignatureCommitments(signer2, m, m, true,  cex::make_async_result<void>([](std::promise<void>&& p){p.set_value();}, [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                                                                                                 move(signonce_promise2)));
+
+    CHECK_NOTHROW(signonce_res0.wait());
+    CHECK_NOTHROW(signonce_res1.wait());
+    CHECK_NOTHROW(signonce_res2.wait());
+
+    std::promise<signature> sig_promise0;
+    std::promise<signature> sig_promise2;
+
+    auto sign_res0 = sig_promise0.get_future();
+    auto sign_res2 = sig_promise2.get_future();
+
+    signerService.Sign(signer0, m, cex::make_async_result<signature>([](signature sig, std::promise<signature>&& p) { p.set_value(sig); },
+                                                                               [](std::promise<signature>&& p){p.set_exception(std::current_exception());},
+                                                                               move(sig_promise0)));
+    signerService.Sign(signer2, m, cex::make_async_result<signature>([](signature sig, std::promise<signature>&& p) { p.set_value(sig); },
+                                                                     [](std::promise<signature>&& p){p.set_exception(std::current_exception());},
+                                                                     move(sig_promise2)));
+
+    signature sig0, sig2;
     CHECK_NOTHROW(sig0 = sign_res0.get());
-    CHECK_NOTHROW(sig1 = sign_res1.get());
+    CHECK_NOTHROW(sig2 = sign_res2.get());
 
     std::cout << HexStr(sig0) << std::endl;
 
-    REQUIRE_FALSE(IsZeroArray(sig1));
-    CHECK((sig0 == sig1));
+    REQUIRE_FALSE(IsZeroArray(sig0));
+    CHECK((sig0 == sig2));
 
     CHECK_NOTHROW(signer0->Verify(m, sig0));
-}
\ No newline at end of file
+}
+
+//TEST_CASE("15-of-30")
+//{
+//    const size_t N = 30;
+//    const size_t K = 15;
+//
+//    auto service = std::make_shared<service::GenericService>(10);
+//    signer_service::SignerService signerService(service);
+//    WalletApi wallet;
+//
+//    // Create peers
+//
+//    error_handler error_hdl = [](Error&& e) {
+//        FAIL(std::string(e.what()) + ": " + e.details());
+//    };
+//
+//    std::vector<std::shared_ptr<SignerApi>> signers;
+//    signers.reserve(N);
+//
+//    std::ranges::transform(
+//            std::views::iota(0) | std::views::take(N),
+//            cex::smartinserter(signers, signers.end()),
+//            [&](int i) {
+//                return std::make_shared<SignerApi> (
+//                        ChannelKeys(wallet.Secp256k1Context()), N, K, error_hdl);
+//            });
+//
+//
+//    std::for_each(signers.begin(), signers.end(), [=, &signerService, &signers](auto& si) {
+//        si->SetPublisher([=, &signerService, &signers](frost_message_ptr m) {
+//            std::for_each(signers.begin(), signers.end(), [=, &signerService](auto &sj) {
+//                if (si != sj)
+//                    service->Serve([=, &signerService](){ signerService.Accept(sj->GetLocalPubKey(), m);});
+//            });
+//        });
+//
+//        std::for_each(signers.begin(), signers.end(), [=, &signerService](auto& sj){
+//            if (si != sj)
+//                si->AddPeer(xonly_pubkey(sj->GetLocalPubKey()), [=, &signerService](frost_message_ptr m){
+//                    service->Serve([=, &signerService](){ signerService.Accept(sj->GetLocalPubKey(), m);});
+//                });
+//        });
+//
+//        signerService.AddSigner(si);
+//    });
+//
+//
+//    std::vector<std::future<const xonly_pubkey&>> key_res;
+//    std::for_each(signers.begin(), signers.end(), [&signerService, &key_res](auto& si) {
+//        key_res.emplace_back(signerService.NegotiateKey(si->GetLocalPubKey()));
+//    });
+//    CHECK_NOTHROW(
+//            std::for_each(key_res.begin(), key_res.end(), [](auto& key) {
+//                key.wait();
+//            }));
+//
+//
+//    std::vector<std::future<void>> nonce_res;
+//    std::for_each(signers.begin(), signers.end(), [&signerService, &nonce_res](auto& si) {
+//        nonce_res.emplace_back(signerService.PublishNonces(si->GetLocalPubKey(), 1));
+//    });
+//    CHECK_NOTHROW(
+//            std::for_each(nonce_res.begin(), nonce_res.end(), [](auto& nonce) {
+//                nonce.wait();
+//            }));
+//
+//
+//    std::string text = "text";
+//    uint256 message;
+//    CSHA256().Write((unsigned char *) text.data(), text.length()).Finalize(message.data());
+//
+//
+//    std::vector<std::future<signature>> sig_res;
+//    std::for_each(signers.begin(), signers.end(), [message, &signerService, &sig_res, &signers](auto& si) {
+//        if ((&si - &signers.front()) % 2 == 0)
+//            sig_res.emplace_back(signerService.Sign(si->GetLocalPubKey(), message, 0));
+//    });
+//    CHECK_NOTHROW(
+//            std::for_each(sig_res.begin(), sig_res.end(), [message, &signers](auto& sig) {
+//                auto s = sig.get();
+//                signers.front()->Verify(message, s);
+//            }));
+//
+//}
\ No newline at end of file
diff --git a/test/signer.cpp b/test/signer.cpp
index db1b97d..d7edb69 100644
--- a/test/signer.cpp
+++ b/test/signer.cpp
@@ -3,16 +3,20 @@
 #include <vector>
 #include <sstream>
 #include <deque>
+#include <memory>
+#include <ranges>
 
 #include <unistd.h>
 
 #include <boost/container/flat_map.hpp>
 
+#include "async_result.hpp"
+
 #include "CLI11.hpp"
 #include "common.hpp"
 #include "channel_keys.hpp"
 #include "wallet_api.hpp"
-#include "signer_api.hpp"
+#include "frost_signer.hpp"
 #include "signer_service.hpp"
 #include "util/strencodings.h"
 #include "generic_service.hpp"
@@ -32,7 +36,7 @@ const char * const DOSIGN = "--sign,-s";
 
 
 
-class Signer
+class TestSigner
 {
     CLI::App mApp;
 
@@ -44,11 +48,11 @@ class Signer
     std::string mListenAddress;
     std::shared_ptr<l15::service::GenericService> mTaskService;
     WalletApi mWallet;
-    boost::container::flat_map<xonly_pubkey, std::string, l15::less<xonly_pubkey>> m_peers;
+    boost::container::flat_map<xonly_pubkey, std::string> m_peers;
     std::string mInput;
 
-    Signer();
-    ~Signer() = default;
+    TestSigner();
+    ~TestSigner() = default;
 
     void ProcessConfig(int argc, const char *const argv[])
     {
@@ -73,7 +77,7 @@ class Signer
 };
 
 
-Signer::Signer()
+TestSigner::TestSigner()
 : mApp("Tool to generate threshold signature", "signer")
 , mVerbose(0), mDryRun(false), mDoSign(false)
 , mTaskService(std::make_shared<service::GenericService>(10))
@@ -118,15 +122,14 @@ Signer::Signer()
                     "Input message to sign")->configurable(true);
 }
 
-error_handler error_hdl = [](Error&& e) { std::cerr << (std::ostringstream() << "Fatal error: " << e.what() << ": " << e.details()).str() << std::endl; exit(1); };
 
 int main(int argc, char* argv[])
 {
     try {
         std::deque<p2p::frost_message_ptr> message_cache;
         std::mutex message_cache_mutex;
-        std::atomic<bool> agg_pubkey_ready = false;
-        Signer config;
+        std::atomic_bool agg_pubkey_ready = false;
+        TestSigner config;
         config.ProcessConfig(argc, argv);
 
         if (config.mVerbose > 1) config.Print();
@@ -137,35 +140,54 @@ int main(int argc, char* argv[])
             sk = ParseHex(config.mSecKey);
         }
 
-        size_t N = config.m_peers.size();
-        size_t K = (N % 2) ? (N + 1) / 2 : N / 2;
-
-        std::shared_ptr<SignerApi> signer = make_shared<SignerApi>(
-                config.mSecKey.empty()
-                ? l15::core::ChannelKeys(config.mWallet.Secp256k1Context())
-                : l15::core::ChannelKeys(config.mWallet.Secp256k1Context(), std::move(sk)),
-                N, K,
-                error_hdl);
+        core::ChannelKeys keypair = config.mSecKey.empty()
+                             ? l15::core::ChannelKeys(config.mWallet.Secp256k1Context())
+                             : l15::core::ChannelKeys(config.mWallet.Secp256k1Context(), std::move(sk));
 
         if (config.mVerbose) {
             std::clog << "pid: " << getpid() << "\n";
-            std::clog << "sign: " << K << "-of-" << N << "\n";
-            std::clog << "sk: " << HexStr(signer->GetSecKey()) << "\n";
-            std::clog << "pk: " << HexStr(signer->GetLocalPubKey()) << std::endl;
+//            std::clog << "sign: " << K << "-of-" << N << "\n";
+            std::clog << "sk: " << hex(keypair.GetLocalPrivKey()) << "\n";
+            std::clog << "pk: " << hex(keypair.GetLocalPubKey()) << std::endl;
         }
 
         if (config.mDryRun) {
             return 0;
         }
 
-        std::unique_ptr<ZmqService> peerService = std::make_unique<ZmqService>(
+        std::shared_ptr<ZmqService> peerService = std::make_shared<ZmqService>(
                 config.mWallet.Secp256k1Context(),
-                config.mTaskService,
-                signer->GetLocalPubKey(),
-                config.mDoSign ? p2p::FROST_MESSAGE::SIGNATURE_SHARE : p2p::FROST_MESSAGE::KEY_SHARE);
+                config.mTaskService, [&, verbose = config.mVerbose](p2p::frost_message_ptr m) {
+                    if ((m->id == p2p::FROST_MESSAGE::SIGNATURE_COMMITMENT || m->id == p2p::FROST_MESSAGE::SIGNATURE_SHARE) && !agg_pubkey_ready) {
+                        {
+                            std::lock_guard lock(message_cache_mutex);
+                            message_cache.emplace_back(m);
+                        }
+                        if (verbose == 2)
+                            std::clog << (std::ostringstream() << "<<<< " << m->ToString() << " >>>> move to cache until agg pubkey is ready").str()
+                                      << std::endl;
+                        return false;
+                    }
+
+                    if (m->id == p2p::FROST_MESSAGE::SIGNATURE_SHARE) {
+                        std::unique_lock lock(message_cache_mutex);
+                        if (std::find_if(message_cache.begin(), message_cache.end(), [m](auto m1) { return m1->pubkey == m->pubkey; }) !=
+                            message_cache.end()) {
+                            message_cache.emplace_back(m);
+                            lock.unlock();
+                            if (verbose == 2)
+                                std::clog << (std::ostringstream() << "<<<< " << m->ToString()
+                                                                   << " >>>> move to cache until sig commitment is processed").str() << std::endl;
+                            return false;
+                        }
+                    }
+
+                    if (verbose == 2) std::clog << (std::ostringstream() << "<<<< " << m->ToString()).str() << std::endl;
+                    return true;
+                });
 
         for (const auto &peer: config.m_peers) {
-            if (peer.first != signer->GetLocalPubKey()) {
+            if (peer.first != keypair.GetLocalPubKey()) {
                 peerService->AddPeer(xonly_pubkey(peer.first), std::string(peer.second));
 
                 if (config.mVerbose == 2) {
@@ -175,71 +197,41 @@ int main(int argc, char* argv[])
             }
         }
 
-        //config.mPeerService.SetSelfPubKey(signer->GetLocalPubKey());
-        signer->SetPublisher([&peerService, verbose = config.mVerbose](p2p::frost_message_ptr m) {
-            if (verbose == 2) std::clog << ">>>> " << m->ToString() << std::endl;
-            peerService->Publish(move(m));
-        });
-
-        for (const auto &peer: peerService->GetPeersMap()) {
-            signer->AddPeer(xonly_pubkey(peer.first), [&, pk = peer.first, verbose = config.mVerbose](p2p::frost_message_ptr m) {
-                if (verbose == 2)
-                    std::clog << (std::ostringstream() << ">>>> " << hex(pk).substr(0, 8) << "... | " << m->ToString()).str() << std::endl;
-                peerService->Send(pk, move(m));
-            });
-        }
+        if (config.mVerbose) std::clog << "Starting signer =================================================" << std::endl;
+        auto signerService = std::make_shared<signer_service::SignerService>(config.mTaskService);
 
-        if (config.mVerbose) std::clog << "Creating signer service =================================================" << std::endl;
-        signer_service::SignerService signerService(config.mTaskService);
-        signerService.AddSigner(signer);
+        auto signer = make_shared<frost::FrostSigner>(keypair, config.m_peers | std::views::keys, signerService, peerService);
+        signer->Start();
 
-        if (config.mVerbose) std::clog << "Starting network service ================================================" << std::endl;
-        peerService->StartService(config.mListenAddress, [&, signer, verbose = config.mVerbose](p2p::frost_message_ptr m) {
-            if ((m->id == p2p::FROST_MESSAGE::SIGNATURE_COMMITMENT || m->id == p2p::FROST_MESSAGE::SIGNATURE_SHARE) && !agg_pubkey_ready) {
-                {
-                    std::lock_guard lock(message_cache_mutex);
-                    message_cache.emplace_back(m);
-                }
-                if (verbose == 2)
-                    std::clog << (std::ostringstream() << "<<<< " << m->ToString() << " >>>> move to cache until agg pubkey is ready").str()
-                              << std::endl;
-                return;
-            }
+        std::promise<xonly_pubkey> aggpk_promise;
+        auto aggpk_res = aggpk_promise.get_future();
 
-            if (m->id == p2p::FROST_MESSAGE::SIGNATURE_SHARE) {
-                std::unique_lock lock(message_cache_mutex);
-                if (std::find_if(message_cache.begin(), message_cache.end(), [m](auto m1) { return m1->pubkey == m->pubkey; }) !=
-                    message_cache.end()) {
-                    message_cache.emplace_back(m);
-                    lock.unlock();
-                    if (verbose == 2)
-                        std::clog << (std::ostringstream() << "<<<< " << m->ToString()
-                                                           << " >>>> move to cache until sig commitment is processed").str() << std::endl;
-                    return;
-                }
-            }
+        signer->AggregateKey(cex::make_async_result<const xonly_pubkey&>(
+                [](const xonly_pubkey& aggpk, std::promise<xonly_pubkey>&& p) { p.set_value(aggpk); },
+                [](std::promise<xonly_pubkey>&& p){ p.set_exception(std::current_exception()); },
+                move(aggpk_promise)));
 
-            if (verbose == 2) std::clog << (std::ostringstream() << "<<<< " << m->ToString()).str() << std::endl;
-            signerService.Accept(signer->GetLocalPubKey(), m);
-        });
+        xonly_pubkey shared_pk = aggpk_res.get();
+        agg_pubkey_ready = true;
 
+        std::cout << "\nagg_pk:" << hex(shared_pk) << std::endl;
 
-        std::future<void> nonce_res;
-        //if (config.mDoSign) {
-        if (config.mVerbose) std::clog << "Commiting future signature nonces =======================================" << std::endl;
-        nonce_res = signerService.PublishNonces(signer->GetLocalPubKey(), 1);
-        nonce_res.wait();
-        //}
+        if (config.mDoSign) {
+            if (config.mVerbose) std::clog << "Commiting future signature nonces =======================================" << std::endl;
 
-        if (config.mVerbose) std::clog << "Aggregated key negotiation =====================================" << std::endl;
-        auto aggKeyFuture = signerService.NegotiateKey(signer->GetLocalPubKey());
-        xonly_pubkey shared_pk = aggKeyFuture.get();
-        agg_pubkey_ready = true;
+            std::promise<void> nonce_promise;
+            auto nonce_res = nonce_promise.get_future();
 
-        std::cout << "\nagg_pk:" << hex(shared_pk) << std::endl;
+            signer->CommitNonces(1, cex::make_async_result<void>(
+                    [](std::promise<void>&& p){p.set_value();},
+                    [](std::promise<void>&& p){p.set_exception(std::current_exception());},
+                    move(nonce_promise)));
 
-        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //Just get some time to handle what coming to the message cache ^^^
+            nonce_res.wait();
+        }
 
+//        std::this_thread::sleep_for(std::chrono::milliseconds(1000)); //Just get some time to handle what coming to the message cache ^^^
+//
         bool res = true;
         if (config.mDoSign) {
             while (true) {
@@ -254,15 +246,25 @@ int main(int argc, char* argv[])
                 }
 
                 if (config.mVerbose == 2) std::clog << (std::ostringstream() << "==== " << m->ToString()).str() << std::endl;
-                signerService.Accept(signer->GetLocalPubKey(), move(m));
+
+                peerService->GetMessageHandler()(move(m));
             }
 
-            uint256 message;
+            scalar message;
             CSHA256().Write((unsigned char *) config.mInput.data(), config.mInput.length()).Finalize(message.data());
 
             if (config.mVerbose) std::clog << "Signing =================================================================" << std::endl;
-            auto sign_res = signerService.Sign(signer->GetLocalPubKey(), message, 0);
-            signature sig = sign_res.get();
+
+            std::promise<signature> sig_promise;
+
+            auto sig_res = sig_promise.get_future();
+
+            signer->Sign(message, message, cex::make_async_result<signature>(
+                    [](signature sig, std::promise<signature>&& p){p.set_value(sig);},
+                    [](std::promise<signature>&& p){p.set_exception(std::current_exception());},
+                    move(sig_promise)));
+
+            signature sig = sig_res.get();
 
             std::cout << "sig: " << hex(sig) << std::endl;
 
@@ -286,6 +288,10 @@ int main(int argc, char* argv[])
     catch (const CLI::Error& e) {
         return e.get_exit_code();
     }
+    catch (const Error& e) {
+        std::cerr << e.what() << ": " << e.details() << std::endl;
+        return 1;
+    }
     catch (const std::exception &e) {
         std::cerr << "error: " << e.what() << std::endl;
         return 1;
diff --git a/test/testlib/Makefile.am b/test/testlib/Makefile.am
new file mode 100644
index 0000000..1312288
--- /dev/null
+++ b/test/testlib/Makefile.am
@@ -0,0 +1,14 @@
+AM_CPPFLAGS = \
+ -DZMQ_BUILD_DRAFT_API=1 $(ZMQ_CPPFLAGS) \
+ -I$(top_srcdir)/node/src \
+ -I$(top_srcdir)/contrib/secp256k1/include \
+ -I$(top_srcdir)/contrib/cex \
+ -I$(top_srcdir)/contrib/cli11 \
+ -I$(top_srcdir)/src/common \
+ -I$(top_srcdir)/src/core \
+ -I$(top_srcdir)/src/service \
+ -I$(top_srcdir)/src/p2p
+
+
+noinst_LTLIBRARIES = libl15-test.la
+libl15_test_la_SOURCES = zmq_service.cpp
\ No newline at end of file
diff --git a/test/time_measure.hpp b/test/testlib/time_measure.hpp
similarity index 100%
rename from test/time_measure.hpp
rename to test/testlib/time_measure.hpp
diff --git a/test/testlib/zmq_service.cpp b/test/testlib/zmq_service.cpp
new file mode 100644
index 0000000..7d47da1
--- /dev/null
+++ b/test/testlib/zmq_service.cpp
@@ -0,0 +1,292 @@
+
+#include <deque>
+#include <stdexcept>
+#include <functional>
+#include <stdexcept>
+#include <sstream>
+
+#include "wrapstream.hpp"
+
+#include "generic_service.hpp"
+#include "zmq_service.hpp"
+
+namespace l15 {
+
+const std::string ZmqService::STOP("stop");
+
+ZmqService::~ZmqService()
+{
+    std::clog << "Destroying ZMQ service" << std::endl;
+
+    zmq::socket_t sock(zmq_ctx.value(), zmq::socket_type::client);
+    zmq::message_t stop(STOP);
+
+    std::string local_addr = m_server_address;
+    local_addr.replace(local_addr.find('*'), 1, "localhost");
+
+    sock.connect(local_addr);
+    sock.send(stop, zmq::send_flags::none);
+    sock.close();
+
+//        mTaskService->Serve([this]() {
+//            std::shared_lock lock(m_peers_mutex);
+    for (auto &peer: m_peers) {
+        peer_socket(peer.second).close();
+    }
+//        });
+
+    std::unique_lock lock(m_peers_mutex);
+    m_peers.clear();
+
+    std::unique_lock exit_lock(m_exit_mutex);
+
+    if (zmq_ctx.has_value()) {
+        zmq_ctx->shutdown();
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+}
+
+void ZmqService::Connect(const xonly_pubkey& local_pk, std::function<void(p2p::frost_message_ptr)> h)
+{
+    if (!m_server_address.empty()) {
+        throw std::runtime_error("already subscribed");
+    }
+
+    auto peer_it = m_peers.find(local_pk);
+    if (peer_it != m_peers.end()) {
+
+        const std::string self_address = peer_address(peer_it->second);
+
+        size_t p1 = self_address.find("//");
+        if (p1 == std::string::npos) {
+            p2p::WrongAddress(std::string(self_address));
+        }
+        size_t p2 = self_address.find(":", p1+2);
+        if (p2 == std::string::npos) {
+            p2p::WrongAddress(std::string(self_address));
+        }
+        std::string listen_addr = self_address.substr(0, p1+2) + "*" + self_address.substr(p2);
+
+        m_self_address = local_pk;
+        m_server_address = listen_addr;
+        m_subscription_handler = h;
+
+        std::thread(&ZmqService::ListenCycle, this, move(listen_addr),
+                    [this, message_handler = move(h)] (p2p::frost_message_ptr m) {
+                        if (m_message_filter(m))
+                            message_handler(m);
+                    }
+        ).detach();
+    }
+    else {
+        throw p2p::UnknownPeer(hex(local_pk));
+    }
+
+    for (auto peer: m_peers) {
+        if (peer.first != local_pk) {
+            peer_socket(peer.second).connect(peer_address(peer.second));
+        }
+    }
+}
+
+void ZmqService::Publish(p2p::frost_message_ptr m,
+                         std::function<void(const xonly_pubkey&, p2p::frost_message_ptr)> on_send,
+                         std::function<void(const xonly_pubkey&, p2p::frost_message_ptr)> on_error)
+{
+    std::shared_lock lock(m_peers_mutex);
+    for (auto &peer: m_peers) {
+        if (peer.first == m_self_address)
+            continue;
+
+        auto peer_msg = m->Copy();
+        mTaskService->Serve([=, this]() {
+            try {
+                on_send(peer.first, peer_msg);
+                SendInternal(peer, peer_msg);
+            } catch(...) {
+                on_error(peer.first, peer_msg);
+            }
+        });
+    }
+}
+
+void ZmqService::Send(const xonly_pubkey &pk, p2p::frost_message_ptr m,
+                      std::function<void()> on_error)
+{
+    if (pk == m_self_address)
+        throw std::runtime_error("send to self");
+
+    std::shared_lock lock(m_peers_mutex);
+    auto peer_it = m_peers.find(pk);
+    if (peer_it == m_peers.end()) {
+        throw p2p::UnknownPeer(hex(pk));
+    }
+
+    mTaskService->Serve([this, peer = *peer_it, m = move(m), on_error]() {
+        try {
+            SendInternal(peer, m);
+        } catch(...) {
+            on_error();
+        }
+    });
+}
+
+void ZmqService::SendInternal(const ZmqService::peers_map::value_type& peer, p2p::frost_message_ptr msg)
+{
+    std::clog << (std::ostringstream() << ">>> " << msg->ToString() << "\n").str() << std::flush;
+
+    cex::stream<std::deque<uint8_t>> data;
+    if (msg) {
+        p2p::Serialize(data, m_ctx, *msg);
+    }
+
+    zmq::message_t zmq_msg(data.begin(), data.end());
+
+    auto res = peer_socket(peer.second).send(move(zmq_msg), zmq::send_flags::dontwait);
+    if (!res) {
+        throw p2p::SendError(hex(peer.first));
+    }
+
+    if (res.value() < data.size()) {
+        throw std::runtime_error((std::ostringstream() << "just part of message has been sent: " << res.value() << " of " << data.size()).str());
+    }
+}
+
+
+void ZmqService::CheckPeers()
+{
+//    mTaskService->Serve([this]() {
+//
+//        //std::clog << "^^^^ End phase: " << static_cast<uint16_t>(m_end_phase) << std::endl;
+//
+//        size_t confirmation_wait_count = 0;
+//        std::for_each(m_peers.begin(), m_peers.end(), [this, &confirmation_wait_count](auto & peer) {
+//            try {
+//                m_protocol_confirmation_mutex.try_lock();
+//                std::unique_lock lock(peer_outgoing_mutex(peer.second), std::try_to_lock);
+//                p2p::frost_message_ptr out_msg;
+//                if (lock.owns_lock()) {
+//                    size_t unconfirmed_out_count = 0;
+//                    out_msg = peer_outgoing_pipeline(peer.second).PeekUnconfirmedMessage(std::chrono::seconds(7), unconfirmed_out_count);
+//                    confirmation_wait_count += unconfirmed_out_count;
+//                    if (out_msg) {
+//                        std::clog << (std::ostringstream() << "Repeat sending to " << hex(peer.first).substr(0, 8)).str() << std::endl;
+//                        SendInternal(peer.second, out_msg);
+//                    }
+//                    else {
+//                        size_t unconfirmed_in_count = 0;
+//                        p2p::frost_message_ptr in_msg = peer_incoming_pipeline(peer.second).PeekUnconfirmedMessage(std::chrono::seconds(7), unconfirmed_in_count);
+//                        confirmation_wait_count += unconfirmed_in_count;
+//
+//                    }
+//                }
+//            }
+//            catch (Error &e) {
+//                std::cerr << "Send error: " << e.what() << ": " << e.details() << std::endl;
+//            }
+//            catch (std::exception &e) {
+//                std::cerr << "Send error: " << e.what() << std::endl;
+//            }
+//            catch (...) {
+//                std::cerr << "Send error: unknown error" << std::endl;
+//            }
+//        });
+//
+//        //std::clog << "^^^^ Confirmation wait count: " << confirmation_wait_count << std::endl;
+//
+//
+//        if (confirmation_wait_count == 0) {
+//            m_protocol_confirmation_mutex.unlock();
+//        }
+//    });
+}
+
+
+void ZmqService::ListenCycle(const std::string server_addr, frost_link_handler h)
+{
+    std::shared_lock thread_lock(m_exit_mutex);
+
+    cex::stream<std::deque<uint8_t>> buffer;
+
+    zmq::socket_t server_sock(zmq_ctx.value(), zmq::socket_type::server);
+
+    server_sock.bind(server_addr);
+
+    std::clog << "Listening at: " << server_addr << std::endl;
+
+    for(bool next_block = false;;) {
+        try {
+
+            if (!next_block && !buffer.empty()) {
+                try {
+                    p2p::frost_message_ptr msg = nullptr;
+                    msg = p2p::Unserialize(m_ctx, buffer);
+
+                    buffer.clear();
+
+                    std::shared_lock lock(m_peers_mutex);
+                    auto peer_it = m_peers.find(msg->pubkey);
+                    if (peer_it == m_peers.end()) {
+                        throw p2p::WrongMessageData(*msg);
+                    }
+                    peer_state peer = peer_it->second;
+                    lock.unlock();
+
+                    //std::clog << (std::ostringstream() << "vvv " << msg->ToString()).str() << std::endl;
+                    mTaskService->Serve([this, m = move(msg), h]() {
+                        std::clog << (std::ostringstream() << "[" << hex(m_self_address).substr(0,8) << "] <<< " << m->ToString() << "\n").str() << std::flush;
+                        h(m);
+                        std::clog << (std::ostringstream() << "[" << hex(m_self_address).substr(0,8) << "] ||| " << m->ToString() << "\n").str() << std::flush;
+                    });
+                }
+                catch(...) {
+                    buffer.clear();
+                    print_error(std::cerr);
+                }
+            }
+
+            zmq::message_t m;
+
+            auto cycle_start = std::chrono::steady_clock::now();
+
+            auto res = server_sock.recv(m, zmq::recv_flags::dontwait);
+            next_block = m.more();
+
+            if (!res) {
+
+//                std::clog << "No message" << std::endl;
+//
+//                CheckPeers();
+
+                auto cycle_end = std::chrono::steady_clock::now();
+                auto elapsed = cycle_end - cycle_start;
+                if (elapsed < std::chrono::milliseconds(50)) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(50) - elapsed);
+                }
+            }
+            else if (m == zmq::message_t(STOP)) {
+                break;
+            }
+            else {
+                //std::clog << (std::ostringstream() << "P2P message size: " << m.size() << ", next_block: " << next_block).str() << std::endl;
+
+                buffer.append(m.data<uint8_t>(), m.data<uint8_t>() + m.size());
+            }
+        }
+        catch (...) {
+            std::cerr << "Skipping unknown error" << std::endl;
+            print_error(std::cerr);
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+    }
+
+    server_sock.close();
+    std::clog << "Stop listening at: " << server_addr << std::endl;
+}
+
+void ZmqService::WaitForConfirmations()
+{
+//    std::lock_guard lock(m_protocol_confirmation_mutex);
+}
+
+}
diff --git a/test/testlib/zmq_service.hpp b/test/testlib/zmq_service.hpp
new file mode 100644
index 0000000..1d6dfa1
--- /dev/null
+++ b/test/testlib/zmq_service.hpp
@@ -0,0 +1,89 @@
+#pragma once
+#include <string>
+#include <memory>
+#include <unordered_map>
+#include <mutex>
+#include <semaphore>
+
+#include <tbb/concurrent_vector.h>
+#include <boost/container/flat_map.hpp>
+
+#include "common.hpp"
+#include "zmq_context.hpp"
+#include "p2p_frost.hpp"
+
+namespace l15 {
+
+namespace service {
+    class GenericService;
+}
+
+typedef std::function<void(p2p::frost_message_ptr)> frost_link_handler;
+
+class ZmqService : public p2p::P2PInterface<xonly_pubkey, p2p::FrostMessage>
+{
+public:
+    typedef std::tuple<std::string, zmq::socket_t> peer;
+    typedef std::shared_ptr<peer> peer_state;
+    typedef std::unordered_map<xonly_pubkey, peer_state, l15::hash<xonly_pubkey>> peers_map;
+private:
+    const static std::string STOP;
+
+    const secp256k1_context_struct *m_ctx;
+    std::optional<zmq::context_t> zmq_ctx;
+    peers_map m_peers;
+    std::shared_mutex m_peers_mutex;
+
+    std::shared_ptr<service::GenericService> mTaskService;
+
+    xonly_pubkey m_self_address;
+    std::string m_server_address;
+
+    std::mutex m_protocol_confirmation_mutex;
+    std::shared_mutex m_exit_mutex;
+
+    std::function<bool(p2p::frost_message_ptr)> m_message_filter;
+    std::function<void(p2p::frost_message_ptr)> m_subscription_handler;
+
+private:
+    static inline const std::string& peer_address(const peer_state& state) { return get<0>(*state); }
+    static inline zmq::socket_t& peer_socket(const peer_state& state) { return get<1>(*state); }
+
+    void ListenCycle(std::string server_addr, frost_link_handler h);
+    void CheckPeers();
+
+    void SendInternal(const ZmqService::peers_map::value_type&, p2p::frost_message_ptr m);
+
+public:
+    explicit ZmqService(const secp256k1_context_struct *ctx, std::shared_ptr<service::GenericService> srv, std::function<bool(p2p::frost_message_ptr)> msg_filter = [](p2p::frost_message_ptr){ return true;})
+    : m_ctx(ctx), zmq_ctx(zmq::context_t(10)), m_peers(), mTaskService(move(srv)), m_protocol_confirmation_mutex(), m_exit_mutex(), m_message_filter(move(msg_filter)) {}
+
+    ~ZmqService() override;
+
+    void AddPeer(xonly_pubkey&& pk, string&& addr)
+    {
+        xonly_pubkey pk1(pk), pk2(pk);
+        m_peers.emplace(move(pk), std::make_shared<peer>(
+            move(addr), zmq::socket_t(zmq_ctx.value(), zmq::socket_type::client)
+        ));
+    }
+
+    const peers_map& GetPeersMap() const
+    { return m_peers; }
+
+    const std::function<void(p2p::frost_message_ptr)>& GetMessageHandler()
+    { return m_subscription_handler; }
+
+    void Publish(p2p::frost_message_ptr m,
+                 std::function<void(const xonly_pubkey&, p2p::frost_message_ptr)> on_send,
+                 std::function<void(const xonly_pubkey&, p2p::frost_message_ptr)> on_error) override;
+
+    void Send(const xonly_pubkey& pk, p2p::frost_message_ptr m,
+              std::function<void()> on_error) override;
+
+    void Connect(const xonly_pubkey&, std::function<void(p2p::frost_message_ptr)>) override;
+
+    void WaitForConfirmations();
+};
+
+}
diff --git a/test/zmq_service.cpp b/test/zmq_service.cpp
deleted file mode 100644
index dbc65ca..0000000
--- a/test/zmq_service.cpp
+++ /dev/null
@@ -1,388 +0,0 @@
-
-#include <deque>
-#include <stdexcept>
-#include <functional>
-
-#include "wrapstream.hpp"
-
-#include "generic_service.hpp"
-#include "zmq_service.hpp"
-
-namespace l15 {
-
-const std::string ZmqService::STOP("stop");
-
-ZmqService::~ZmqService()
-{
-    if (!m_server_addr.empty()) {
-        zmq::socket_t sock(zmq_ctx.value(), zmq::socket_type::push);
-        zmq::message_t stop(STOP);
-
-        std::string local_addr = m_server_addr.replace(m_server_addr.find('*'), 1, "localhost");
-
-        sock.connect(local_addr);
-        sock.send(stop, zmq::send_flags::none);
-        m_exit_sem.acquire();
-        sock.close();
-
-        //std::binary_semaphore peers_sem(0);
-        mTaskService->Serve([this]() {
-            std::shared_lock lock(m_peers_mutex);
-            for (auto &peer: m_peers) {
-                peer_socket(peer.second).close();
-            }
-            //peers_sem.release();
-        });
-        //peers_sem.acquire();
-
-        std::unique_lock lock(m_peers_mutex);
-        m_peers.clear();
-    }
-
-    if (zmq_ctx.has_value()) {
-        zmq_ctx->shutdown();
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    }
-}
-
-void ZmqService::StartService(const std::string& addr, p2p::frost_link_handler&& h)
-{
-    m_server_addr = addr;
-
-    for (auto &peer: m_peers) {
-        peer_socket(peer.second).connect(peer_address(peer.second));
-    }
-
-    std::thread(&ZmqService::ListenCycle, this, move(h)).detach();
-}
-
-void ZmqService::Publish(p2p::frost_message_ptr m)
-{
-    std::shared_lock lock(m_peers_mutex);
-    for (auto& peer_data: m_peers) {
-        SendWithPipeline(peer_data.second, m);
-    }
-}
-
-void ZmqService::Send(const xonly_pubkey &pk, p2p::frost_message_ptr m)
-{
-    std::shared_lock lock(m_peers_mutex);
-    auto peer_it = m_peers.find(pk);
-    if (peer_it == m_peers.end()) {
-        throw std::invalid_argument(hex(pk));
-    }
-    lock.unlock();
-
-    SendWithPipeline(peer_it->second, move(m));
-}
-
-void ZmqService::ProcessIncomingPipeline(ZmqService::peer_state peer, p2p::frost_link_handler h)
-{
-    try {
-        std::unique_lock lock(peer_incoming_mutex(peer), std::try_to_lock);
-        if (lock.owns_lock()) {
-            p2p::frost_message_ptr msg;
-            while ((msg = peer_incoming_pipeline(peer).PeekNextMessage())) {
-                h(move(msg));
-                peer_incoming_pipeline(peer).PopCurrentMessage();
-            }
-        }
-    }
-    catch (Error &e) {
-        std::cerr << "Cannot process FROST message: " << e.what() << ": " << e.details() << std::endl;
-    }
-    catch (std::exception &e) {
-        std::cerr << "Cannot process FROST message: " << e.what() << std::endl;
-    }
-    catch (...) {
-        std::cerr << "Cannot process FROST message: unknown error" << std::endl;
-    }
-}
-
-
-void ZmqService::SendInternal(ZmqService::peer_state peer, p2p::frost_message_ptr msg)
-{
-    cex::stream<std::deque<uint8_t>> data;
-    if (msg) {
-        p2p::Serialize(data, m_ctx, *msg);
-    }
-    else {
-        p2p::FrostMessage m(p2p::FROST_MESSAGE::MESSAGE_ID_COUNT, xonly_pubkey(m_pk));
-        m.Serialize(data);
-    }
-
-    auto cur_phase = peer_incoming_pipeline(peer).GetCurPhase();
-    data << cur_phase;
-
-    std::clog << (std::ostringstream() << "Sending to " << hex(peer_outgoing_pipeline(peer).Pubkey()).substr(0, 8) << "... "<< data.size() <<"b:\n" << hex(data)).str() << std::endl;
-
-    zmq::message_t zmq_msg(data.begin(), data.end());
-
-    auto res = peer_socket(peer).send(move(zmq_msg), zmq::send_flags::dontwait);
-    if (!res) {
-        throw std::runtime_error("send returned zero bytes sent");
-    }
-
-    if (res.value() < data.size()) {
-        throw std::runtime_error((std::ostringstream() << "just part of message has been sent: " << res.value() << " of " << data.size()).str());
-    }
-
-    peer_incoming_pipeline(peer).ConfirmPhase(cur_phase);
-}
-
-
-void ZmqService::ProcessOutgoingPipeline(ZmqService::peer_state peer)
-{
-    try {
-        std::unique_lock lock(peer_outgoing_mutex(peer), std::try_to_lock);
-        if (lock.owns_lock()) {
-            p2p::frost_message_ptr msg;
-            while ((msg = peer_outgoing_pipeline(peer).PeekNextMessage())) {
-                SendInternal(peer, msg);
-                peer_outgoing_pipeline(peer).PopCurrentMessage();
-            }
-        }
-    }
-    catch (Error &e) {
-        std::cerr << "Send error: " << e.what() << ": " << e.details() << std::endl;
-    }
-    catch (std::exception &e) {
-        std::cerr << "Send error: " << e.what() << std::endl;
-    }
-    catch (...) {
-        std::cerr << "Send error: unknown error" << std::endl;
-    }
-}
-
-
-void ZmqService::SendWithPipeline(ZmqService::peer_state peer, p2p::frost_message_ptr m)
-{
-    m_protocol_confirmation_mutex.try_lock();
-
-    peer_outgoing_pipeline(peer).PushMessage(move(m));
-    mTaskService->Serve([this, peer]()
-    {
-        ProcessOutgoingPipeline(peer);
-    });
-}
-
-
-void ZmqService::CheckPeers()
-{
-    mTaskService->Serve([this]() {
-
-        //std::clog << "^^^^ End phase: " << static_cast<uint16_t>(m_end_phase) << std::endl;
-
-        size_t confirmation_wait_count = 0;
-        std::for_each(m_peers.begin(), m_peers.end(), [this, &confirmation_wait_count](auto & peer) {
-            try {
-                m_protocol_confirmation_mutex.try_lock();
-                std::unique_lock lock(peer_outgoing_mutex(peer.second), std::try_to_lock);
-                p2p::frost_message_ptr out_msg;
-                if (lock.owns_lock()) {
-                    size_t unconfirmed_out_count = 0;
-                    out_msg = peer_outgoing_pipeline(peer.second).PeekUnconfirmedMessage(std::chrono::seconds(7), unconfirmed_out_count);
-                    confirmation_wait_count += unconfirmed_out_count;
-                    if (out_msg) {
-                        std::clog << (std::ostringstream() << "Repeat sending to " << hex(peer.first).substr(0, 8)).str() << std::endl;
-                        SendInternal(peer.second, out_msg);
-                    }
-                    else {
-                        size_t unconfirmed_in_count = 0;
-                        p2p::frost_message_ptr in_msg = peer_incoming_pipeline(peer.second).PeekUnconfirmedMessage(std::chrono::seconds(7), unconfirmed_in_count);
-                        confirmation_wait_count += unconfirmed_in_count;
-
-                        //std::clog << "Check peer's incoming pipeline | current phase: " << static_cast<uint16_t>(peer_outgoing_pipeline(peer.second).GetCurPhase()) << ", unconfirmed count: " << unconfirmed_in_count << std::endl;
-
-                        if (in_msg && peer_outgoing_pipeline(peer.second).GetCurPhase() == m_end_phase) {
-                            //std::clog << "Schedule confirmation send for peer" << std::endl;
-                            SendInternal(peer.second, nullptr);
-                        }
-                    }
-                }
-            }
-            catch (Error &e) {
-                std::cerr << "Send error: " << e.what() << ": " << e.details() << std::endl;
-            }
-            catch (std::exception &e) {
-                std::cerr << "Send error: " << e.what() << std::endl;
-            }
-            catch (...) {
-                std::cerr << "Send error: unknown error" << std::endl;
-            }
-        });
-
-        //std::clog << "^^^^ Confirmation wait count: " << confirmation_wait_count << std::endl;
-
-
-        if (confirmation_wait_count == 0) {
-            m_protocol_confirmation_mutex.unlock();
-        }
-    });
-}
-
-
-void ZmqService::ListenCycle(p2p::frost_link_handler h)
-{
-    cex::stream<std::deque<uint8_t>> buffer;
-
-    zmq::socket_t server_sock(zmq_ctx.value(), zmq::socket_type::pull);
-
-    server_sock.bind(m_server_addr);
-
-    std::clog << "Listening at: " << m_server_addr << std::endl;
-
-    for(bool next_block = false;;) {
-        try {
-
-            if (!next_block && !buffer.empty()) {
-                try {
-                    p2p::frost_message_ptr msg = nullptr;
-                    try {
-                        msg = p2p::Unserialize(m_ctx, buffer);
-                    }
-                    catch(p2p::WrongMessage e) {
-                        if (e.protocol_id != static_cast<uint16_t>(p2p::PROTOCOL::FROST) ||
-                            e.message_id != static_cast<uint16_t>(p2p::FROST_MESSAGE::MESSAGE_ID_COUNT))
-                        {
-                            std::rethrow_exception(std::current_exception());
-                        }
-                        msg = std::make_shared<p2p::FrostMessage>(static_cast<p2p::FROST_MESSAGE>(e.message_id), move(e.pubkey));
-                    }
-
-                    p2p::FROST_MESSAGE last_recv_id = p2p::FROST_MESSAGE::MESSAGE_ID_COUNT;
-                    if (buffer.remains() >= sizeof(p2p::FROST_MESSAGE)) {
-                        buffer >> last_recv_id;
-                    }
-
-                    buffer.clear();
-
-                    std::shared_lock lock(m_peers_mutex);
-                    peers_map::iterator peer_it = m_peers.find(msg->pubkey);
-                    if (peer_it == m_peers.end()) {
-                        throw p2p::WrongMessageData(*msg);
-                    }
-                    peer_state peer = peer_it->second;
-                    lock.unlock();
-
-                    std::clog << (std::ostringstream() << "++++ " << hex(msg->pubkey).substr(0, 8) << "... -> " << static_cast<uint16_t>(last_recv_id)).str() << std::endl;
-                    if (last_recv_id != p2p::FROST_MESSAGE::MESSAGE_ID_COUNT) {
-                        peer_outgoing_pipeline(peer).ConfirmPhase(last_recv_id);
-                    }
-
-                    if (msg->id != p2p::FROST_MESSAGE::MESSAGE_ID_COUNT) {
-                        peer_incoming_pipeline(peer).PushMessage(move(msg));
-                        mTaskService->Serve([this, peer, h]() { ProcessIncomingPipeline(peer, h); });
-                    }
-                }
-                catch(p2p::UnserializeError& e) {
-                    buffer.clear();
-                    std::cerr << (std::ostringstream() << "Skipping: " << e.what() << "\n" << e.details()).str() << std::endl;
-                }
-                catch(...) {
-                    buffer.clear();
-                    std::cerr << "Skipping unknown error" << std::endl;
-                }
-            }
-
-            zmq::message_t m;
-
-            auto cycle_start = std::chrono::steady_clock::now();
-
-            auto res = server_sock.recv(m, zmq::recv_flags::dontwait);
-            next_block = m.more();
-
-            if (!res) {
-                CheckPeers();
-
-                auto cycle_end = std::chrono::steady_clock::now();
-                auto elapsed = cycle_end - cycle_start;
-                if (elapsed < std::chrono::milliseconds(50)) {
-                    std::this_thread::sleep_for(std::chrono::milliseconds(50) - elapsed);
-                }
-            }
-            else if (m == zmq::message_t(STOP)) {
-                break;
-            }
-            else {
-                buffer.append(m.data<uint8_t>(), m.data<uint8_t>() + m.size());
-            }
-        }
-        catch (std::exception& e) {
-            std::cerr << "Skipping unknown error: " << e.what() << std::endl;
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        }
-        catch (...) {
-            std::cerr << "Skipping unknown error" << std::endl;
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        }
-    }
-
-    server_sock.close();
-
-    m_exit_sem.release();
-}
-
-void ZmqService::WaitForConfirmations()
-{
-    std::lock_guard lock(m_protocol_confirmation_mutex);
-}
-
-
-void FrostMessagePipeLine::PushMessage(p2p::frost_message_ptr msg)
-{
-    std::lock_guard lock(*m_queue_mutex);
-    auto ins_it = std::find_if(m_queue.begin(), m_queue.end(), [msg](const p2p::frost_message_ptr& que_msg){ return que_msg->id > msg->id; });
-    m_queue.insert(ins_it, move(msg));
-}
-
-p2p::frost_message_ptr FrostMessagePipeLine::PeekNextMessage()
-{
-    std::lock_guard lock(*m_queue_mutex);
-    auto it = std::find_if(m_queue.begin(), m_queue.end(), [this](auto& m){ return m->id == m_next_phase; });
-    return (it != m_queue.end()) ? *it : l15::p2p::frost_message_ptr();
-}
-
-p2p::frost_message_ptr FrostMessagePipeLine::PeekUnconfirmedMessage(std::chrono::milliseconds confirmation_timeout, size_t& unconfirmed_count)
-{
-    auto time = std::chrono::steady_clock::now();
-    std::lock_guard lock(*m_queue_mutex);
-    unconfirmed_count = m_queue.size();
-    if ((time - m_last_to_confirm_time > confirmation_timeout) && !m_queue.empty() && m_queue.front()->id < m_next_phase) {
-        m_last_to_confirm_time = time;
-        return m_queue.front();
-    } else {
-        return l15::p2p::frost_message_ptr();
-    }
-}
-
-void FrostMessagePipeLine::PopCurrentMessage()
-{
-    auto time = std::chrono::steady_clock::now();
-    std::lock_guard lock(*m_queue_mutex);
-    auto it = std::find_if(m_queue.begin(), m_queue.end(), [this](auto& m){ return m->id == m_next_phase; });
-    if (it != m_queue.end()) {
-        m_next_phase = static_cast<p2p::FROST_MESSAGE>(static_cast<uint16_t>(m_next_phase) + 1);
-        m_last_to_confirm_time = time;
-    }
-}
-
-void FrostMessagePipeLine::ConfirmPhase(p2p::FROST_MESSAGE confirm_phase)
-{
-    auto time = std::chrono::steady_clock::now();
-    std::list<p2p::frost_message_ptr> confirmed;
-    {
-        std::lock_guard lock(*m_queue_mutex);
-        while (!m_queue.empty() && confirm_phase >= m_queue.front()->id) {
-            confirmed.push_back(m_queue.front());
-            m_queue.pop_front();
-            m_last_to_confirm_time = time;
-        }
-    }
-    for (auto& m: confirmed) {
-        std::clog << (std::ostringstream() << "@@@@: " << hex(m_pk).substr(0,8) << "... " << m->ToString()).str() << std::endl;
-    }
-}
-
-
-}
diff --git a/test/zmq_service.hpp b/test/zmq_service.hpp
deleted file mode 100644
index 0c959f6..0000000
--- a/test/zmq_service.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#pragma once
-#include <string>
-#include <memory>
-#include <unordered_map>
-#include <mutex>
-#include <semaphore>
-
-#include "common.hpp"
-#include "zmq_context.hpp"
-#include "p2p_frost.hpp"
-
-namespace l15 {
-
-namespace service {
-    class GenericService;
-}
-
-class FrostMessagePipeLine {
-    xonly_pubkey m_pk;
-    std::list<p2p::frost_message_ptr> m_queue;
-    p2p::FROST_MESSAGE m_next_phase;
-    std::chrono::time_point<std::chrono::steady_clock> m_last_to_confirm_time;
-    std::unique_ptr<std::mutex> m_queue_mutex;
-public:
-    explicit FrostMessagePipeLine(xonly_pubkey&& pk) :
-        m_pk(move(pk)),
-        m_queue(),
-        m_next_phase(p2p::FROST_MESSAGE::NONCE_COMMITMENTS),
-        m_last_to_confirm_time(std::chrono::steady_clock::now()),
-        m_queue_mutex(std::make_unique<std::mutex>())
-        {}
-    FrostMessagePipeLine(FrostMessagePipeLine&&) noexcept = default;
-
-    const xonly_pubkey& Pubkey() const
-    { return m_pk; }
-
-    void PushMessage(p2p::frost_message_ptr msg);
-    p2p::frost_message_ptr PeekNextMessage();
-    p2p::frost_message_ptr PeekUnconfirmedMessage(std::chrono::milliseconds confirmation_timeout, size_t& unconfirmed_count);
-    void PopCurrentMessage();
-    p2p::FROST_MESSAGE GetCurPhase() const
-    {
-        p2p::FROST_MESSAGE cur_phase = m_next_phase;
-        if (cur_phase == p2p::FROST_MESSAGE::NONCE_COMMITMENTS)
-            cur_phase = p2p::FROST_MESSAGE::MESSAGE_ID_COUNT;
-        else
-            cur_phase = static_cast<p2p::FROST_MESSAGE>(static_cast<uint16_t>(m_next_phase) - 1);
-        return cur_phase;
-    }
-    void ConfirmPhase(p2p::FROST_MESSAGE confirm_phase);
-};
-
-class ZmqService// : public service::ZmqContextSingleton
-{
-public:
-    typedef std::tuple<std::string,
-                        zmq::socket_t,
-                        FrostMessagePipeLine,        // Outgoing message pipeline
-                        std::unique_ptr<std::mutex>, // This mutex is used to guarantee that a peer related message send happens from single thread only
-                        FrostMessagePipeLine,        // Incoming message pipeline
-                        std::unique_ptr<std::mutex>  // This mutex is used to guarantee that a peer related message receive happens from single thread only
-    > peer;
-
-    typedef std::shared_ptr<peer> peer_state;
-    typedef std::unordered_map<xonly_pubkey, peer_state, l15::hash<xonly_pubkey>> peers_map;
-private:
-    const static std::string STOP;
-
-    const secp256k1_context_struct *m_ctx;
-    std::optional<zmq::context_t> zmq_ctx;
-    const xonly_pubkey m_pk;
-    const p2p::FROST_MESSAGE m_end_phase;
-    peers_map m_peers;
-    std::shared_mutex m_peers_mutex;
-
-    std::shared_ptr<service::GenericService> mTaskService;
-
-    std::string m_server_addr;
-
-    std::mutex m_protocol_confirmation_mutex;
-    std::binary_semaphore m_exit_sem;
-
-private:
-    static inline std::string& peer_address(peer_state& state) { return get<0>(*state); }
-    static inline zmq::socket_t& peer_socket(peer_state& state) { return get<1>(*state); }
-    static inline FrostMessagePipeLine& peer_outgoing_pipeline(peer_state& state) { return get<2>(*state); }
-    static inline std::mutex& peer_outgoing_mutex(peer_state& state) { return *get<3>(*state); }
-    static inline FrostMessagePipeLine& peer_incoming_pipeline(peer_state& state) { return get<4>(*state); }
-    static inline std::mutex& peer_incoming_mutex(peer_state& state) { return *get<5>(*state); }
-
-    void ListenCycle(p2p::frost_link_handler h);
-    void CheckPeers();
-
-    void SendInternal(ZmqService::peer_state peer, p2p::frost_message_ptr m);
-
-    void ProcessIncomingPipeline(peer_state peer, p2p::frost_link_handler h);
-    void ProcessOutgoingPipeline(peer_state peer);
-    void SendWithPipeline(peer_state peer, p2p::frost_message_ptr m);
-
-public:
-    explicit ZmqService(const secp256k1_context_struct *ctx, std::shared_ptr<service::GenericService> srv, xonly_pubkey pk, p2p::FROST_MESSAGE end_phase)
-    : m_ctx(ctx), zmq_ctx(zmq::context_t(10, 1005)), m_pk(move(pk)), m_end_phase(end_phase), m_peers(), mTaskService(move(srv)), m_protocol_confirmation_mutex(), m_exit_sem(0) {}
-
-    ~ZmqService();
-
-    void AddPeer(xonly_pubkey&& pk, string&& addr)
-    {
-        xonly_pubkey pk1(pk), pk2(pk);
-        m_peers.emplace(move(pk), std::make_shared<peer>(
-            move(addr), zmq::socket_t(zmq_ctx.value(), zmq::socket_type::push),
-            FrostMessagePipeLine(move(pk1)), std::make_unique<std::mutex>(),
-            FrostMessagePipeLine((move(pk2))), std::make_unique<std::mutex>()
-        ));
-    }
-
-    const peers_map& GetPeersMap() const
-    { return m_peers; }
-
-    void StartService(const std::string& addr, p2p::frost_link_handler&& h);
-
-    void Publish(p2p::frost_message_ptr m);
-    void Send(const xonly_pubkey& pk, p2p::frost_message_ptr m);
-
-    void WaitForConfirmations();
-};
-
-
-}