diff --git a/.gitmodules b/.gitmodules
index 859e7637d8..e4ca16a9fe 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -33,7 +33,7 @@
 	url = https://github.com/AntelopeIO/CLI11.git
 [submodule "libraries/libfc/libraries/bls12-381"]
 	path = libraries/libfc/libraries/bls12-381
-	url = https://github.com/mschoenebeck/bls12-381.git
+	url = https://github.com/AntelopeIO/bls12-381
 [submodule "libraries/boost"]
 	path = libraries/boost
 	url = https://github.com/boostorg/boost.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a6532b4292..1521e0ec1f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -225,6 +225,7 @@ configure_file(libraries/libfc/include/fc/crypto/webauthn_json/license.txt licen
 configure_file(libraries/eos-vm/LICENSE                                    licenses/leap/LICENSE.eos-vm    COPYONLY)
 configure_file(libraries/prometheus/prometheus-cpp/LICENSE                 licenses/leap/LICENSE.prom      COPYONLY)
 configure_file(programs/cleos/LICENSE.CLI11                                licenses/leap/LICENSE.CLI11     COPYONLY)
+configure_file(libraries/libfc/libraries/bls12-381/LICENSE                 licenses/leap/LICENSE.bls12-381 COPYONLY)
 
 install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/licenses/leap" DESTINATION "${CMAKE_INSTALL_FULL_DATAROOTDIR}/licenses/" COMPONENT base)
 
diff --git a/CMakeModules/EosioTesterBuild.cmake.in b/CMakeModules/EosioTesterBuild.cmake.in
index 1ef5d2d695..209f0ec985 100644
--- a/CMakeModules/EosioTesterBuild.cmake.in
+++ b/CMakeModules/EosioTesterBuild.cmake.in
@@ -42,7 +42,7 @@ find_library(libchain eosio_chain @CMAKE_BINARY_DIR@/libraries/chain NO_DEFAULT_
 find_library(libfc fc @CMAKE_BINARY_DIR@/libraries/libfc NO_DEFAULT_PATH)
 find_library(libsecp256k1 secp256k1 @CMAKE_BINARY_DIR@/libraries/libfc/secp256k1 NO_DEFAULT_PATH)
 find_library(libbn256 bn256 @CMAKE_BINARY_DIR@/libraries/libfc/libraries/bn256/src NO_DEFAULT_PATH)
-find_library(libbls12-381 bls12-381 @CMAKE_BINARY_DIR@/libraries/libfc/libraries/bls12-381/src NO_DEFAULT_PATH)
+find_library(libbls12-381 bls12-381 @CMAKE_BINARY_DIR@/libraries/libfc/libraries/bls12-381 NO_DEFAULT_PATH)
 
 find_library(libwasm WASM @CMAKE_BINARY_DIR@/libraries/wasm-jit/Source/WASM NO_DEFAULT_PATH)
 find_library(libwast WAST @CMAKE_BINARY_DIR@/libraries/wasm-jit/Source/WAST NO_DEFAULT_PATH)
diff --git a/libraries/chain/controller.cpp b/libraries/chain/controller.cpp
index 5fb35a78d7..be604bffb6 100644
--- a/libraries/chain/controller.cpp
+++ b/libraries/chain/controller.cpp
@@ -34,7 +34,7 @@
 #include <fc/log/logger_config.hpp>
 #include <fc/scoped_exit.hpp>
 #include <fc/variant_object.hpp>
-#include <bls12-381.hpp>
+#include <bls12-381/bls12-381.hpp>
 
 #include <new>
 #include <shared_mutex>
@@ -340,7 +340,6 @@ struct controller_impl {
       set_activation_handler<builtin_protocol_feature_t::get_block_num>();
       set_activation_handler<builtin_protocol_feature_t::crypto_primitives>();
       set_activation_handler<builtin_protocol_feature_t::bls_primitives>();
-      bls12_381::init();
 
       self.irreversible_block.connect([this](const block_state_ptr& bsp) {
          wasm_if_collect.current_lib(bsp->block_num);
diff --git a/libraries/chain/webassembly/crypto.cpp b/libraries/chain/webassembly/crypto.cpp
index b2a05b5e1e..035bece57e 100644
--- a/libraries/chain/webassembly/crypto.cpp
+++ b/libraries/chain/webassembly/crypto.cpp
@@ -7,7 +7,7 @@
 #include <fc/crypto/sha3.hpp>
 #include <fc/crypto/k1_recover.hpp>
 #include <bn256/bn256.h>
-#include <bls12-381.hpp>
+#include <bls12-381/bls12-381.hpp>
 
 namespace {
     uint32_t ceil_log2(uint32_t n)
@@ -255,12 +255,12 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(op1.size() != 144 ||  op2.size() != 144 ||  result.size() != 144)
          return return_code::failure;
-      std::optional<bls12_381::g1> a = bls12_381::g1::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(op1.data()), 144}, false, true);
-      std::optional<bls12_381::g1> b = bls12_381::g1::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(op2.data()), 144}, false, true);
+      std::optional<bls12_381::g1> a = bls12_381::g1::fromJacobianBytesLE(std::span<const uint8_t, 144>((const uint8_t*)op1.data(), 144), false, true);
+      std::optional<bls12_381::g1> b = bls12_381::g1::fromJacobianBytesLE(std::span<const uint8_t, 144>((const uint8_t*)op2.data(), 144), false, true);
       if(!a.has_value() || !b.has_value())
          return return_code::failure;
       bls12_381::g1 c = a.value().add(b.value());
-      c.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 144}, true);
+      c.toJacobianBytesLE(std::span<uint8_t, 144>((uint8_t*)result.data(), 144), true);
       return return_code::success;
    }
 
