diff --git a/libraries/fc b/libraries/fc
index 73a7f08f00..77fc2fe60d 160000
--- a/libraries/fc
+++ b/libraries/fc
@@ -1 +1 @@
-Subproject commit 73a7f08f00456b0984cd431dd8f55bd901282e15
+Subproject commit 77fc2fe60d762e49fe3a33398b1488ad24ac516d
diff --git a/libraries/protocol/CMakeLists.txt b/libraries/protocol/CMakeLists.txt
index 8d6b096e84..72f2b40b00 100644
--- a/libraries/protocol/CMakeLists.txt
+++ b/libraries/protocol/CMakeLists.txt
@@ -37,24 +37,18 @@ list(APPEND CUSTOM_AUTHS_FILES
      custom_authorities/create_predicate_fwd_1.cpp
      custom_authorities/create_predicate_fwd_2.cpp
      custom_authorities/create_predicate_fwd_3.cpp
-     custom_authorities/restriction_predicate.cpp
-     custom_authorities/list_1.cpp
-     custom_authorities/list_2.cpp
-     custom_authorities/list_3.cpp
-     custom_authorities/list_4.cpp
-     custom_authorities/list_5.cpp
-     custom_authorities/list_6.cpp
-     custom_authorities/list_7.cpp
-     custom_authorities/list_8.cpp
-     custom_authorities/list_9.cpp
-     custom_authorities/list_10.cpp
-     custom_authorities/list_11.cpp
-     custom_authorities/list_12.cpp)
+     custom_authorities/restriction_predicate.cpp)
+
+foreach(LIST_NUM RANGE 1 12)
+    configure_file("custom_authorities/list.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/custom_authorities/list_${LIST_NUM}.cpp")
+    list(APPEND CUSTOM_AUTHS_FILES "${CMAKE_CURRENT_BINARY_DIR}/custom_authorities/list_${LIST_NUM}.cpp")
+endforeach(LIST_NUM)
 
 file(GLOB CUSTOM_AUTHS_HEADERS "custom_authorities/*.hxx")
 
 add_library( graphene_protocol_custom_auths ${CUSTOM_AUTHS_FILES} ${CUSTOM_AUTHS_HEADERS} )
 target_link_libraries( graphene_protocol_custom_auths fc )