@@ -268,12 +268,12 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(op1.size() != 288 ||  op2.size() != 288 ||  result.size() != 288)
          return return_code::failure;
-      std::optional<bls12_381::g2> a = bls12_381::g2::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(op1.data()), 288}, false, true);
-      std::optional<bls12_381::g2> b = bls12_381::g2::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(op2.data()), 288}, false, true);
+      std::optional<bls12_381::g2> a = bls12_381::g2::fromJacobianBytesLE(std::span<const uint8_t, 288>((const uint8_t*)op1.data(), 288), false, true);
+      std::optional<bls12_381::g2> b = bls12_381::g2::fromJacobianBytesLE(std::span<const uint8_t, 288>((const uint8_t*)op2.data(), 288), false, true);
       if(!a.has_value() || !b.has_value())
          return return_code::failure;
       bls12_381::g2 c = a.value().add(b.value());
-      c.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 288}, true);
+      c.toJacobianBytesLE(std::span<uint8_t, 288>((uint8_t*)result.data(), 288), true);
       return return_code::success;
    }
 
@@ -281,12 +281,12 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(point.size() != 144 ||  scalar.size() != 32 ||  result.size() != 144)
          return return_code::failure;
-      std::optional<bls12_381::g1> a = bls12_381::g1::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(point.data()), 144}, false, true);
+      std::optional<bls12_381::g1> a = bls12_381::g1::fromJacobianBytesLE(std::span<const uint8_t, 144>((const uint8_t*)point.data(), 144), false, true);
       if(!a.has_value())
          return return_code::failure;
-      std::array<uint64_t, 4> b = bls12_381::scalar::fromBytesLE<4>({reinterpret_cast<const uint8_t*>(scalar.data()), 32});
+      std::array<uint64_t, 4> b = bls12_381::scalar::fromBytesLE<4>(std::span<uint8_t, 32>((uint8_t*)scalar.data(), 32));
       bls12_381::g1 c = a.value().mulScalar(b);
-      c.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 144}, true);
+      c.toJacobianBytesLE(std::span<uint8_t, 144>((uint8_t*)result.data(), 144), true);
       return return_code::success;
    }
 
@@ -294,12 +294,12 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(point.size() != 288 ||  scalar.size() != 32 ||  result.size() != 288)
          return return_code::failure;
-      std::optional<bls12_381::g2> a = bls12_381::g2::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(point.data()), 288}, false, true);
+      std::optional<bls12_381::g2> a = bls12_381::g2::fromJacobianBytesLE(std::span<const uint8_t, 288>((const uint8_t*)point.data(), 288), false, true);
       if(!a.has_value())
          return return_code::failure;
-      std::array<uint64_t, 4> b = bls12_381::scalar::fromBytesLE<4>({reinterpret_cast<const uint8_t*>(scalar.data()), 32});
+      std::array<uint64_t, 4> b = bls12_381::scalar::fromBytesLE<4>(std::span<uint8_t, 32>((uint8_t*)scalar.data(), 32));
       bls12_381::g2 c = a.value().mulScalar(b);
-      c.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 288}, true);
+      c.toJacobianBytesLE(std::span<uint8_t, 288>((uint8_t*)result.data(), 288), true);
       return return_code::success;
    }
 
@@ -313,17 +313,17 @@ namespace eosio { namespace chain { namespace webassembly {
       sv.reserve(n);
       for(uint32_t i = 0; i < n; i++)
       {
-         std::optional<bls12_381::g1> p = bls12_381::g1::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(points.data() + i*144), 144}, false, true);
+         std::optional<bls12_381::g1> p = bls12_381::g1::fromJacobianBytesLE(std::span<const uint8_t, 144>((const uint8_t*)points.data() + i*144, 144), false, true);
          if(!p.has_value())
             return return_code::failure;
-         std::array<uint64_t, 4> s = bls12_381::scalar::fromBytesLE<4>({reinterpret_cast<const uint8_t*>(scalars.data() + i*32), 32});
+         std::array<uint64_t, 4> s = bls12_381::scalar::fromBytesLE<4>(std::span<const uint8_t, 32>((const uint8_t*)scalars.data() + i*32, 32));
          pv.push_back(p.value());
          sv.push_back(s);
          if(i%10 == 0)
             context.trx_context.checktime();
       }
       bls12_381::g1 r = bls12_381::g1::multiExp(pv, sv, [this](){ context.trx_context.checktime(); }).value(); // accessing value is safe
-      r.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 144}, true);
+      r.toJacobianBytesLE(std::span<uint8_t, 144>((uint8_t*)result.data(), 144), true);
       return return_code::success;
    }
 
@@ -337,17 +337,17 @@ namespace eosio { namespace chain { namespace webassembly {
       sv.reserve(n);
       for(uint32_t i = 0; i < n; i++)
       {
-         std::optional<bls12_381::g2> p = bls12_381::g2::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(points.data() + i*288), 288}, false, true);
+         std::optional<bls12_381::g2> p = bls12_381::g2::fromJacobianBytesLE(std::span<const uint8_t, 288>((const uint8_t*)points.data() + i*288, 288), false, true);
          if(!p.has_value())
             return return_code::failure;
-         std::array<uint64_t, 4> s = bls12_381::scalar::fromBytesLE<4>({reinterpret_cast<const uint8_t*>(scalars.data() + i*32), 32});
+         std::array<uint64_t, 4> s = bls12_381::scalar::fromBytesLE<4>(std::span<const uint8_t, 32>((const uint8_t*)scalars.data() + i*32, 32));
          pv.push_back(p.value());
          sv.push_back(s);
          if(i%6 == 0)
             context.trx_context.checktime();
       }
       bls12_381::g2 r = bls12_381::g2::multiExp(pv, sv, [this](){ context.trx_context.checktime(); }).value(); // accessing value is safe
-      r.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 288}, true);
+      r.toJacobianBytesLE(std::span<uint8_t, 288>((uint8_t*)result.data(), 288), true);
       return return_code::success;
    }
 
@@ -359,8 +359,8 @@ namespace eosio { namespace chain { namespace webassembly {
       v.reserve(n);
       for(uint32_t i = 0; i < n; i++)
       {
-         std::optional<bls12_381::g1> p_g1 = bls12_381::g1::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(g1_points.data() + i*144), 144}, true, true);
-         std::optional<bls12_381::g2> p_g2 = bls12_381::g2::fromJacobianBytesLE({reinterpret_cast<const uint8_t*>(g2_points.data() + i*288), 288}, true, true);
+         std::optional<bls12_381::g1> p_g1 = bls12_381::g1::fromJacobianBytesLE(std::span<const uint8_t, 144>((const uint8_t*)g1_points.data() + i*144, 144), true, true);
+         std::optional<bls12_381::g2> p_g2 = bls12_381::g2::fromJacobianBytesLE(std::span<const uint8_t, 288>((const uint8_t*)g2_points.data() + i*288, 288), true, true);
          if(!p_g1.has_value() || !p_g2.has_value())
             return return_code::failure;
          bls12_381::pairing::add_pair(v, p_g1.value(), p_g2.value());
@@ -368,7 +368,7 @@ namespace eosio { namespace chain { namespace webassembly {
             context.trx_context.checktime();
       }
       bls12_381::fp12 r = bls12_381::pairing::calculate(v, [this](){ context.trx_context.checktime(); });
-      r.toBytesLE({reinterpret_cast<uint8_t*>(result.data()), 576}, true);
+      r.toBytesLE(std::span<uint8_t, 576>((uint8_t*)result.data(), 576), true);
       return return_code::success;
    }
 
@@ -376,11 +376,11 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(e.size() != 48 ||  result.size() != 144)
          return return_code::failure;
-      std::optional<bls12_381::fp> a = bls12_381::fp::fromBytesLE({reinterpret_cast<const uint8_t*>(e.data()), 48}, true, true);
+      std::optional<bls12_381::fp> a = bls12_381::fp::fromBytesLE(std::span<const uint8_t, 48>((const uint8_t*)e.data(), 48), true, true);
       if(!a.has_value())
          return return_code::failure;
       bls12_381::g1 c = bls12_381::g1::mapToCurve(a.value());
-      c.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 144}, true);
+      c.toJacobianBytesLE(std::span<uint8_t, 144>((uint8_t*)result.data(), 144), true);
       return return_code::success;
    }
 
@@ -388,11 +388,11 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(e.size() != 96 ||  result.size() != 288)
          return return_code::failure;