+target_include_directories(graphene_protocol_custom_auths PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/custom_authorities")
 target_include_directories( graphene_protocol_custom_auths PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )
 
 if( MSVC )
diff --git a/libraries/protocol/custom_authorities/list_1.cpp b/libraries/protocol/custom_authorities/list.cpp.in
similarity index 88%
rename from libraries/protocol/custom_authorities/list_1.cpp
rename to libraries/protocol/custom_authorities/list.cpp.in
index 7102fe2ecc..3416c9ebfc 100644
--- a/libraries/protocol/custom_authorities/list_1.cpp
+++ b/libraries/protocol/custom_authorities/list.cpp.in
@@ -28,8 +28,8 @@
 namespace graphene { namespace protocol {
 using result_type = object_restriction_predicate<operation>;
 
-result_type get_restriction_predicate_list_1(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_1::list(), idx, [&rs] (auto t) -> result_type {
+result_type get_restriction_predicate_list_${LIST_NUM}(size_t idx, vector<restriction> rs) {
+   return typelist::runtime::dispatch(operation_list_${LIST_NUM}::list(), idx, [&rs] (auto t) -> result_type {
       using Op = typename decltype(t)::type;
       return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
          FC_ASSERT(op.which() == operation::tag<Op>::value,
diff --git a/libraries/protocol/custom_authorities/list_10.cpp b/libraries/protocol/custom_authorities/list_10.cpp
deleted file mode 100644
index 6bcd0a9a10..0000000000
--- a/libraries/protocol/custom_authorities/list_10.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_10(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_10::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_11.cpp b/libraries/protocol/custom_authorities/list_11.cpp
deleted file mode 100644
index d626102113..0000000000
--- a/libraries/protocol/custom_authorities/list_11.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_11(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_11::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_12.cpp b/libraries/protocol/custom_authorities/list_12.cpp
deleted file mode 100644
index 9a4cee9c2f..0000000000
--- a/libraries/protocol/custom_authorities/list_12.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_12(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_12::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_2.cpp b/libraries/protocol/custom_authorities/list_2.cpp
deleted file mode 100644
index c42458dcf1..0000000000
--- a/libraries/protocol/custom_authorities/list_2.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_2(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_2::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_3.cpp b/libraries/protocol/custom_authorities/list_3.cpp
deleted file mode 100644
index 9158d6e003..0000000000
--- a/libraries/protocol/custom_authorities/list_3.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_3(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_3::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_4.cpp b/libraries/protocol/custom_authorities/list_4.cpp
deleted file mode 100644
index 2ff2fefb64..0000000000
--- a/libraries/protocol/custom_authorities/list_4.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_4(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_4::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_5.cpp b/libraries/protocol/custom_authorities/list_5.cpp
deleted file mode 100644
index a1b93b9a44..0000000000
--- a/libraries/protocol/custom_authorities/list_5.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_5(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_5::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_6.cpp b/libraries/protocol/custom_authorities/list_6.cpp
deleted file mode 100644
index e5d5962c0e..0000000000
--- a/libraries/protocol/custom_authorities/list_6.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_6(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_6::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_7.cpp b/libraries/protocol/custom_authorities/list_7.cpp
deleted file mode 100644
index 9ac5c1bfcc..0000000000
--- a/libraries/protocol/custom_authorities/list_7.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_7(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_7::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_8.cpp b/libraries/protocol/custom_authorities/list_8.cpp
deleted file mode 100644
index 32774e285b..0000000000
--- a/libraries/protocol/custom_authorities/list_8.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_8(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_8::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/list_9.cpp b/libraries/protocol/custom_authorities/list_9.cpp
deleted file mode 100644
index 27b2e069dd..0000000000
--- a/libraries/protocol/custom_authorities/list_9.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2019 Contributors.
- *
- * The MIT License
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "restriction_predicate.hxx"
-#include "sliced_lists.hxx"
-
-namespace graphene { namespace protocol {
-
-using result_type = object_restriction_predicate<operation>;
-
-result_type get_restriction_predicate_list_9(size_t idx, vector<restriction> rs) {
-   return typelist::runtime::dispatch(operation_list_9::list(), idx, [&rs] (auto t) -> result_type {
-      using Op = typename decltype(t)::type;
-      return [p=restrictions_to_predicate<Op>(std::move(rs), true)] (const operation& op) {
-         FC_ASSERT(op.which() == operation::tag<Op>::value,
-                   "Supplied operation is incorrect type for restriction predicate");
-         return p(op.get<Op>());
-      };
-   });
-}
-} }
diff --git a/libraries/protocol/custom_authorities/restriction_predicate.cpp b/libraries/protocol/custom_authorities/restriction_predicate.cpp
index 10cc57709a..3375572316 100644
--- a/libraries/protocol/custom_authorities/restriction_predicate.cpp
+++ b/libraries/protocol/custom_authorities/restriction_predicate.cpp
@@ -56,6 +56,8 @@ restriction_predicate_function get_restriction_predicate(vector<restriction> rs,
          return get_restriction_predicate_list_11(typelist::index_of<operation_list_11::list, Op>(), std::move(rs));
       if (typelist::contains<operation_list_12::list, Op>())
          return get_restriction_predicate_list_12(typelist::index_of<operation_list_12::list, Op>(), std::move(rs));
+      if (typelist::contains<unsupported_operations_list::list, Op>())
+         FC_THROW_EXCEPTION( fc::assert_exception, "Unsupported operation not allowed!" );
       if (typelist::contains<virtual_operations_list::list, Op>())
          FC_THROW_EXCEPTION( fc::assert_exception, "Virtual operations not allowed!" );
 
@@ -66,6 +68,7 @@ restriction_predicate_function get_restriction_predicate(vector<restriction> rs,
                                                         operation_list_7::list, operation_list_8::list,
                                                         operation_list_9::list, operation_list_10::list,
                                                         operation_list_11::list, operation_list_12::list,
+                                                        unsupported_operations_list::list,
                                                         virtual_operations_list::list>,
                                        Op>(), "");
       FC_THROW_EXCEPTION(fc::assert_exception,
diff --git a/libraries/protocol/custom_authorities/restriction_predicate.hxx b/libraries/protocol/custom_authorities/restriction_predicate.hxx
index 9d2757b787..0f35b2a4cf 100644
--- a/libraries/protocol/custom_authorities/restriction_predicate.hxx
+++ b/libraries/protocol/custom_authorities/restriction_predicate.hxx
@@ -23,6 +23,7 @@
  */
 
 #include <graphene/protocol/restriction_predicate.hpp>
+#include <graphene/protocol/fee_schedule.hpp>
 
 #include <fc/exception/exception.hpp>
 
@@ -50,7 +51,8 @@ template<typename T> constexpr static bool is_flat_set = is_flat_set_impl<T>::va
 // We use our own is_integral which does not consider bools integral (to disallow comparison between bool and ints)
 template<typename T> constexpr static bool is_integral = !std::is_same<T, bool>::value &&
                                                          !std::is_same<T, safe<bool>>::value &&
-                                                         (is_safe<T> || std::is_integral<T>::value);
+                                                         (is_safe<T> || std::is_integral<T>::value ||
+                                                          std::is_same<T, fc::unsigned_int>::value);
 
 // Metafunction to check if two types are comparable, which means not void_t, and either the same or both integral
 template<typename T, typename U>
@@ -60,10 +62,37 @@ constexpr static bool comparable_types = !std::is_same<T, void_t>::value &&
 // Metafunction to check if type is a container
 template<typename, typename = void>
 struct is_container_impl : std::false_type {};
+template<>
+struct is_container_impl<vector<char>> : std::false_type {};
 template<typename T>
 struct is_container_impl<T, make_void<typename T::value_type, decltype(declval<T>().size())>> : std::true_type {};
 template<typename T> constexpr static bool is_container = is_container_impl<T>::value;
 
+// Metafunction to check if type is string-like
+template<typename>
+struct is_stringish_impl : std::false_type {};
+template<>
+struct is_stringish_impl<std::string> : std::true_type {};
+template<>
+struct is_stringish_impl<std::vector<char>> : std::true_type {};
+template<>
+struct is_stringish_impl<fc::sha1> : std::true_type {};
+template<>
+struct is_stringish_impl<fc::sha256> : std::true_type {};
+template<>
+struct is_stringish_impl<fc::ripemd160> : std::true_type {};
+template<>
+struct is_stringish_impl<fc::hash160> : std::true_type {};
+template<typename T> constexpr static bool is_stringish = is_stringish_impl<T>::value;
+
+// Convert stringish types to strings
+inline const string& to_string(const string& str) { return str; }
+inline string to_string(const std::vector<char>& vec) { return string(vec.begin(), vec.end()); }
+inline string to_string(const fc::sha1& hash) { return hash.str(); }
+inline string to_string(const fc::sha256& hash) { return hash.str(); }
+inline string to_string(const fc::ripemd160& hash) { return hash.str(); }
+inline string to_string(const fc::hash160& hash) { return hash.str(); }
+
 // Type alias for a predicate on a particular field type
 template<typename Field>
 using object_restriction_predicate = std::function<predicate_result(const Field&)>;
@@ -74,6 +103,7 @@ const auto& to_num(const I& i) { return i; }
 template<typename I>
 const auto& to_num(const fc::safe<I>& i) { return i.value; }
 inline auto to_num(const fc::time_point_sec& t) { return t.sec_since_epoch(); }
+inline auto to_num(const fc::unsigned_int& ui) { return ui.value; }
 
 namespace safenum = boost::safe_numerics::safe_compare;
 
@@ -163,12 +193,34 @@ struct predicate_eq<Field, Argument, std::enable_if_t<is_integral<Field> && is_i
    constexpr bool operator()(const Field& f, const Argument& a) const { return safenum::equal(to_num(f), to_num(a)); }
 };
 template<typename Field, typename Argument>
+struct predicate_eq<Field, Argument, std::enable_if_t<is_stringish<Field> && is_stringish<Argument> &&
+                                                      !std::is_same<Field, Argument>::value>> {
+   // Converting comparison, stringish types
+   constexpr static bool valid = true;
+   bool operator()(const Field& f, const Argument& a) const { return to_string(f) == to_string(a); }
+};
+template<typename Field, typename Argument>
 struct predicate_eq<Field, Argument, std::enable_if_t<is_container<Field> && is_integral<Argument>>> {
    // Compare container size against int
    constexpr static bool valid = true;
    bool operator()(const Field& f, const Argument& a) const { return safenum::equal(f.size(), to_num(a)); }
 };
 template<typename Field, typename Argument>
+struct predicate_eq<Field, Argument, std::enable_if_t<is_stringish<Field> && !is_container<Field>
+                                                      && is_integral<Argument>>> {
+   // Compare stringish size against int
+   constexpr static bool valid = true;
+   bool operator()(const Field& f, const Argument& a) const { return safenum::equal(to_string(f).size(), to_num(a)); }
+};
+template<typename... Ts, typename Argument>
+struct predicate_eq<static_variant<Ts...>, Argument, std::enable_if_t<is_integral<Argument>>> {
+   // Compare static_variant.which() against int
+   constexpr static bool valid = true;
+   bool operator()(const static_variant<Ts...>& f, const Argument& a) const {
+      return safenum::equal(f.which(), to_num(a));
+   }
+};
+template<typename Field, typename Argument>
 struct predicate_eq<fc::optional<Field>, Argument, std::enable_if_t<comparable_types<Field, Argument>>>
    : predicate_eq<Field, Argument> {
    // Compare optional value against comparable type
@@ -197,7 +249,7 @@ struct predicate_compare<Field, Argument, std::enable_if_t<std::is_same<Field, A
    // Simple comparison, same types
    constexpr static bool valid = true;
    constexpr int8_t operator()(const Field& f, const Argument& a) const {
-      return f<a? -1 : (f>a? 1 : 0);
+      return f<a? -1 : (a<f? 1 : 0);
    }
 };
 template<typename Field, typename Argument>
@@ -212,6 +264,42 @@ struct predicate_compare<Field, Argument, std::enable_if_t<is_integral<Field> &&
    }
 };
 template<typename Field, typename Argument>
+struct predicate_compare<Field, Argument, std::enable_if_t<is_stringish<Field> && is_stringish<Argument> &&
+                                                           !std::is_same<Field, Argument>::value>> {
+   // Converting comparison, stringish types
+   constexpr static bool valid = true;
+   constexpr int8_t operator()(const Field& f, const Argument& a) const {
+      auto sf = to_string(f);
+      auto sa = to_string(a);
+      return sf < sa? -1 : (sa < sf? 1 : 0);
+   }
+};
+template<typename Field, typename Argument>
+struct predicate_compare<Field, Argument, std::enable_if_t<is_container<Field> && is_integral<Argument>>>
+      : public predicate_compare<size_t, Argument> {
+   // Compare container size against int
+   using base = predicate_compare<size_t, Argument>;
+   constexpr static bool valid = true;
+   bool operator()(const Field& f, const Argument& a) const { return base::operator()(f.size(), a); }
+};
+template<typename Field, typename Argument>
+struct predicate_compare<Field, Argument, std::enable_if_t<is_stringish<Field> && !is_container<Field>
+                                                           && is_integral<Argument>>>
+      : public predicate_compare<size_t, Argument> {
+   // Compare stringish size against int
+   using base = predicate_compare<size_t, Argument>;
+   constexpr static bool valid = true;
+   bool operator()(const Field& f, const Argument& a) const { return base::operator()(to_string(f).size(), a); }
+};
+template<typename... Ts, typename Argument>
+struct predicate_compare<static_variant<Ts...>, Argument, std::enable_if_t<is_integral<Argument>>>
+      : public predicate_compare<size_t, Argument> {
+   // Compare static_variant.which() against int
+   using base = predicate_compare<size_t, Argument>;
+   constexpr static bool valid = true;
+   bool operator()(const static_variant<Ts...>& f, const Argument& a) const { return base::operator()(f.which(), a); }
+};
+template<typename Field, typename Argument>
 struct predicate_compare<fc::optional<Field>, Argument, void> : predicate_compare<Field, Argument> {
    // Compare optional value against comparable type
    constexpr static bool valid = true;
@@ -397,6 +485,14 @@ struct attribute_assertion<extension<Extension>> {
       };
    }
 };
+template<typename Pointed>
+struct attribute_assertion<std::shared_ptr<Pointed>> {
+   static object_restriction_predicate<std::shared_ptr<Pointed>> create(vector<restriction>&& rs) {
+      return [p=restrictions_to_predicate<Pointed>(std::move(rs), false)](const shared_ptr<Pointed>& x) {
+         return p(*x);
+      };
+   }
+};
 
 template<typename Variant>
 struct variant_assertion {
@@ -465,8 +561,59 @@ object_restriction_predicate<Field> make_predicate(ArgVariant arg) {
    });
 }
 
+// A template checking whether a predicate is valid with the provided field type and any restriction argument type
+template<typename Field, typename = void>
+struct predicate_is_valid_for_field {
+   template<typename Predicate>
+   struct filter {
+      template<typename Argument>
+      struct argument_filter {
+         constexpr static bool value = Predicate::template unwrap<Field, Argument>::valid;
+      };
+
+      constexpr static bool value = typelist::any<restriction::argument_type::list, argument_filter>;
+   };
+};
+// Specialization for reflected struct fields; they are always valid because we can use an attribute_assert on them
+template<typename Struct>
+struct predicate_is_valid_for_field<Struct, std::enable_if_t<fc::reflector<Struct>::is_defined::value>> {
+   template<typename>
+   struct filter { constexpr static bool value = true; };
+};
+// Specialization for extension fields; they are always valid because we can use an attribute_assert on them
+template<typename Ext>
+struct predicate_is_valid_for_field<extension<Ext>, void> {
+   template<typename>
+   struct filter { constexpr static bool value = true; };
+};
+// Specialization for static variant fields; they are always valid because we can use a variant_assert on them
+template<typename... Ts>
+struct predicate_is_valid_for_field<static_variant<Ts...>, void> {
+   template<typename>
+   struct filter { constexpr static bool value = true; };
+};
+// Specialization for shared_ptr fields; they are valid if the thing pointed to is
+template<typename Pointed>
+struct predicate_is_valid_for_field<std::shared_ptr<Pointed>, void>
+      : public predicate_is_valid_for_field<std::decay_t<Pointed>> {};
+
+// Check if any predicate can be used with the provided field type and any known argument type
+template<typename Field>
+constexpr bool any_predicate_applies() {
+   using PredicateTypes = typelist::list<typelist::wrapped<predicate_eq>, typelist::wrapped<predicate_ne>,
+                                         typelist::wrapped<predicate_lt>, typelist::wrapped<predicate_le>,
+                                         typelist::wrapped<predicate_gt>, typelist::wrapped<predicate_ge>,
+                                         typelist::wrapped<predicate_in>, typelist::wrapped<predicate_not_in>,
+                                         typelist::wrapped<predicate_has_all>, typelist::wrapped<predicate_has_none>>;
+   return typelist::any<PredicateTypes, predicate_is_valid_for_field<Field>::template filter>;
+}
+
 template<typename Field>
 object_restriction_predicate<Field> create_predicate_function(restriction_function func, restriction_argument arg) {
+   // This checks that all fields of all objects can be used with at least one predicate
+   static_assert(any_predicate_applies<Field>(),
+                 "This new field type is not yet supported by Custom Active Authorities. Please add support for it.");
+
    try {
       switch(func) {
       case restriction::func_eq:
@@ -539,7 +686,7 @@ object_restriction_predicate<Object> create_field_predicate(restriction&& r, sho
 template<typename Object>
 object_restriction_predicate<Object> create_field_predicate(restriction&&, long) {
    FC_THROW_EXCEPTION(fc::assert_exception, "Invalid restriction references member of non-object type: ${O}",
-                      ("O", fc::get_typename<Object>::name()));
+                      ("O", fc::get_typename<std::decay_t<Object>>::name()));
 }
 
 template<typename Object>
diff --git a/libraries/protocol/custom_authorities/sliced_lists.hxx b/libraries/protocol/custom_authorities/sliced_lists.hxx
index f26b3b77ef..d1ffbfb70c 100644
--- a/libraries/protocol/custom_authorities/sliced_lists.hxx
+++ b/libraries/protocol/custom_authorities/sliced_lists.hxx
@@ -32,21 +32,58 @@ namespace typelist = fc::typelist;
 // To make the build gentler on RAM, break the operation list into several pieces to build over several files
 using operation_list_1 = static_variant<typelist::slice<operation::list, 0, 4>>;
 using operation_list_2 = static_variant<typelist::slice<operation::list, 5, 9>>;
-using operation_list_3 = static_variant<typelist::slice<operation::list, 9, 11>>;
+static_assert(typelist::index_of<operation::list, account_transfer_operation>() == 9,
+              "Custom Active Authorities do not support account_transfer_operation");
+using operation_list_3 = static_variant<typelist::slice<operation::list, 10, 11>>;
 using operation_list_4 = static_variant<typelist::slice<operation::list, 11, 12>>;
 using operation_list_5 = static_variant<typelist::slice<operation::list, 12, 15>>;
 using operation_list_6 = static_variant<typelist::slice<operation::list, 15, 22>>;
 using operation_list_7 = static_variant<typelist::slice<operation::list, 22, 29>>;
-using operation_list_8 = static_variant<typelist::slice<operation::list, 29, 32>>;
+using operation_list_8 = static_variant<typelist::slice<operation::list, 29, 31>>;
+static_assert(typelist::index_of<operation::list, committee_member_update_global_parameters_operation>() == 31,
+              "Custom Active Authorities do not support committee_member_update_global_parameters_operation");
 using operation_list_9 = static_variant<typelist::slice<operation::list, 32, 35>>;
-using operation_list_10 = static_variant<typelist::slice<operation::list, 35, 42>>;
+using operation_list_10 = static_variant<typelist::slice<operation::list, 35, 40>>;
+static_assert(typelist::index_of<operation::list, blind_transfer_operation>() == 40,
+              "Custom Active Authorities do not support blind_transfer_operation");
+static_assert(typelist::index_of<operation::list, transfer_from_blind_operation>() == 41,
+              "Custom Active Authorities do not support transfer_from_blind_operation");
+static_assert(typelist::index_of<operation::list, asset_settle_cancel_operation>() == 42,
+              "Custom Active Authorities do not support asset_settle_cancel_operation");
 using operation_list_11 = static_variant<typelist::builder<>
                                                 ::add<asset_claim_fees_operation> // 43
                                                 ::add<bid_collateral_operation>   // 45
-                                                ::add_list<typelist::slice<operation::list, 47, 51>>
+                                                ::add<asset_claim_pool_operation> // 47
+                                                ::add<htlc_create_operation>      // 49
+                                                ::add<htlc_redeem_operation>      // 50
                                                 ::add<htlc_extend_operation>      // 52
                                                 ::finalize>;
-using operation_list_12 = static_variant<typelist::slice<operation::list, 54>>;
+static_assert(typelist::index_of<operation::list, fba_distribute_operation>() == 44,
+              "Custom Active Authorities do not support fba_distribute_operation");
+static_assert(typelist::index_of<operation::list, execute_bid_operation>() == 46,
+              "Custom Active Authorities do not support execute_bid_operation");
+static_assert(typelist::index_of<operation::list, asset_update_issuer_operation>() == 48,
+              "Custom Active Authorities do not support asset_update_issuer_operation");
+static_assert(typelist::index_of<operation::list, htlc_redeemed_operation>() == 51,
+              "Custom Active Authorities do not support htlc_redeemed_operation");
+static_assert(typelist::index_of<operation::list, htlc_refund_operation>() == 53,
+              "Custom Active Authorities do not support htlc_refund_operation");
+static_assert(typelist::index_of<operation::list, custom_authority_create_operation>() == 54,
+              "Custom Active Authorities do not support custom_authority_create_operation");
+static_assert(typelist::index_of<operation::list, custom_authority_update_operation>() == 55,
+              "Custom Active Authorities do not support custom_authority_update_operation");
+static_assert(typelist::index_of<operation::list, custom_authority_delete_operation>() == 56,
+              "Custom Active Authorities do not support custom_authority_delete_operation");
+using operation_list_12 = static_variant<typelist::slice<operation::list, 57>>;
+using unsupported_operations_list = static_variant<account_transfer_operation, // 9
+                                                   committee_member_update_global_parameters_operation, // 31
+                                                   blind_transfer_operation, // 40
+                                                   transfer_from_blind_operation, // 41
+                                                   asset_update_issuer_operation,  // 49
+                                                   custom_authority_create_operation, // 54
+                                                   custom_authority_update_operation, // 55
+                                                   custom_authority_delete_operation  // 56
+                                                  >;
 using virtual_operations_list = static_variant<fill_order_operation,          // 4
                                                asset_settle_cancel_operation, // 42
                                                fba_distribute_operation,      // 44
diff --git a/libraries/protocol/custom_authority.cpp b/libraries/protocol/custom_authority.cpp
index f7217d01f2..1a7bc54f4d 100644
--- a/libraries/protocol/custom_authority.cpp
+++ b/libraries/protocol/custom_authority.cpp
@@ -98,3 +98,10 @@ void custom_authority_delete_operation::validate()const {
 }
 
 } } // graphene::protocol
+
+GRAPHENE_IMPLEMENT_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_create_operation::fee_parameters_type)
+GRAPHENE_IMPLEMENT_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_update_operation::fee_parameters_type)
+GRAPHENE_IMPLEMENT_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_delete_operation::fee_parameters_type)
+GRAPHENE_IMPLEMENT_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_create_operation)
+GRAPHENE_IMPLEMENT_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_update_operation)
+GRAPHENE_IMPLEMENT_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_delete_operation)
diff --git a/libraries/protocol/include/graphene/protocol/custom_authority.hpp b/libraries/protocol/include/graphene/protocol/custom_authority.hpp
index 7448c84aee..ead0c5597e 100644
--- a/libraries/protocol/include/graphene/protocol/custom_authority.hpp
+++ b/libraries/protocol/include/graphene/protocol/custom_authority.hpp
@@ -134,3 +134,10 @@ FC_REFLECT(graphene::protocol::custom_authority_update_operation,
            (fee)(account)(authority_to_update)(new_enabled)(new_valid_from)
            (new_valid_to)(new_auth)(restrictions_to_remove)(restrictions_to_add)(extensions))
 FC_REFLECT(graphene::protocol::custom_authority_delete_operation, (fee)(account)(authority_to_delete)(extensions))
+
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_create_operation::fee_parameters_type)
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_update_operation::fee_parameters_type)
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_delete_operation::fee_parameters_type)
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_create_operation)
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_update_operation)
+GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(graphene::protocol::custom_authority_delete_operation)
diff --git a/libraries/protocol/include/graphene/protocol/restriction.hpp b/libraries/protocol/include/graphene/protocol/restriction.hpp
index 334cf63b03..c77e0b8495 100644
--- a/libraries/protocol/include/graphene/protocol/restriction.hpp
+++ b/libraries/protocol/include/graphene/protocol/restriction.hpp
@@ -59,19 +59,19 @@ struct restriction {
    /*  3 */ string, \
    /*  4 */ time_point_sec, \
    /*  5 */ public_key_type, \
-   /*  6 */ fc::sha256, \
-   /*  7 */ account_id_type, \
-   /*  8 */ asset_id_type, \
-   /*  9 */ force_settlement_id_type, \
-   /* 10 */ committee_member_id_type, \
-   /* 11 */ witness_id_type, \
-   /* 12 */ limit_order_id_type, \
-   /* 13 */ call_order_id_type, \
-   /* 14 */ custom_id_type, \
-   /* 15 */ proposal_id_type, \
-   /* 16 */ withdraw_permission_id_type, \
-   /* 17 */ vesting_balance_id_type, \
-   /* 18 */ worker_id_type, \
+   /*  6 */ fc::sha1, \
+   /*  7 */ fc::sha256, \
+   /*  8 */ fc::ripemd160, \
+   /*  9 */ fc::hash160, \
+   /* 10 */ account_id_type, \
+   /* 11 */ asset_id_type, \
+   /* 12 */ htlc_id_type, \
+   /* 13 */ committee_member_id_type, \
+   /* 14 */ witness_id_type, \
+   /* 15 */ limit_order_id_type, \
+   /* 16 */ proposal_id_type, \
+   /* 17 */ withdraw_permission_id_type, \
+   /* 18 */ vesting_balance_id_type, \
    /* 19 */ balance_id_type, \
    /* 20 */ flat_set<bool>, \
    /* 21 */ flat_set<int64_t>, \
@@ -81,20 +81,17 @@ struct restriction {
    /* 25 */ flat_set<fc::sha256>, \
    /* 26 */ flat_set<account_id_type>, \
    /* 27 */ flat_set<asset_id_type>, \
-   /* 28 */ flat_set<force_settlement_id_type>, \
+   /* 28 */ flat_set<htlc_id_type>, \
    /* 29 */ flat_set<committee_member_id_type>, \
    /* 30 */ flat_set<witness_id_type>, \
    /* 31 */ flat_set<limit_order_id_type>, \
-   /* 32 */ flat_set<call_order_id_type>, \
-   /* 33 */ flat_set<custom_id_type>, \
-   /* 34 */ flat_set<proposal_id_type>, \
-   /* 35 */ flat_set<withdraw_permission_id_type>, \
-   /* 36 */ flat_set<vesting_balance_id_type>, \
-   /* 37 */ flat_set<worker_id_type>, \
-   /* 38 */ flat_set<balance_id_type>, \
-   /* 39 */ vector<restriction>, \
-   /* 40 */ vector<vector<restriction>>, \
-   /* 41 */ variant_assert_argument_type
+   /* 32 */ flat_set<proposal_id_type>, \
+   /* 33 */ flat_set<withdraw_permission_id_type>, \
+   /* 34 */ flat_set<vesting_balance_id_type>, \
+   /* 35 */ flat_set<balance_id_type>, \
+   /* 36 */ vector<restriction>, \
+   /* 37 */ vector<vector<restriction>>, \
+   /* 38 */ variant_assert_argument_type
 
    using argument_type = fc::static_variant<GRAPHENE_OP_RESTRICTION_ARGUMENTS_VARIADIC>;