-      std::optional<bls12_381::fp2> a = bls12_381::fp2::fromBytesLE({reinterpret_cast<const uint8_t*>(e.data()), 96}, true, true);
+      std::optional<bls12_381::fp2> a = bls12_381::fp2::fromBytesLE(std::span<const uint8_t, 96>((const uint8_t*)e.data(), 96), true, true);
       if(!a.has_value())
          return return_code::failure;
       bls12_381::g2 c = bls12_381::g2::mapToCurve(a.value());
-      c.toJacobianBytesLE({reinterpret_cast<uint8_t*>(result.data()), 288}, true);
+      c.toJacobianBytesLE(std::span<uint8_t, 288>((uint8_t*)result.data(), 288), true);
       return return_code::success;
    }
 
@@ -400,9 +400,9 @@ namespace eosio { namespace chain { namespace webassembly {
    {
       if(s.size() != 64 ||  result.size() != 48)
          return return_code::failure;
-      std::array<uint64_t, 8> k = bls12_381::scalar::fromBytesLE<8>({reinterpret_cast<const uint8_t*>(s.data()), 64});
+      std::array<uint64_t, 8> k = bls12_381::scalar::fromBytesLE<8>(std::span<const uint8_t, 64>((const uint8_t*)s.data(), 64));
       bls12_381::fp e = bls12_381::fp::modPrime<8>(k);
-      e.toBytesLE({reinterpret_cast<uint8_t*>(result.data()), 48}, true);
+      e.toBytesLE(std::span<uint8_t, 48>((uint8_t*)result.data(), 48), true);
       return return_code::success;
    }
 
diff --git a/libraries/libfc/CMakeLists.txt b/libraries/libfc/CMakeLists.txt
index d6291d5130..3975f2bd4d 100644
--- a/libraries/libfc/CMakeLists.txt
+++ b/libraries/libfc/CMakeLists.txt
@@ -126,3 +126,6 @@ install(TARGETS fc
    LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR} COMPONENT dev EXCLUDE_FROM_ALL
    ARCHIVE DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR} COMPONENT dev EXCLUDE_FROM_ALL)
 install(DIRECTORY include/fc DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR} COMPONENT dev EXCLUDE_FROM_ALL)
+
+install(TARGETS bls12-381 ARCHIVE       DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}"               COMPONENT dev EXCLUDE_FROM_ALL
+                          PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_FULL_INCLUDEDIR}/bls12-381" COMPONENT dev EXCLUDE_FROM_ALL)
diff --git a/libraries/libfc/libraries/bls12-381 b/libraries/libfc/libraries/bls12-381
index 82a137ecdc..a24734c86c 160000
--- a/libraries/libfc/libraries/bls12-381
+++ b/libraries/libfc/libraries/bls12-381
@@ -1 +1 @@
-Subproject commit 82a137ecdc010563a78673ddabf014dd0ec6ae77
+Subproject commit a24734c86cb61aa4e498181203d1fe054d9e99a0
diff --git a/libraries/libfc/test/crypto/test_bls.cpp b/libraries/libfc/test/crypto/test_bls.cpp
index 8d5fbbf538..569c2c4e91 100644
--- a/libraries/libfc/test/crypto/test_bls.cpp
+++ b/libraries/libfc/test/crypto/test_bls.cpp
@@ -1,6 +1,6 @@
 #include <boost/test/unit_test.hpp>
 
-#include <bls12-381.hpp>
+#include <bls12-381/bls12-381.hpp>
 #include <fc/exception/exception.hpp>
 
 using namespace std;
@@ -33,13 +33,13 @@ BOOST_AUTO_TEST_CASE(bls_serialization_test) try {
     g1 pk = public_key(sk);
     g2 signature = sign(sk, message_1);
 
-    string pk_string = bytesToHex<144>(pk.toJacobianBytesBE());
-    string signature_string = bytesToHex<288>(signature.toJacobianBytesBE());
-    cout << pk_string << std::endl;
-    cout << signature_string << std::endl;
+    const array<uint8_t, 144> pk_string = pk.toJacobianBytesBE();
+    const array<uint8_t, 288> signature_string = signature.toJacobianBytesBE();
+    cout << bytesToHex<144>(pk_string) <<  std::endl;
+    cout << bytesToHex<288>(signature_string) << std::endl;
 
-    g1 pk2 = g1::fromJacobianBytesBE(hexToBytes(pk_string)).value();
-    g2 signature2 = g2::fromJacobianBytesBE(hexToBytes(signature_string)).value();
+    g1 pk2 = g1::fromJacobianBytesBE(pk_string).value();
+    g2 signature2 = g2::fromJacobianBytesBE(signature_string).value();
     bool ok = verify(pk2, message_1, signature2);
     BOOST_CHECK_EQUAL(ok, true);
 } FC_LOG_AND_RETHROW();