vendor: use BLS-12_384 curve and update dependencies (#356)

18 files changed, 2420 insertions, 6 deletions

diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/App.config b/vendor/github.com/dexon-foundation/bls/ffi/cs/App.config
new file mode 100644
index 000000000..8d234373a
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/App.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/>
+    </startup>
+</configuration>
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/Properties/AssemblyInfo.cs b/vendor/github.com/dexon-foundation/bls/ffi/cs/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..201222c55
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// アセンブリに関する一般情報は以下の属性セットをとおして制御されます。
+// アセンブリに関連付けられている情報を変更するには、
+// これらの属性値を変更してください。
+[assembly: AssemblyTitle("bls256")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("bls256")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// ComVisible を false に設定すると、その型はこのアセンブリ内で COM コンポーネントから
+// 参照不可能になります。COM からこのアセンブリ内の型にアクセスする場合は、
+// その型の ComVisible 属性を true に設定してください。
+[assembly: ComVisible(false)]
+
+// このプロジェクトが COM に公開される場合、次の GUID が typelib の ID になります
+[assembly: Guid("e9d06b1b-ea22-4ef4-ba4b-422f7625966c")]
+
+// アセンブリのバージョン情報は次の 4 つの値で構成されています:
+//
+//      メジャー バージョン
+//      マイナー バージョン
+//      ビルド番号
+//      Revision
+//
+// すべての値を指定するか、下のように '*' を使ってビルドおよびリビジョン番号を
+// 既定値にすることができます:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.cs b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.cs
new file mode 100644
index 000000000..6bcaf07fb
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.cs
@@ -0,0 +1,351 @@
+����using System;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace mcl
+{
+    class BLS
+    {
+        public const int BN254 = 0;
+        public const int BLS12_381 = 5;
+
+        const int IoEcComp = 512; // fixed byte representation
+        public const int FR_UNIT_SIZE = 4;
+        public const int FP_UNIT_SIZE = 6; // 4 if bls256.dll is used
+        public const int COMPILED_TIME_VAR = FR_UNIT_SIZE * 10 + FP_UNIT_SIZE;
+
+        public const int ID_UNIT_SIZE = FR_UNIT_SIZE;
+        public const int SECRETKEY_UNIT_SIZE = FR_UNIT_SIZE;
+        public const int PUBLICKEY_UNIT_SIZE = FP_UNIT_SIZE * 3 * 2;
+        public const int SIGNATURE_UNIT_SIZE = FP_UNIT_SIZE * 3;
+
+        public const int ID_SERIALIZE_SIZE = FR_UNIT_SIZE * 8;
+        public const int SECRETKEY_SERIALIZE_SIZE = FR_UNIT_SIZE * 8;
+        public const int PUBLICKEY_SERIALIZE_SIZE = FP_UNIT_SIZE * 8 * 2;
+        public const int SIGNATURE_SERIALIZE_SIZE = FP_UNIT_SIZE * 8;
+
+        public const string dllName = FP_UNIT_SIZE == 4 ? "bls256.dll" : "bls384_256.dll";
+        [DllImport(dllName)]
+        public static extern int blsInit(int curveType, int compiledTimeVar);
+
+        [DllImport(dllName)] public static extern void blsIdSetInt(ref Id id, int x);
+        [DllImport(dllName)] public static extern int blsIdSetDecStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        [DllImport(dllName)] public static extern int blsIdSetHexStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        [DllImport(dllName)] public static extern ulong blsIdGetDecStr([Out]StringBuilder buf, ulong maxBufSize, in Id id);
+        [DllImport(dllName)] public static extern ulong blsIdGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in Id id);
+
+        [DllImport(dllName)] public static extern ulong blsIdSerialize([Out]byte[] buf, ulong maxBufSize, in Id id);
+        [DllImport(dllName)] public static extern ulong blsSecretKeySerialize([Out]byte[] buf, ulong maxBufSize, in SecretKey sec);
+        [DllImport(dllName)] public static extern ulong blsPublicKeySerialize([Out]byte[] buf, ulong maxBufSize, in PublicKey pub);
+        [DllImport(dllName)] public static extern ulong blsSignatureSerialize([Out]byte[] buf, ulong maxBufSize, in Signature sig);
+        [DllImport(dllName)] public static extern ulong blsIdDeserialize(ref Id id, [In]byte[] buf, ulong bufSize);
+        [DllImport(dllName)] public static extern ulong blsSecretKeyDeserialize(ref SecretKey sec, [In]byte[] buf, ulong bufSize);
+        [DllImport(dllName)] public static extern ulong blsPublicKeyDeserialize(ref PublicKey pub, [In]byte[] buf, ulong bufSize);
+        [DllImport(dllName)] public static extern ulong blsSignatureDeserialize(ref Signature sig, [In]byte[] buf, ulong bufSize);
+
+        [DllImport(dllName)] public static extern int blsIdIsEqual(in Id lhs, in Id rhs);
+        [DllImport(dllName)] public static extern int blsSecretKeyIsEqual(in SecretKey lhs, in SecretKey rhs);
+        [DllImport(dllName)] public static extern int blsPublicKeyIsEqual(in PublicKey lhs, in PublicKey rhs);
+        [DllImport(dllName)] public static extern int blsSignatureIsEqual(in Signature lhs, in Signature rhs);
+        // add
+        [DllImport(dllName)] public static extern void blsSecretKeyAdd(ref SecretKey sec, in SecretKey rhs);
+        [DllImport(dllName)] public static extern void blsPublicKeyAdd(ref PublicKey pub, in PublicKey rhs);
+        [DllImport(dllName)] public static extern void blsSignatureAdd(ref Signature sig, in Signature rhs);
+        //	hash buf and set
+        [DllImport(dllName)] public static extern int blsHashToSecretKey(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        /*
+			set secretKey if system has /dev/urandom or CryptGenRandom
+			return 0 if success else -1
+		*/
+        [DllImport(dllName)] public static extern int blsSecretKeySetByCSPRNG(ref SecretKey sec);
+
+        [DllImport(dllName)] public static extern void blsGetPublicKey(ref PublicKey pub, in SecretKey sec);
+        [DllImport(dllName)] public static extern void blsGetPop(ref Signature sig, in SecretKey sec);
+
+        // return 0 if success
+        [DllImport(dllName)] public static extern int blsSecretKeyShare(ref SecretKey sec, in SecretKey msk, ulong k, in Id id);
+        [DllImport(dllName)] public static extern int blsPublicKeyShare(ref PublicKey pub, in PublicKey mpk, ulong k, in Id id);
+
+
+        [DllImport(dllName)] public static extern int blsSecretKeyRecover(ref SecretKey sec, in SecretKey secVec, in Id idVec, ulong n);
+        [DllImport(dllName)] public static extern int blsPublicKeyRecover(ref PublicKey pub, in PublicKey pubVec, in Id idVec, ulong n);
+        [DllImport(dllName)] public static extern int blsSignatureRecover(ref Signature sig, in Signature sigVec, in Id idVec, ulong n);
+
+        [DllImport(dllName)] public static extern void blsSign(ref Signature sig, in SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);
+
+        // return 1 if valid
+        [DllImport(dllName)] public static extern int blsVerify(in Signature sig, in PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);
+        [DllImport(dllName)] public static extern int blsVerifyPop(in Signature sig, in PublicKey pub);
+
+        //////////////////////////////////////////////////////////////////////////
+        // the following apis will be removed
+
+        // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r
+        [DllImport(dllName)] public static extern int blsIdSetLittleEndian(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        /*
+			return written byte size if success else 0
+		*/
+        [DllImport(dllName)] public static extern ulong blsIdGetLittleEndian([Out]StringBuilder buf, ulong maxBufSize, in Id id);
+
+        // return 0 if success
+        // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r
+        [DllImport(dllName)] public static extern int blsSecretKeySetLittleEndian(ref SecretKey sec, [In]byte[] buf, ulong bufSize);
+        [DllImport(dllName)] public static extern int blsSecretKeySetDecStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        [DllImport(dllName)] public static extern int blsSecretKeySetHexStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        /*
+			return written byte size if success else 0
+		*/
+        [DllImport(dllName)] public static extern ulong blsSecretKeyGetLittleEndian([Out]byte[] buf, ulong maxBufSize, in SecretKey sec);
+        /*
+			return strlen(buf) if success else 0
+			buf is '\0' terminated
+		*/
+        [DllImport(dllName)] public static extern ulong blsSecretKeyGetDecStr([Out]StringBuilder buf, ulong maxBufSize, in SecretKey sec);
+        [DllImport(dllName)] public static extern ulong blsSecretKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in SecretKey sec);
+        [DllImport(dllName)] public static extern int blsPublicKeySetHexStr(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        [DllImport(dllName)] public static extern ulong blsPublicKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in PublicKey pub);
+        [DllImport(dllName)] public static extern int blsSignatureSetHexStr(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+        [DllImport(dllName)] public static extern ulong blsSignatureGetHexStr([Out]StringBuilder buf, ulong maxBufSize, in Signature sig);
+
+        public static void Init(int curveType = BN254) {
+            if (!System.Environment.Is64BitProcess) {
+                throw new PlatformNotSupportedException("not 64-bit system");
+            }
+            int err = blsInit(curveType, COMPILED_TIME_VAR);
+            if (err != 0) {
+                throw new ArgumentException("blsInit");
+            }
+        }
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct Id
+        {
+            private fixed ulong v[ID_UNIT_SIZE];
+            public byte[] Serialize() {
+                byte[] buf = new byte[ID_SERIALIZE_SIZE];
+                ulong n = blsIdSerialize(buf, (ulong)buf.Length, this);
+                if (n == 0) {
+                    throw new ArithmeticException("blsIdSerialize");
+                }
+                return buf;
+            }
+            public void Deserialize(byte[] buf) {
+                ulong n = blsIdDeserialize(ref this, buf, (ulong)buf.Length);
+                if (n == 0) {
+                    throw new ArithmeticException("blsIdDeserialize");
+                }
+            }
+            public bool IsEqual(in Id rhs) {
+                return blsIdIsEqual(this, rhs) != 0;
+            }
+            public void SetDecStr(string s) {
+                if (blsIdSetDecStr(ref this, s, (ulong)s.Length) != 0) {
+                    throw new ArgumentException("blsIdSetDecSt:" + s);
+                }
+            }
+            public void SetHexStr(string s) {
+                if (blsIdSetHexStr(ref this, s, (ulong)s.Length) != 0) {
+                    throw new ArgumentException("blsIdSetHexStr:" + s);
+                }
+            }
+            public void SetInt(int x) {
+                blsIdSetInt(ref this, x);
+            }
+            public string GetDecStr() {
+                StringBuilder sb = new StringBuilder(1024);
+                ulong size = blsIdGetDecStr(sb, (ulong)sb.Capacity, this);
+                if (size == 0) {
+                    throw new ArgumentException("blsIdGetDecStr");
+                }
+                return sb.ToString(0, (int)size);
+            }
+            public string GetHexStr() {
+                StringBuilder sb = new StringBuilder(1024);
+                ulong size = blsIdGetHexStr(sb, (ulong)sb.Capacity, this);
+                if (size == 0) {
+                    throw new ArgumentException("blsIdGetHexStr");
+                }
+                return sb.ToString(0, (int)size);
+            }
+        }
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct SecretKey
+        {
+            private fixed ulong v[SECRETKEY_UNIT_SIZE];
+            public byte[] Serialize() {
+                byte[] buf = new byte[SECRETKEY_SERIALIZE_SIZE];
+                ulong n = blsSecretKeySerialize(buf, (ulong)buf.Length, this);
+                if (n == 0) {
+                    throw new ArithmeticException("blsSecretKeySerialize");
+                }
+                return buf;
+            }
+            public void Deserialize(byte[] buf) {
+                ulong n = blsSecretKeyDeserialize(ref this, buf, (ulong)buf.Length);
+                if (n == 0) {
+                    throw new ArithmeticException("blsSecretKeyDeserialize");
+                }
+            }
+            public bool IsEqual(in SecretKey rhs) {
+                return blsSecretKeyIsEqual(this, rhs) != 0;
+            }
+            public void SetHexStr(string s) {
+                if (blsSecretKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {
+                    throw new ArgumentException("blsSecretKeySetHexStr:" + s);
+                }
+            }
+            public string GetHexStr() {
+                StringBuilder sb = new StringBuilder(1024);
+                ulong size = blsSecretKeyGetHexStr(sb, (ulong)sb.Capacity, this);
+                if (size == 0) {
+                    throw new ArgumentException("mclBnFr_getStr");
+                }
+                return sb.ToString(0, (int)size);
+            }
+            public void Add(in SecretKey rhs) {
+                blsSecretKeyAdd(ref this, rhs);
+            }
+            public void SetByCSPRNG() {
+                blsSecretKeySetByCSPRNG(ref this);
+            }
+            public void SetHashOf(string s) {
+                if (blsHashToSecretKey(ref this, s, (ulong)s.Length) != 0) {
+                    throw new ArgumentException("blsHashToSecretKey");
+                }
+            }
+            public PublicKey GetPublicKey() {
+                PublicKey pub;
+                blsGetPublicKey(ref pub, this);
+                return pub;
+            }
+            public Signature Sign(string m) {
+                Signature sig;
+                blsSign(ref sig, this, m, (ulong)m.Length);
+                return sig;
+            }
+            public Signature GetPop() {
+                Signature sig;
+                blsGetPop(ref sig, this);
+                return sig;
+            }
+        }
+        // secretKey = sum_{i=0}^{msk.Length - 1} msk[i] * id^i
+        public static SecretKey ShareSecretKey(in SecretKey[] msk, in Id id) {
+            SecretKey sec;
+            if (blsSecretKeyShare(ref sec, msk[0], (ulong)msk.Length, id) != 0) {
+                throw new ArgumentException("GetSecretKeyForId:" + id.ToString());
+            }
+            return sec;
+        }
+        public static SecretKey RecoverSecretKey(in SecretKey[] secVec, in Id[] idVec) {
+            SecretKey sec;
+            if (blsSecretKeyRecover(ref sec, secVec[0], idVec[0], (ulong)secVec.Length) != 0) {
+                throw new ArgumentException("Recover");
+            }
+            return sec;
+        }
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct PublicKey
+        {
+            private fixed ulong v[PUBLICKEY_UNIT_SIZE];
+            public byte[] Serialize() {
+                byte[] buf = new byte[PUBLICKEY_SERIALIZE_SIZE];
+                ulong n = blsPublicKeySerialize(buf, (ulong)buf.Length, this);
+                if (n == 0) {
+                    throw new ArithmeticException("blsPublicKeySerialize");
+                }
+                return buf;
+            }
+            public void Deserialize(byte[] buf) {
+                ulong n = blsPublicKeyDeserialize(ref this, buf, (ulong)buf.Length);
+                if (n == 0) {
+                    throw new ArithmeticException("blsPublicKeyDeserialize");
+                }
+            }
+            public bool IsEqual(in PublicKey rhs) {
+                return blsPublicKeyIsEqual(this, rhs) != 0;
+            }
+            public void SetStr(string s) {
+                if (blsPublicKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {
+                    throw new ArgumentException("blsPublicKeySetStr:" + s);
+                }
+            }
+            public string GetHexStr() {
+                StringBuilder sb = new StringBuilder(1024);
+                ulong size = blsPublicKeyGetHexStr(sb, (ulong)sb.Capacity, this);
+                if (size == 0) {
+                    throw new ArgumentException("blsPublicKeyGetStr");
+                }
+                return sb.ToString(0, (int)size);
+            }
+            public void Add(in PublicKey rhs) {
+                blsPublicKeyAdd(ref this, rhs);
+            }
+            public bool Verify(in Signature sig, string m) {
+                return blsVerify(sig, this, m, (ulong)m.Length) == 1;
+            }
+            public bool VerifyPop(in Signature pop) {
+                return blsVerifyPop(pop, this) == 1;
+            }
+        }
+        // publicKey = sum_{i=0}^{mpk.Length - 1} mpk[i] * id^i
+        public static PublicKey SharePublicKey(in PublicKey[] mpk, in Id id) {
+            PublicKey pub;
+            if (blsPublicKeyShare(ref pub, mpk[0], (ulong)mpk.Length, id) != 0) {
+                throw new ArgumentException("GetPublicKeyForId:" + id.ToString());
+            }
+            return pub;
+        }
+        public static PublicKey RecoverPublicKey(in PublicKey[] pubVec, in Id[] idVec) {
+            PublicKey pub;
+            if (blsPublicKeyRecover(ref pub, pubVec[0], idVec[0], (ulong)pubVec.Length) != 0) {
+                throw new ArgumentException("Recover");
+            }
+            return pub;
+        }
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct Signature
+        {
+            private fixed ulong v[SIGNATURE_UNIT_SIZE];
+            public byte[] Serialize() {
+                byte[] buf = new byte[SIGNATURE_SERIALIZE_SIZE];
+                ulong n = blsSignatureSerialize(buf, (ulong)buf.Length, this);
+                if (n == 0) {
+                    throw new ArithmeticException("blsSignatureSerialize");
+                }
+                return buf;
+            }
+            public void Deserialize(byte[] buf) {
+                ulong n = blsSignatureDeserialize(ref this, buf, (ulong)buf.Length);
+                if (n == 0) {
+                    throw new ArithmeticException("blsSignatureDeserialize");
+                }
+            }
+            public bool IsEqual(in Signature rhs) {
+                return blsSignatureIsEqual(this, rhs) != 0;
+            }
+            public void SetStr(string s) {
+                if (blsSignatureSetHexStr(ref this, s, (ulong)s.Length) != 0) {
+                    throw new ArgumentException("blsSignatureSetStr:" + s);
+                }
+            }
+            public string GetHexStr() {
+                StringBuilder sb = new StringBuilder(1024);
+                ulong size = blsSignatureGetHexStr(sb, (ulong)sb.Capacity, this);
+                if (size == 0) {
+                    throw new ArgumentException("blsSignatureGetStr");
+                }
+                return sb.ToString(0, (int)size);
+            }
+            public void Add(in Signature rhs) {
+                blsSignatureAdd(ref this, rhs);
+            }
+        }
+        public static Signature RecoverSign(in Signature[] sigVec, in Id[] idVec) {
+            Signature sig;
+            if (blsSignatureRecover(ref sig, sigVec[0], idVec[0], (ulong)sigVec.Length) != 0) {
+                throw new ArgumentException("Recover");
+            }
+            return sig;
+        }
+    }
+}
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.csproj b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.csproj
new file mode 100644
index 000000000..c03afa436
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.csproj
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>bls</RootNamespace>
+    <AssemblyName>bls</AssemblyName>
+    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <LangVersion>7.2</LangVersion>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <LangVersion>7.2</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup>
+    <NoWin32Manifest>true</NoWin32Manifest>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="bls.cs" />
+    <Compile Include="bls_test.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include=".NETFramework,Version=v4.5.2">
+      <Visible>False</Visible>
+      <ProductName>Microsoft .NET Framework 4.5.2 %28x86 および x64%29</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.sln b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.sln
new file mode 100644
index 000000000..7c3dfba7b
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.28307.539
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "bls", "bls.csproj", "{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Debug|x64.ActiveCfg = Debug|x64
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Debug|x64.Build.0 = Debug|x64
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Release|x64.ActiveCfg = Release|x64
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966D}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {1935C301-6478-4F82-9587-6A66B531E327}
+	EndGlobalSection
+EndGlobal
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.cs b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.cs
new file mode 100644
index 000000000..3ef5fab9a
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.cs
@@ -0,0 +1,298 @@
+����using System;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace mcl {
+	class BLS256 {
+		const int IoEcComp = 512; // fixed byte representation
+        public const int MCLBN_FR_UNIT_SIZE = 4;
+        public const int MCLBN_FP_UNIT_SIZE = 4;
+        public const int MCLBN_COMPILED_TIME_VAR = MCLBN_FR_UNIT_SIZE * 10 + MCLBN_FP_UNIT_SIZE;
+		[DllImport("bls256.dll")]
+		public static extern int blsInit(int curve, int compiledTimeVar);
+
+		[DllImport("bls256.dll")] public static extern void blsIdSetInt(ref Id id, int x);
+		[DllImport("bls256.dll")] public static extern int blsIdSetDecStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern int blsIdSetHexStr(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern ulong blsIdGetDecStr([Out]StringBuilder buf, ulong maxBufSize, ref Id id);
+		[DllImport("bls256.dll")] public static extern ulong blsIdGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref Id id);
+
+
+		[DllImport("bls256.dll")] public static extern ulong blsIdSerialize([Out]StringBuilder buf, ulong maxBufSize, ref Id id);
+		[DllImport("bls256.dll")] public static extern ulong blsSecretKeySerialize([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);
+		[DllImport("bls256.dll")] public static extern ulong blsPublicKeySerialize([Out]StringBuilder buf, ulong maxBufSize, ref PublicKey pub);
+		[DllImport("bls256.dll")] public static extern ulong blsSignatureSerialize([Out]StringBuilder buf, ulong maxBufSize, ref Signature sig);
+
+		[DllImport("bls256.dll")] public static extern int blsIdDeserialize(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern int blsSecretKeyDeserialize(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern int blsPublicKeyDeserialize(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern int blsSignatureDeserialize(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+
+		[DllImport("bls256.dll")] public static extern int blsIdIsEqual(ref Id lhs, ref Id rhs);
+		[DllImport("bls256.dll")] public static extern int blsSecretKeyIsEqual(ref SecretKey lhs, ref SecretKey rhs);
+		[DllImport("bls256.dll")] public static extern int blsPublicKeyIsEqual(ref PublicKey lhs, ref PublicKey rhs);
+		[DllImport("bls256.dll")] public static extern int blsSignatureIsEqual(ref Signature lhs, ref Signature rhs);
+
+		// add
+		[DllImport("bls256.dll")] public static extern void blsSecretKeyAdd(ref SecretKey sec, ref SecretKey rhs);
+		[DllImport("bls256.dll")] public static extern void blsPublicKeyAdd(ref PublicKey pub, ref PublicKey rhs);
+		[DllImport("bls256.dll")] public static extern void blsSignatureAdd(ref Signature sig, ref Signature rhs);
+
+		//	hash buf and set
+		[DllImport("bls256.dll")] public static extern int blsHashToSecretKey(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		/*
+			set secretKey if system has /dev/urandom or CryptGenRandom
+			return 0 if success else -1
+		*/
+		[DllImport("bls256.dll")] public static extern int blsSecretKeySetByCSPRNG(ref SecretKey sec);
+
+		[DllImport("bls256.dll")] public static extern void blsGetPublicKey(ref PublicKey pub, ref SecretKey sec);
+		[DllImport("bls256.dll")] public static extern void blsGetPop(ref Signature sig, ref SecretKey sec);
+
+		// return 0 if success
+		[DllImport("bls256.dll")] public static extern int blsSecretKeyShare(ref SecretKey sec, ref SecretKey msk, ulong k, ref Id id);
+		[DllImport("bls256.dll")] public static extern int blsPublicKeyShare(ref PublicKey pub, ref PublicKey mpk, ulong k, ref Id id);
+
+
+		[DllImport("bls256.dll")] public static extern int blsSecretKeyRecover(ref SecretKey sec, ref SecretKey secVec, ref Id idVec, ulong n);
+		[DllImport("bls256.dll")] public static extern int blsPublicKeyRecover(ref PublicKey pub, ref PublicKey pubVec, ref Id idVec, ulong n);
+		[DllImport("bls256.dll")] public static extern int blsSignatureRecover(ref Signature sig, ref Signature sigVec, ref Id idVec, ulong n);
+
+		[DllImport("bls256.dll")] public static extern void blsSign(ref Signature sig, ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);
+
+		// return 1 if valid
+		[DllImport("bls256.dll")] public static extern int blsVerify(ref Signature sig, ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string m, ulong size);
+		[DllImport("bls256.dll")] public static extern int blsVerifyPop(ref Signature sig, ref PublicKey pub);
+
+		//////////////////////////////////////////////////////////////////////////
+		// the following apis will be removed
+
+		// mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r
+		[DllImport("bls256.dll")] public static extern int blsIdSetLittleEndian(ref Id id, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		/*
+			return written byte size if success else 0
+		*/
+		[DllImport("bls256.dll")] public static extern ulong blsIdGetLittleEndian([Out]StringBuilder buf, ulong maxBufSize, ref Id id);
+
+		// return 0 if success
+		// mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r
+		[DllImport("bls256.dll")] public static extern int blsSecretKeySetLittleEndian(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern int blsSecretKeySetDecStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern int blsSecretKeySetHexStr(ref SecretKey sec, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		/*
+			return written byte size if success else 0
+		*/
+		[DllImport("bls256.dll")] public static extern ulong blsSecretKeyGetLittleEndian([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);
+		/*
+			return strlen(buf) if success else 0
+			buf is '\0' terminated
+		*/
+		[DllImport("bls256.dll")] public static extern ulong blsSecretKeyGetDecStr([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);
+		[DllImport("bls256.dll")] public static extern ulong blsSecretKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref SecretKey sec);
+		[DllImport("bls256.dll")] public static extern int blsPublicKeySetHexStr(ref PublicKey pub, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern ulong blsPublicKeyGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref PublicKey pub);
+		[DllImport("bls256.dll")] public static extern int blsSignatureSetHexStr(ref Signature sig, [In][MarshalAs(UnmanagedType.LPStr)] string buf, ulong bufSize);
+		[DllImport("bls256.dll")] public static extern ulong blsSignatureGetHexStr([Out]StringBuilder buf, ulong maxBufSize, ref Signature sig);
+
+		public static void Init()
+		{
+			const int CurveFp254BNb = 0;
+			if (!System.Environment.Is64BitProcess) {
+				throw new PlatformNotSupportedException("not 64-bit system");
+			}
+			int err = blsInit(CurveFp254BNb, MCLBN_COMPILED_TIME_VAR);
+			if (err != 0) {
+				throw new ArgumentException("blsInit");
+			}
+		}
+
+		public struct Id {
+			private ulong v0, v1, v2, v3;
+			public bool IsEqual(Id rhs)
+			{
+				return blsIdIsEqual(ref this, ref rhs) != 0;
+			}
+			public void SetDecStr(String s)
+			{
+				if (blsIdSetDecStr(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsIdSetDecSt:" + s);
+				}
+			}
+			public void SetHexStr(String s)
+			{
+				if (blsIdSetHexStr(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsIdSetHexStr:" + s);
+				}
+			}
+			public void SetInt(int x)
+			{
+				blsIdSetInt(ref this, x);
+			}
+			public string GetDecStr()
+			{
+				StringBuilder sb = new StringBuilder(1024);
+				ulong size = blsIdGetDecStr(sb, (ulong)sb.Capacity, ref this);
+				if (size == 0) {
+					throw new ArgumentException("blsIdGetDecStr");
+				}
+				return sb.ToString(0, (int)size);
+			}
+			public string GetHexStr()
+			{
+				StringBuilder sb = new StringBuilder(1024);
+				ulong size = blsIdGetHexStr(sb, (ulong)sb.Capacity, ref this);
+				if (size == 0) {
+					throw new ArgumentException("blsIdGetHexStr");
+				}
+				return sb.ToString(0, (int)size);
+			}
+		}
+		public struct SecretKey {
+			private ulong v0, v1, v2, v3;
+			public bool IsEqual(SecretKey rhs)
+			{
+				return blsSecretKeyIsEqual(ref this, ref rhs) != 0;
+			}
+			public void SetHexStr(String s)
+			{
+				if (blsSecretKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsSecretKeySetHexStr:" + s);
+				}
+			}
+			public string GetHexStr()
+			{
+				StringBuilder sb = new StringBuilder(1024);
+				ulong size = blsSecretKeyGetHexStr(sb, (ulong)sb.Capacity, ref this);
+				if (size == 0) {
+					throw new ArgumentException("mclBnFr_getStr");
+				}
+				return sb.ToString(0, (int)size);
+			}
+			public void Add(SecretKey rhs)
+			{
+				blsSecretKeyAdd(ref this, ref rhs);
+			}
+			public void SetByCSPRNG()
+			{
+				blsSecretKeySetByCSPRNG(ref this);
+			}
+			public void SetHashOf(string s)
+			{
+				if (blsHashToSecretKey(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsHashToSecretKey");
+				}
+			}
+			public PublicKey GetPublicKey()
+			{
+				PublicKey pub = new PublicKey();
+				blsGetPublicKey(ref pub, ref this);
+				return pub;
+			}
+			public Signature Signature(String m)
+			{
+				Signature Signature = new Signature();
+				blsSign(ref Signature, ref this, m, (ulong)m.Length);
+				return Signature;
+			}
+		}
+		// secretKey = sum_{i=0}^{msk.Length - 1} msk[i] * id^i
+		public static SecretKey ShareSecretKey(SecretKey[] msk, Id id)
+		{
+			SecretKey sec = new SecretKey();
+			if (blsSecretKeyShare(ref sec, ref msk[0], (ulong)msk.Length, ref id) != 0) {
+				throw new ArgumentException("GetSecretKeyForId:" + id.ToString());
+			}
+			return sec;
+		}
+		public static SecretKey RecoverSecretKey(SecretKey[] secs, Id[] ids)
+		{
+			SecretKey sec = new SecretKey();
+			if (blsSecretKeyRecover(ref sec, ref secs[0], ref ids[0], (ulong)secs.Length) != 0) {
+				throw new ArgumentException("Recover");
+			}
+			return sec;
+		}
+		public struct PublicKey {
+			private ulong v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11;
+			private ulong v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23;
+			public bool IsEqual(PublicKey rhs)
+			{
+				return blsPublicKeyIsEqual(ref this, ref rhs) != 0;
+			}
+			public void SetStr(String s)
+			{
+				if (blsPublicKeySetHexStr(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsPublicKeySetStr:" + s);
+				}
+			}
+			public string GetHexStr()
+			{
+				StringBuilder sb = new StringBuilder(1024);
+				ulong size = blsPublicKeyGetHexStr(sb, (ulong)sb.Capacity, ref this);
+				if (size == 0) {
+					throw new ArgumentException("blsPublicKeyGetStr");
+				}
+				return sb.ToString(0, (int)size);
+			}
+			public void Add(PublicKey rhs)
+			{
+				blsPublicKeyAdd(ref this, ref rhs);
+			}
+			public bool Verify(Signature Signature, string m)
+			{
+				return blsVerify(ref Signature, ref this, m, (ulong)m.Length) == 1;
+			}
+		}
+		// publicKey = sum_{i=0}^{mpk.Length - 1} mpk[i] * id^i
+		public static PublicKey SharePublicKey(PublicKey[] mpk, Id id)
+		{
+			PublicKey pub = new PublicKey();
+			if (blsPublicKeyShare(ref pub, ref mpk[0], (ulong)mpk.Length, ref id) != 0) {
+				throw new ArgumentException("GetPublicKeyForId:" + id.ToString());
+			}
+			return pub;
+		}
+		public static PublicKey RecoverPublicKey(PublicKey[] pubs, Id[] ids)
+		{
+			PublicKey pub = new PublicKey();
+			if (blsPublicKeyRecover(ref pub, ref pubs[0], ref ids[0], (ulong)pubs.Length) != 0) {
+				throw new ArgumentException("Recover");
+			}
+			return pub;
+		}
+		public struct Signature {
+			private ulong v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11;
+			public bool IsEqual(Signature rhs)
+			{
+				return blsSignatureIsEqual(ref this, ref rhs) != 0;
+			}
+			public void SetStr(String s)
+			{
+				if (blsSignatureSetHexStr(ref this, s, (ulong)s.Length) != 0) {
+					throw new ArgumentException("blsSignatureSetStr:" + s);
+				}
+			}
+			public string GetHexStr()
+			{
+				StringBuilder sb = new StringBuilder(1024);
+				ulong size = blsSignatureGetHexStr(sb, (ulong)sb.Capacity, ref this);
+				if (size == 0) {
+					throw new ArgumentException("blsSignatureGetStr");
+				}
+				return sb.ToString(0, (int)size);
+			}
+			public void Add(Signature rhs)
+			{
+				blsSignatureAdd(ref this, ref rhs);
+			}
+		}
+		public static Signature RecoverSign(Signature[] signs, Id[] ids)
+		{
+			Signature Signature = new Signature();
+			if (blsSignatureRecover(ref Signature, ref signs[0], ref ids[0], (ulong)signs.Length) != 0) {
+				throw new ArgumentException("Recover");
+			}
+			return Signature;
+		}
+	}
+}
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.csproj b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.csproj
new file mode 100644
index 000000000..032a1d347
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.csproj
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>bls256</RootNamespace>
+    <AssemblyName>bls256</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="bls256.cs" />
+    <Compile Include="bls256_test.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.sln b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.sln
new file mode 100644
index 000000000..eb29af97b
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256.sln
@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBD}") = "bls256", "bls256.csproj", "{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Debug|x64.ActiveCfg = Debug|x64
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Debug|x64.Build.0 = Debug|x64
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Release|x64.ActiveCfg = Release|x64
+		{E9D06B1B-EA22-4EF4-BA4B-422F7625966C}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256_test.cs b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256_test.cs
new file mode 100644
index 000000000..989993e0f
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls256_test.cs
@@ -0,0 +1,126 @@
+using System;
+
+namespace mcl {
+	using static BLS256;
+	class BLS256Test {
+		static int err = 0;
+		static void assert(string msg, bool b)
+		{
+			if (b) return;
+			Console.WriteLine("ERR {0}", msg);
+			err++;
+		}
+		static void TestId()
+		{
+			Console.WriteLine("TestId");
+			Id id = new Id();
+			id.SetDecStr("255");
+			assert("GetStr(10)", id.GetDecStr() == "255");
+			assert("GetStr(16)", id.GetHexStr() == "ff");
+		}
+		static void TestSecretKey()
+		{
+			Console.WriteLine("TestSecretKey");
+			SecretKey sec = new SecretKey();
+			sec.SetHexStr("ff");
+			assert("GetHexStr()", sec.GetHexStr() == "ff");
+			{
+				SecretKey sec2 = new SecretKey();
+				sec.SetHexStr("321");
+				sec2.SetHexStr("4000");
+				sec.Add(sec2);
+				assert("sec.Add", sec.GetHexStr() == "4321");
+				sec.SetByCSPRNG();
+				Console.WriteLine("sec.Init={0}", sec.GetHexStr());
+			}
+		}
+		static void TestPublicKey()
+		{
+			Console.WriteLine("TestPublicKey");
+			SecretKey sec = new SecretKey();
+			sec.SetByCSPRNG();
+			PublicKey pub = sec.GetPublicKey();
+			String s = pub.GetHexStr();
+			Console.WriteLine("pub={0}", s);
+			PublicKey pub2 = new PublicKey();
+			pub2.SetStr(s);
+			assert("pub.SetStr", pub.IsEqual(pub2));
+		}
+		static void TestSign()
+		{
+			Console.WriteLine("TestSign");
+			SecretKey sec = new SecretKey();
+			sec.SetByCSPRNG();
+			PublicKey pub = sec.GetPublicKey();
+			String m = "abc";
+			Signature sig = sec.Signature(m);
+			assert("verify", pub.Verify(sig, m));
+			assert("not verify", !pub.Verify(sig, m + "a"));
+		}
+		static void TestSharing()
+		{
+			Console.WriteLine("TestSharing");
+			int k = 5;
+			SecretKey[] msk = new SecretKey[k];
+			PublicKey[] mpk = new PublicKey[k];
+			// make master secretkey
+			for (int i = 0; i < k; i++) {
+				msk[i].SetByCSPRNG();
+				mpk[i] = msk[i].GetPublicKey();
+			}
+			int n = 30;
+			Id[] ids = new Id[n];
+			SecretKey[] secs = new SecretKey[n];
+			PublicKey[] pubs = new PublicKey[n];
+			for (int i = 0; i < n; i++) {
+				ids[i].SetInt(i * i + 123);
+				secs[i] = ShareSecretKey(msk, ids[i]);
+				pubs[i] = SharePublicKey(mpk, ids[i]);
+				assert("share publicKey", secs[i].GetPublicKey().IsEqual(pubs[i]));
+			}
+			string m = "doremi";
+			for (int i = 0; i < n; i++) {
+				Signature Signature = secs[i].Signature(m);
+				assert("Signature.Verify", pubs[i].Verify(Signature, m));
+			}
+			{
+				int[] idxTbl = { 0, 2, 5, 8, 10 };
+				assert("idxTbl.Length=k", idxTbl.Length == k);
+				Id[] subIds = new Id[k];
+				SecretKey[] subSecs = new SecretKey[k];
+				PublicKey[] subPubs = new PublicKey[k];
+				Signature[] subSigns = new Signature[k];
+				for (int i = 0; i < k; i++) {
+					int idx = idxTbl[i];
+					subIds[i] = ids[idx];
+					subSecs[i] = secs[idx];
+					subPubs[i] = pubs[idx];
+					subSigns[i] = secs[idx].Signature(m);
+				}
+				SecretKey sec = RecoverSecretKey(subSecs, subIds);
+				PublicKey pub = RecoverPublicKey(subPubs, subIds);
+				assert("check pub", pub.IsEqual(sec.GetPublicKey()));
+				Signature Signature = RecoverSign(subSigns, subIds);
+				assert("Signature.verify", pub.Verify(Signature, m));
+			}
+		}
+		static void Main(string[] args)
+		{
+			try {
+				Init();
+				TestId();
+				TestSecretKey();
+				TestPublicKey();
+				TestSign();
+				TestSharing();
+				if (err == 0) {
+					Console.WriteLine("all tests succeed");
+				} else {
+					Console.WriteLine("err={0}", err);
+				}
+			} catch (Exception e) {
+				Console.WriteLine("ERR={0}", e);
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/bls_test.cs b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls_test.cs
new file mode 100644
index 000000000..2eb451ba9
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/bls_test.cs
@@ -0,0 +1,176 @@
+using System;
+
+namespace mcl
+{
+    using static BLS;
+    class BLSTest
+    {
+        static int err = 0;
+        static void assert(string msg, bool b) {
+            if (b) return;
+            Console.WriteLine("ERR {0}", msg);
+            err++;
+        }
+        static void TestId() {
+            Console.WriteLine("TestId");
+            Id id1;
+            id1.SetDecStr("255");
+            assert("GetStr(10)", id1.GetDecStr() == "255");
+            assert("GetStr(16)", id1.GetHexStr() == "ff");
+            Id id2;
+            id2.SetInt(255);
+            assert("IsEqual", id1.IsEqual(id2));
+        }
+        static void TestSecretKey() {
+            Console.WriteLine("TestSecretKey");
+            SecretKey sec;
+            sec.SetHexStr("ff");
+            assert("GetHexStr()", sec.GetHexStr() == "ff");
+            {
+                SecretKey sec2;
+                sec.SetHexStr("321");
+                sec2.SetHexStr("4000");
+                sec.Add(sec2);
+                assert("sec.Add", sec.GetHexStr() == "4321");
+                sec.SetByCSPRNG();
+                Console.WriteLine("sec.Init={0}", sec.GetHexStr());
+            }
+            {
+                SecretKey sec2;
+                byte[] buf = sec.Serialize();
+                sec2.Deserialize(buf);
+                assert("serialize", sec2.IsEqual(sec));
+            }
+        }
+        static void TestPublicKey() {
+            Console.WriteLine("TestPublicKey");
+            SecretKey sec;
+            sec.SetByCSPRNG();
+            PublicKey pub = sec.GetPublicKey();
+            string s = pub.GetHexStr();
+            Console.WriteLine("pub={0}", s);
+            {
+                PublicKey pub2;
+                pub2.SetStr(s);
+                assert("pub.SetStr", pub.IsEqual(pub2));
+            }
+            {
+                PublicKey pub2;
+                byte[] buf = pub.Serialize();
+                pub2.Deserialize(buf);
+                assert("serialize", pub2.IsEqual(pub));
+            }
+        }
+        static void TestSign() {
+            Console.WriteLine("TestSign");
+            SecretKey sec;
+            sec.SetByCSPRNG();
+            PublicKey pub = sec.GetPublicKey();
+            string m = "abc";
+            Signature sig = sec.Sign(m);
+            Console.WriteLine("sig={0}", sig.GetHexStr());
+            assert("verify", pub.Verify(sig, m));
+            assert("not verify", !pub.Verify(sig, m + "a"));
+            {
+                Signature sig2;
+                byte[] buf = sig.Serialize();
+                sig2.Deserialize(buf);
+                assert("serialize", sig2.IsEqual(sig));
+            }
+        }
+        static void TestSharing() {
+            Console.WriteLine("TestSharing");
+            int k = 5;
+            SecretKey[] msk = new SecretKey[k];
+            PublicKey[] mpk = new PublicKey[k];
+            // make master secretkey
+            for (int i = 0; i < k; i++) {
+                msk[i].SetByCSPRNG();
+                mpk[i] = msk[i].GetPublicKey();
+            }
+            int n = 30;
+            Id[] ids = new Id[n];
+            SecretKey[] secs = new SecretKey[n];
+            PublicKey[] pubs = new PublicKey[n];
+            for (int i = 0; i < n; i++) {
+                ids[i].SetInt(i * i + 123);
+                secs[i] = ShareSecretKey(msk, ids[i]);
+                pubs[i] = SharePublicKey(mpk, ids[i]);
+                assert("share publicKey", secs[i].GetPublicKey().IsEqual(pubs[i]));
+            }
+            string m = "doremi";
+            for (int i = 0; i < n; i++) {
+                Signature Signature = secs[i].Sign(m);
+                assert("Signature.Verify", pubs[i].Verify(Signature, m));
+            }
+            {
+                int[] idxTbl = { 0, 2, 5, 8, 10 };
+                assert("idxTbl.Length=k", idxTbl.Length == k);
+                Id[] subIds = new Id[k];
+                SecretKey[] subSecs = new SecretKey[k];
+                PublicKey[] subPubs = new PublicKey[k];
+                Signature[] subSigns = new Signature[k];
+                for (int i = 0; i < k; i++) {
+                    int idx = idxTbl[i];
+                    subIds[i] = ids[idx];
+                    subSecs[i] = secs[idx];
+                    subPubs[i] = pubs[idx];
+                    subSigns[i] = secs[idx].Sign(m);
+                }
+                SecretKey sec = RecoverSecretKey(subSecs, subIds);
+                PublicKey pub = RecoverPublicKey(subPubs, subIds);
+                assert("check pub", pub.IsEqual(sec.GetPublicKey()));
+                Signature Signature = RecoverSign(subSigns, subIds);
+                assert("Signature.verify", pub.Verify(Signature, m));
+            }
+        }
+        static void TestAggregate() {
+            Console.WriteLine("TestAggregate");
+            const int n = 10;
+            const string m = "abc";
+            SecretKey[] secVec = new SecretKey[n];
+            PublicKey[] pubVec = new PublicKey[n];
+            Signature[] popVec = new Signature[n];
+            Signature[] sigVec = new Signature[n];
+            for (int i = 0; i < n; i++) {
+                secVec[i].SetByCSPRNG();
+                pubVec[i] = secVec[i].GetPublicKey();
+                popVec[i] = secVec[i].GetPop();
+                sigVec[i] = secVec[i].Sign(m);
+            }
+            SecretKey secAgg;
+            PublicKey pubAgg;
+            Signature sigAgg;
+            for (int i = 0; i < n; i++) {
+                secAgg.Add(secVec[i]);
+                assert("verify pop", pubVec[i].VerifyPop(popVec[i]));
+                pubAgg.Add(pubVec[i]);
+                sigAgg.Add(sigVec[i]);
+            }
+            assert("aggregate sec", secAgg.Sign(m).IsEqual(sigAgg));
+            assert("aggregate", pubAgg.Verify(sigAgg, m));
+        }
+        static void Main(string[] args) {
+            try {
+                int[] curveTypeTbl = { BN254, BLS12_381 };
+                foreach (int curveType in curveTypeTbl) {
+                    Console.WriteLine("curveType={0}", curveType);
+                    Init(curveType);
+                    TestId();
+                    TestSecretKey();
+                    TestPublicKey();
+                    TestSign();
+                    TestSharing();
+                    TestAggregate();
+                    if (err == 0) {
+                        Console.WriteLine("all tests succeed");
+                    } else {
+                        Console.WriteLine("err={0}", err);
+                    }
+                }
+            } catch (Exception e) {
+                Console.WriteLine("ERR={0}", e);
+            }
+        }
+    }
+}
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/readme-ja.md b/vendor/github.com/dexon-foundation/bls/ffi/cs/readme-ja.md
new file mode 100644
index 000000000..199135725
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/readme-ja.md
@@ -0,0 +1,188 @@
+# BLS署名のC#バインディング
+
+# 必要環境
+
+* Visual Studio 2017(x64) or later
+* C# 7.2 or later
+* .NET Framework 4.5.2 or later
+
+# DLLのビルド方法
+
+Visual Studio 2017の64bit用コマンドプロンプトを開いて
+```
+md work
+cd work
+git clone https://github.com/herumi/cybozulib_ext
+git clone https://github.com/herumi/mcl
+git clone https://github.com/herumi/bls
+cd bls
+mklib dll
+```
+`bls/bin/*.dll`が作成される。
+
+# サンプルのビルド方法
+
+bls/ffi/cs/bls.slnを開いて実行する。
+
+* 注意 bls256.slnは古いため使わないでください。
+
+# クラスとAPI
+
+## API
+
+* `Init(int curveType = BN254);`
+    * ライブラリを曲線curveTypeで初期化する。
+    * curveType = BN254 or BLS12_381
+* `SecretKey ShareSecretKey(in SecretKey[] msk, in Id id);`
+    * マスター秘密鍵の列mskに対するidの秘密鍵を生成(共有)する。
+* `SecretKey RecoverSecretKey(in SecretKey[] secVec, in Id[] idVec);`
+    * 秘密鍵secVecとID idVecのペアから秘密鍵を復元する。
+* `PublicKey SharePublicKey(in PublicKey[] mpk, in Id id);`
+    * マスター公開鍵の列mpkに対するidの公開鍵を生成(共有)する。
+* `PublicKey RecoverPublicKey(in PublicKey[] pubVec, in Id[] idVec);`
+    * 公開鍵pubVecとID idVecのペアから公開鍵を復元する。
+* `Signature RecoverSign(in Signature[] sigVec, in Id[] idVec);`
+    * 署名sigVecとID idVecのペアから署名を復元する。
+
+## Id
+
+識別子クラス
+
+* `byte[] Serialize();`
+    * Idをシリアライズする。
+* `void Deserialize(byte[] buf);`
+    * バイト列bufからIdをデシリアライズする。
+* `bool IsEqual(in Id rhs);`
+    * 同値判定。
+* `void SetDecStr(string s);`
+    * 10進数文字列を設定する。
+* `void SetHexStr(string s);`
+    * 16進数文字列を設定する。
+* `void SetInt(int x);`
+    * 整数xを設定する。
+* `string GetDecStr();`
+    * 10進数表記を取得する。
+* `string GetHexStr();`
+    * 16進数表記を取得する。
+
+## SecretKey
+
+* `byte[] Serialize();`
+    * Idをシリアライズする。
+* `void Deserialize(byte[] buf);`
+    * バイト列bufからSecretKeyをデシリアライズする。
+* `bool IsEqual(in SecretKey rhs);`
+    * 同値判定。
+* `void SetHexStr(string s);`
+    * 16進数文字列を設定する。
+* `string GetHexStr();`
+    * 16進数表記を取得する。
+* `void Add(in SecretKey rhs);`
+    * 秘密鍵rhsを加算する。
+* `void SetByCSPRNG();`
+    * 暗号学的乱数で設定する。
+* `void SetHashOf(string s);`
+    * 文字列sのハッシュ値を設定する。
+* `PublicKey GetPublicKey();`
+    * 対応する公開鍵を取得する。
+* `Signature Sign(string m);`
+    * 文字列mの署名を生成する。
+* `Signature GetPop();`
+    * 自身の秘密鍵による署名(Proof Of Posession)を生成する。
+
+## PublicKey
+
+* `byte[] Serialize();`
+    * PublicKeyをシリアライズする。
+* `void Deserialize(byte[] buf);`
+    * バイト列bufからPublicKeyをデシリアライズする。
+* `bool IsEqual(in PublicKey rhs);`
+    * 同値判定。
+* `void Add(in PublicKey rhs);`
+    * 公開鍵rhsを加算する。
+* `void SetHexStr(string s);`
+    * 16進数文字列を設定する。
+* `string GetHexStr();`
+    * 16進数表記を取得する。
+* `bool Verify(in Signature sig, string m);`
+    * 文字列mに対する署名sigの正当性を確認する。
+* `bool VerifyPop(in Signature pop);`
+    * PoPの正当性を確認する。
+
+## Signature
+
+* `byte[] Serialize();`
+    * Signatureをシリアライズする。
+* `void Deserialize(byte[] buf);`
+    * バイト列bufからSignatureをデシリアライズする。
+* `bool IsEqual(in Signature rhs);`
+    * 同値判定。
+* `void Add(in Signature rhs);`
+    * 署名rhsを加算する。
+* `void SetHexStr(string s);`
+    * 16進数文字列を設定する。
+* `string GetHexStr();`
+    * 16進数表記を取得する。
+
+## 使い方
+
+### 最小サンプル
+
+```
+using static BLS;
+
+Init(BN254); // ライブラリ初期化
+SecretKey sec;
+sec.SetByCSPRNG(); // 秘密鍵の初期化
+PublicKey pub = sec.GetPublicKey(); // 公開鍵の取得
+string m = "abc";
+Signature sig = sec.Sign(m); // 署名の作成
+if (pub.Verify(sig, m))) {
+  // 署名の確認
+}
+```
+
+### 集約署名
+```
+Init(BN254); // ライブラリ初期化
+const int n = 10;
+const string m = "abc";
+SecretKey[] secVec = new SecretKey[n];
+PublicKey[] pubVec = new PublicKey[n];
+Signature[] popVec = new Signature[n];
+Signature[] sigVec = new Signature[n];
+
+for (int i = 0; i < n; i++) {
+  secVec[i].SetByCSPRNG(); // 秘密鍵の初期化
+  pubVec[i] = secVec[i].GetPublicKey(); // 公開鍵の取得
+  popVec[i] = secVec[i].GetPop(); // 所有(PoP)の証明
+  sigVec[i] = secVec[i].Sign(m); // 署名
+}
+
+SecretKey secAgg;
+PublicKey pubAgg;
+Signature sigAgg;
+for (int i = 0; i < n; i++) {
+  // PoPの確認
+  if (pubVec[i].VerifyPop(popVec[i]))) {
+    // エラー
+    return;
+  }
+  pubAgg.Add(pubVec[i]); // 公開鍵の集約
+  sigAgg.Add(sigVec[i]); // 署名の集約
+}
+if (pubAgg.Verify(sigAgg, m)) {
+  // 署名の確認
+}
+```
+
+# ライセンス
+
+modified new BSD License
+http://opensource.org/licenses/BSD-3-Clause
+
+# 著者
+
+(C)2019 光成滋生 MITSUNARI Shigeo(herumi@nifty.com) All rights reserved.
+本コンテンツの著作権、および本コンテンツ中に出てくる商標権、団体名、ロゴ、製品、
+サービスなどはそれぞれ、各権利保有者に帰属します
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/cs/readme.md b/vendor/github.com/dexon-foundation/bls/ffi/cs/readme.md
new file mode 100644
index 000000000..2b7191871
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/cs/readme.md
@@ -0,0 +1,185 @@
+# C# binding of BLS threshold signature library
+
+# Installation Requirements
+
+* Visual Studio 2017 or later
+* C# 7.2 or later
+* .NET Framework 4.5.2 or later
+
+# How to build
+
+```
+md work
+cd work
+git clone https://github.com/herumi/cybozulib_ext
+git clone https://github.com/herumi/mcl
+git clone https://github.com/herumi/bls
+cd bls
+mklib dll
+```
+bls/bin/*.dll are created
+
+# How to build a sample
+
+Open bls/ffi/cs/bls.sln and exec it.
+
+* Remark. bls256 is obsolete. Please use bls.sln.
+
+# class and API
+
+## API
+
+* `Init(int curveType = BN254);`
+    * initialize this library with a curve `curveType`.
+    * curveType = BN254 or BLS12_381
+* `SecretKey ShareSecretKey(in SecretKey[] msk, in Id id);`
+    * generate the shared secret key from a sequence of master secret keys msk and Id.
+* `SecretKey RecoverSecretKey(in SecretKey[] secVec, in Id[] idVec);`
+    * recover the secret key from a sequence of secret keys secVec and idVec.
+* `PublicKey SharePublicKey(in PublicKey[] mpk, in Id id);`
+    * generate the shared public key from a sequence of master public keys mpk and Id.
+* `PublicKey RecoverPublicKey(in PublicKey[] pubVec, in Id[] idVec);`
+    * recover the public key from a sequence of public keys pubVec and idVec.
+* `Signature RecoverSign(in Signature[] sigVec, in Id[] idVec);`
+    * recover the signature from a sequence of signatures siVec and idVec.
+
+## Id
+
+Identifier class
+
+* `byte[] Serialize();`
+    * serialize Id
+* `void Deserialize(byte[] buf);`
+    * deserialize from byte[] buf
+* `bool IsEqual(in Id rhs);`
+    * equality
+* `void SetDecStr(string s);`
+    * set by a decimal string s
+* `void SetHexStr(string s);`
+    * set by a hexadecimal string s
+* `void SetInt(int x);`
+    * set an integer x
+* `string GetDecStr();`
+    * get a decimal string
+* `string GetHexStr();`
+    * get a hexadecimal string
+
+## SecretKey
+
+* `byte[] Serialize();`
+    * serialize SecretKey
+* `void Deserialize(byte[] buf);`
+    * deserialize from byte[] buf
+* `bool IsEqual(in SecretKey rhs);`
+    * equality
+* `string GetDecStr();`
+    * get a decimal string
+* `string GetHexStr();`
+    * get a hexadecimal string
+* `void Add(in SecretKey rhs);`
+    * add a secret key rhs
+* `void SetByCSPRNG();`
+    * set a secret key by cryptographically secure pseudo random number generator
+* `void SetHashOf(string s);`
+    * set a secret key by a hash of string s
+* `PublicKey GetPublicKey();`
+    * get the corresponding public key to a secret key
+* `Signature Sign(string m);`
+    * sign a string m
+* `Signature GetPop();`
+    * get a PoP (Proof Of Posession) for a secret key
+
+## PublicKey
+
+* `byte[] Serialize();`
+    * serialize PublicKey
+* `void Deserialize(byte[] buf);`
+    * deserialize from byte[] buf
+* `bool IsEqual(in PublicKey rhs);`
+    * equality
+* `void Add(in PublicKey rhs);`
+    * add a public key rhs
+* `string GetDecStr();`
+    * get a decimal string
+* `string GetHexStr();`
+    * get a hexadecimal string
+* `bool Verify(in Signature sig, string m);`
+    * verify the validness of the sig with m
+* `bool VerifyPop(in Signature pop);`
+    * verify the validness of PoP
+
+## Signature
+
+* `byte[] Serialize();`
+    * serialize Signature
+* `void Deserialize(byte[] buf);`
+    * deserialize from byte[] buf
+* `bool IsEqual(in Signature rhs);`
+    * equality
+* `void Add(in Signature rhs);`
+    * add a signature key rhs
+* `string GetDecStr();`
+    * get a decimal string
+* `string GetHexStr();`
+    * get a hexadecimal string
+
+## How to use
+
+### A minimum sample
+
+```
+using static BLS;
+
+Init(BN254); // init library
+SecretKey sec;
+sec.SetByCSPRNG(); // init secret key
+PublicKey pub = sec.GetPublicKey(); // get public key
+string m = "abc";
+Signature sig = sec.Sign(m); // create signature
+if (pub.Verify(sig, m))) {
+  // signature is verified
+}
+```
+
+### Aggregate signature
+```
+Init(BN254); // init library
+const int n = 10;
+const string m = "abc";
+SecretKey[] secVec = new SecretKey[n];
+PublicKey[] pubVec = new PublicKey[n];
+Signature[] popVec = new Signature[n];
+Signature[] sigVec = new Signature[n];
+
+for (int i = 0; i < n; i++) {
+  secVec[i].SetByCSPRNG(); // init secret key
+  pubVec[i] = secVec[i].GetPublicKey(); // get public key
+  popVec[i] = secVec[i].GetPop(); // get a proof of Possesion (PoP)
+  sigVec[i] = secVec[i].Sign(m); // create signature
+}
+
+SecretKey secAgg;
+PublicKey pubAgg;
+Signature sigAgg;
+for (int i = 0; i < n; i++) {
+  // verify PoP
+  if (pubVec[i].VerifyPop(popVec[i]))) {
+    // error
+    return;
+  }
+  pubAgg.Add(pubVec[i]); // aggregate public key
+  sigAgg.Add(sigVec[i]); // aggregate signature
+}
+if (pubAgg.Verify(sigAgg, m)) {
+  // aggregated signature is verified
+}
+```
+
+# License
+
+modified new BSD License
+http://opensource.org/licenses/BSD-3-Clause
+
+# Author
+
+(C)2019 MITSUNARI Shigeo(herumi@nifty.com) All rights reserved.
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls.go b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls.go
index 5123a07e6..c83a4e658 100644
--- a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls.go
+++ b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls.go
@@ -1,16 +1,25 @@
 package bls
 
 /*
-#cgo CFLAGS:-I../../../include -I../../../../mcl/include/
-#cgo LDFLAGS:${SRCDIR}/../../../lib/libbls384.a ${SRCDIR}/../../../../mcl/lib/libmcl.a -lgmpxx -lgmp -lstdc++
-#cgo CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
-#cgo pkg-config: libcrypto
-#cgo static pkg-config: --static
+#cgo bn256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=4
+#cgo bn256 LDFLAGS:${SRCDIR}/../../../lib/libbls256.a
+#cgo bn384 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
+#cgo bn384 LDFLAGS:${SRCDIR}/../../../lib/libbls384.a
+#cgo bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6 -DMCLBN_FR_UNIT_SIZE=4
+#cgo bn384_256 LDFLAGS:${SRCDIR}/../../../lib/libbls384_256.a
+#cgo !bn256,!bn384,!bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
+#cgo !bn256,!bn384,!bn384_256 LDFLAGS:${SRCDIR}/../../../lib/libbls384.a
+#cgo CFLAGS:-I${SRCDIR}/../../../include -I${SRCDIR}/../../../../mcl/include
+#cgo LDFLAGS:${SRCDIR}/../../../../mcl/lib/libmcl.a -lgmpxx -lgmp
+#cgo linux LDFLAGS:-static
+typedef unsigned int (*ReadRandFunc)(void *, void *, unsigned int);
+int wrapReadRandCgo(void *self, void *buf, unsigned int n);
 #include <bls/bls.h>
 */
 import "C"
 import "fmt"
 import "unsafe"
+import "io"
 import "encoding/json"
 
 // Init --
@@ -67,6 +76,9 @@ func (id *ID) SetDecString(s string) error {
 
 // IsEqual --
 func (id *ID) IsEqual(rhs *ID) bool {
+	if id == nil || rhs == nil {
+		return false
+	}
 	return id.v.IsEqual(&rhs.v)
 }
 
@@ -146,6 +158,9 @@ func (sec *SecretKey) SetDecString(s string) error {
 
 // IsEqual --
 func (sec *SecretKey) IsEqual(rhs *SecretKey) bool {
+	if sec == nil || rhs == nil {
+		return false
+	}
 	return sec.v.IsEqual(&rhs.v)
 }
 
@@ -264,6 +279,9 @@ func (pub *PublicKey) SetHexString(s string) error {
 
 // IsEqual --
 func (pub *PublicKey) IsEqual(rhs *PublicKey) bool {
+	if pub == nil || rhs == nil {
+		return false
+	}
 	return pub.v.IsEqual(&rhs.v)
 }
 
@@ -350,6 +368,9 @@ func (sign *Sign) SetHexString(s string) error {
 
 // IsEqual --
 func (sign *Sign) IsEqual(rhs *Sign) bool {
+	if sign == nil || rhs == nil {
+		return false
+	}
 	return sign.v.IsEqual(&rhs.v)
 }
 
@@ -389,6 +410,9 @@ func (sign *Sign) Verify(pub *PublicKey, m string) bool {
 
 // VerifyPop --
 func (sign *Sign) VerifyPop(pub *PublicKey) bool {
+	if pub.getPointer() == nil {
+		return false
+	}
 	return C.blsVerifyPop(sign.getPointer(), pub.getPointer()) == 1
 }
 
@@ -420,3 +444,96 @@ func DHKeyExchange(sec *SecretKey, pub *PublicKey) (out PublicKey) {
 	C.blsDHKeyExchange(out.getPointer(), sec.getPointer(), pub.getPointer())
 	return out
 }
+
+// HashAndMapToSignature --
+func HashAndMapToSignature(buf []byte) *Sign {
+	sig := new(Sign)
+	err := sig.v.HashAndMapTo(buf)
+	if err == nil {
+		return sig
+	} else {
+		return nil
+	}
+}
+
+// VerifyPairing --
+func VerifyPairing(X *Sign, Y *Sign, pub *PublicKey) bool {
+	if X.getPointer() == nil || Y.getPointer() == nil || pub.getPointer() == nil {
+		return false
+	}
+	return C.blsVerifyPairing(X.getPointer(), Y.getPointer(), pub.getPointer()) == 1
+}
+
+// SignHash --
+func (sec *SecretKey) SignHash(hash []byte) (sign *Sign) {
+	sign = new(Sign)
+	// #nosec
+	err := C.blsSignHash(sign.getPointer(), sec.getPointer(), unsafe.Pointer(&hash[0]), C.size_t(len(hash)))
+	if err == 0 {
+		return sign
+	} else {
+		return nil
+	}
+}
+
+// VerifyHash --
+func (sign *Sign) VerifyHash(pub *PublicKey, hash []byte) bool {
+	if pub.getPointer() == nil {
+		return false
+	}
+	// #nosec
+	return C.blsVerifyHash(sign.getPointer(), pub.getPointer(), unsafe.Pointer(&hash[0]), C.size_t(len(hash))) == 1
+}
+
+func Min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+// VerifyAggregateHashes --
+func (sign *Sign) VerifyAggregateHashes(pubVec []PublicKey, hash [][]byte) bool {
+	hashByte := GetOpUnitSize() * 8
+	n := len(hash)
+	h := make([]byte, n*hashByte)
+	for i := 0; i < n; i++ {
+		hn := len(hash[i])
+		copy(h[i*hashByte:(i+1)*hashByte], hash[i][0:Min(hn, hashByte)])
+	}
+	if pubVec[0].getPointer() == nil {
+		return false
+	}
+	return C.blsVerifyAggregatedHashes(sign.getPointer(), pubVec[0].getPointer(), unsafe.Pointer(&h[0]), C.size_t(hashByte), C.size_t(n)) == 1
+}
+
+///
+
+var s_randReader io.Reader
+
+func createSlice(buf *C.char, n C.uint) []byte {
+	size := int(n)
+	return (*[1 << 30]byte)(unsafe.Pointer(buf))[:size:size]
+}
+
+// this function can't be put in callback.go
+//export wrapReadRandGo
+func wrapReadRandGo(buf *C.char, n C.uint) C.uint {
+	slice := createSlice(buf, n)
+	ret, err := s_randReader.Read(slice)
+	if ret == int(n) && err == nil {
+		return n
+	}
+	return 0
+}
+
+// SetRandFunc --
+func SetRandFunc(randReader io.Reader) {
+	s_randReader = randReader
+	if randReader != nil {
+		C.blsSetRandFunc(nil, C.ReadRandFunc(unsafe.Pointer(C.wrapReadRandCgo)))
+	} else {
+		// use default random generator
+		C.blsSetRandFunc(nil, C.ReadRandFunc(unsafe.Pointer(nil)))
+	}
+}
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls_test.go b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls_test.go
new file mode 100644
index 000000000..a13ee02f4
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/bls_test.go
@@ -0,0 +1,690 @@
+package bls
+
+import "testing"
+import "strconv"
+import "crypto/sha256"
+import "crypto/sha512"
+import "fmt"
+import "crypto/rand"
+
+var unitN = 0
+
+// Tests (for Benchmarks see below)
+
+func testPre(t *testing.T) {
+	t.Log("init")
+	{
+		var id ID
+		err := id.SetLittleEndian([]byte{6, 5, 4, 3, 2, 1})
+		if err != nil {
+			t.Error(err)
+		}
+		t.Log("id :", id.GetHexString())
+		var id2 ID
+		err = id2.SetHexString(id.GetHexString())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !id.IsEqual(&id2) {
+			t.Errorf("not same id\n%s\n%s", id.GetHexString(), id2.GetHexString())
+		}
+		err = id2.SetDecString(id.GetDecString())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !id.IsEqual(&id2) {
+			t.Errorf("not same id\n%s\n%s", id.GetDecString(), id2.GetDecString())
+		}
+	}
+	{
+		var sec SecretKey
+		err := sec.SetLittleEndian([]byte{1, 2, 3, 4, 5, 6})
+		if err != nil {
+			t.Error(err)
+		}
+		t.Log("sec=", sec.GetHexString())
+	}
+
+	t.Log("create secret key")
+	m := "this is a bls sample for go"
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	t.Log("sec:", sec.GetHexString())
+	t.Log("create public key")
+	pub := sec.GetPublicKey()
+	t.Log("pub:", pub.GetHexString())
+	sign := sec.Sign(m)
+	t.Log("sign:", sign.GetHexString())
+	if !sign.Verify(pub, m) {
+		t.Error("Signature does not verify")
+	}
+
+	// How to make array of SecretKey
+	{
+		sec := make([]SecretKey, 3)
+		for i := 0; i < len(sec); i++ {
+			sec[i].SetByCSPRNG()
+			t.Log("sec=", sec[i].GetHexString())
+		}
+	}
+}
+
+func testStringConversion(t *testing.T) {
+	t.Log("testRecoverSecretKey")
+	var sec SecretKey
+	var s string
+	if unitN == 6 {
+		s = "16798108731015832284940804142231733909759579603404752749028378864165570215949"
+	} else {
+		s = "40804142231733909759579603404752749028378864165570215949"
+	}
+	err := sec.SetDecString(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if s != sec.GetDecString() {
+		t.Error("not equal")
+	}
+	s = sec.GetHexString()
+	var sec2 SecretKey
+	err = sec2.SetHexString(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !sec.IsEqual(&sec2) {
+		t.Error("not equal")
+	}
+}
+
+func testRecoverSecretKey(t *testing.T) {
+	t.Log("testRecoverSecretKey")
+	k := 3000
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	t.Logf("sec=%s\n", sec.GetHexString())
+
+	// make master secret key
+	msk := sec.GetMasterSecretKey(k)
+
+	n := k
+	secVec := make([]SecretKey, n)
+	idVec := make([]ID, n)
+	for i := 0; i < n; i++ {
+		err := idVec[i].SetLittleEndian([]byte{byte(i & 255), byte(i >> 8), 2, 3, 4, 5})
+		if err != nil {
+			t.Error(err)
+		}
+		err = secVec[i].Set(msk, &idVec[i])
+		if err != nil {
+			t.Error(err)
+		}
+		//		t.Logf("idVec[%d]=%s\n", i, idVec[i].GetHexString())
+	}
+	// recover sec2 from secVec and idVec
+	var sec2 SecretKey
+	err := sec2.Recover(secVec, idVec)
+	if err != nil {
+		t.Error(err)
+	}
+	if !sec.IsEqual(&sec2) {
+		t.Errorf("Mismatch in recovered secret key:\n  %s\n  %s.", sec.GetHexString(), sec2.GetHexString())
+	}
+}
+
+func testEachSign(t *testing.T, m string, msk []SecretKey, mpk []PublicKey) ([]ID, []SecretKey, []PublicKey, []Sign) {
+	idTbl := []byte{3, 5, 193, 22, 15}
+	n := len(idTbl)
+
+	secVec := make([]SecretKey, n)
+	pubVec := make([]PublicKey, n)
+	signVec := make([]Sign, n)
+	idVec := make([]ID, n)
+
+	for i := 0; i < n; i++ {
+		err := idVec[i].SetLittleEndian([]byte{idTbl[i], 0, 0, 0, 0, 0})
+		if err != nil {
+			t.Error(err)
+		}
+		t.Logf("idVec[%d]=%s\n", i, idVec[i].GetHexString())
+
+		err = secVec[i].Set(msk, &idVec[i])
+		if err != nil {
+			t.Error(err)
+		}
+
+		err = pubVec[i].Set(mpk, &idVec[i])
+		if err != nil {
+			t.Error(err)
+		}
+		t.Logf("pubVec[%d]=%s\n", i, pubVec[i].GetHexString())
+
+		if !pubVec[i].IsEqual(secVec[i].GetPublicKey()) {
+			t.Errorf("Pubkey derivation does not match\n%s\n%s", pubVec[i].GetHexString(), secVec[i].GetPublicKey().GetHexString())
+		}
+
+		signVec[i] = *secVec[i].Sign(m)
+		if !signVec[i].Verify(&pubVec[i], m) {
+			t.Error("Pubkey derivation does not match")
+		}
+	}
+	return idVec, secVec, pubVec, signVec
+}
+func testSign(t *testing.T) {
+	m := "testSign"
+	t.Log(m)
+
+	var sec0 SecretKey
+	sec0.SetByCSPRNG()
+	pub0 := sec0.GetPublicKey()
+	s0 := sec0.Sign(m)
+	if !s0.Verify(pub0, m) {
+		t.Error("Signature does not verify")
+	}
+
+	k := 3
+	msk := sec0.GetMasterSecretKey(k)
+	mpk := GetMasterPublicKey(msk)
+	idVec, secVec, pubVec, signVec := testEachSign(t, m, msk, mpk)
+
+	var sec1 SecretKey
+	err := sec1.Recover(secVec, idVec)
+	if err != nil {
+		t.Error(err)
+	}
+	if !sec0.IsEqual(&sec1) {
+		t.Error("Mismatch in recovered seckey.")
+	}
+	var pub1 PublicKey
+	err = pub1.Recover(pubVec, idVec)
+	if err != nil {
+		t.Error(err)
+	}
+	if !pub0.IsEqual(&pub1) {
+		t.Error("Mismatch in recovered pubkey.")
+	}
+	var s1 Sign
+	err = s1.Recover(signVec, idVec)
+	if err != nil {
+		t.Error(err)
+	}
+	if !s0.IsEqual(&s1) {
+		t.Error("Mismatch in recovered signature.")
+	}
+}
+
+func testAdd(t *testing.T) {
+	t.Log("testAdd")
+	var sec1 SecretKey
+	var sec2 SecretKey
+	sec1.SetByCSPRNG()
+	sec2.SetByCSPRNG()
+
+	pub1 := sec1.GetPublicKey()
+	pub2 := sec2.GetPublicKey()
+
+	m := "test test"
+	sign1 := sec1.Sign(m)
+	sign2 := sec2.Sign(m)
+
+	t.Log("sign1    :", sign1.GetHexString())
+	sign1.Add(sign2)
+	t.Log("sign1 add:", sign1.GetHexString())
+	pub1.Add(pub2)
+	if !sign1.Verify(pub1, m) {
+		t.Fail()
+	}
+}
+
+func testPop(t *testing.T) {
+	t.Log("testPop")
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	pop := sec.GetPop()
+	if !pop.VerifyPop(sec.GetPublicKey()) {
+		t.Errorf("Valid Pop does not verify")
+	}
+	sec.SetByCSPRNG()
+	if pop.VerifyPop(sec.GetPublicKey()) {
+		t.Errorf("Invalid Pop verifies")
+	}
+}
+
+func testData(t *testing.T) {
+	t.Log("testData")
+	var sec1, sec2 SecretKey
+	sec1.SetByCSPRNG()
+	b := sec1.GetLittleEndian()
+	err := sec2.SetLittleEndian(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !sec1.IsEqual(&sec2) {
+		t.Error("SecretKey not same")
+	}
+	pub1 := sec1.GetPublicKey()
+	b = pub1.Serialize()
+	var pub2 PublicKey
+	err = pub2.Deserialize(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !pub1.IsEqual(&pub2) {
+		t.Error("PublicKey not same")
+	}
+	m := "doremi"
+	sign1 := sec1.Sign(m)
+	b = sign1.Serialize()
+	var sign2 Sign
+	err = sign2.Deserialize(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !sign1.IsEqual(&sign2) {
+		t.Error("Sign not same")
+	}
+}
+
+func testSerializeToHexStr(t *testing.T) {
+	t.Log("testSerializeToHexStr")
+	var sec1, sec2 SecretKey
+	sec1.SetByCSPRNG()
+	s := sec1.SerializeToHexStr()
+	err := sec2.DeserializeHexStr(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !sec1.IsEqual(&sec2) {
+		t.Error("SecretKey not same")
+	}
+	pub1 := sec1.GetPublicKey()
+	s = pub1.SerializeToHexStr()
+	var pub2 PublicKey
+	err = pub2.DeserializeHexStr(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !pub1.IsEqual(&pub2) {
+		t.Error("PublicKey not same")
+	}
+	m := "doremi"
+	sign1 := sec1.Sign(m)
+	s = sign1.SerializeToHexStr()
+	var sign2 Sign
+	err = sign2.DeserializeHexStr(s)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !sign1.IsEqual(&sign2) {
+		t.Error("Sign not same")
+	}
+}
+
+func testOrder(t *testing.T, c int) {
+	var curve string
+	var field string
+	if c == CurveFp254BNb {
+		curve = "16798108731015832284940804142231733909759579603404752749028378864165570215949"
+		field = "16798108731015832284940804142231733909889187121439069848933715426072753864723"
+	} else if c == CurveFp382_1 {
+		curve = "5540996953667913971058039301942914304734176495422447785042938606876043190415948413757785063597439175372845535461389"
+		field = "5540996953667913971058039301942914304734176495422447785045292539108217242186829586959562222833658991069414454984723"
+	} else if c == CurveFp382_2 {
+		curve = "5541245505022739011583672869577435255026888277144126952448297309161979278754528049907713682488818304329661351460877"
+		field = "5541245505022739011583672869577435255026888277144126952450651294188487038640194767986566260919128250811286032482323"
+	} else if c == BLS12_381 {
+		curve = "52435875175126190479447740508185965837690552500527637822603658699938581184513"
+		field = "4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"
+	} else {
+		t.Fatal("bad c", c)
+	}
+	s := GetCurveOrder()
+	if s != curve {
+		t.Errorf("bad curve order\n%s\n%s\n", s, curve)
+	}
+	s = GetFieldOrder()
+	if s != field {
+		t.Errorf("bad field order\n%s\n%s\n", s, field)
+	}
+}
+
+func testDHKeyExchange(t *testing.T) {
+	var sec1, sec2 SecretKey
+	sec1.SetByCSPRNG()
+	sec2.SetByCSPRNG()
+	pub1 := sec1.GetPublicKey()
+	pub2 := sec2.GetPublicKey()
+	out1 := DHKeyExchange(&sec1, pub2)
+	out2 := DHKeyExchange(&sec2, pub1)
+	if !out1.IsEqual(&out2) {
+		t.Errorf("DH key is not equal")
+	}
+}
+
+func testPairing(t *testing.T) {
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	pub := sec.GetPublicKey()
+	m := "abc"
+	sig1 := sec.Sign(m)
+	sig2 := HashAndMapToSignature([]byte(m))
+	if !VerifyPairing(sig1, sig2, pub) {
+		t.Errorf("VerifyPairing")
+	}
+}
+
+func testAggregate(t *testing.T) {
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	pub := sec.GetPublicKey()
+	msgTbl := []string{"abc", "def", "123"}
+	n := len(msgTbl)
+	sigVec := make([]*Sign, n)
+	for i := 0; i < n; i++ {
+		m := msgTbl[i]
+		sigVec[i] = sec.Sign(m)
+	}
+	aggSign := sigVec[0]
+	for i := 1; i < n; i++ {
+		aggSign.Add(sigVec[i])
+	}
+	hashPt := HashAndMapToSignature([]byte(msgTbl[0]))
+	for i := 1; i < n; i++ {
+		hashPt.Add(HashAndMapToSignature([]byte(msgTbl[i])))
+	}
+	if !VerifyPairing(aggSign, hashPt, pub) {
+		t.Errorf("aggregate2")
+	}
+}
+
+func Hash(buf []byte) []byte {
+	if GetOpUnitSize() == 4 {
+		d := sha256.Sum256([]byte(buf))
+		return d[:]
+	} else {
+		// use SHA512 if bitSize > 256
+		d := sha512.Sum512([]byte(buf))
+		return d[:]
+	}
+}
+
+func testHash(t *testing.T) {
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	pub := sec.GetPublicKey()
+	m := "abc"
+	h := Hash([]byte(m))
+	sig1 := sec.Sign(m)
+	sig2 := sec.SignHash(h)
+	if !sig1.IsEqual(sig2) {
+		t.Errorf("SignHash")
+	}
+	if !sig1.Verify(pub, m) {
+		t.Errorf("sig1.Verify")
+	}
+	if !sig2.VerifyHash(pub, h) {
+		t.Errorf("sig2.VerifyHash")
+	}
+}
+
+func testAggregateHashes(t *testing.T) {
+	n := 1000
+	pubVec := make([]PublicKey, n)
+	sigVec := make([]*Sign, n)
+	h := make([][]byte, n)
+	for i := 0; i < n; i++ {
+		sec := new(SecretKey)
+		sec.SetByCSPRNG()
+		pubVec[i] = *sec.GetPublicKey()
+		m := fmt.Sprintf("abc-%d", i)
+		h[i] = Hash([]byte(m))
+		sigVec[i] = sec.SignHash(h[i])
+	}
+	// aggregate sig
+	sig := sigVec[0]
+	for i := 1; i < n; i++ {
+		sig.Add(sigVec[i])
+	}
+	if !sig.VerifyAggregateHashes(pubVec, h) {
+		t.Errorf("sig.VerifyAggregateHashes")
+	}
+}
+
+type SeqRead struct {
+}
+
+func (self *SeqRead) Read(buf []byte) (int, error) {
+	n := len(buf)
+	for i := 0; i < n; i++ {
+		buf[i] = byte(i)
+	}
+	return n, nil
+}
+
+func testReadRand(t *testing.T) {
+	s1 := new(SeqRead)
+	SetRandFunc(s1)
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	buf := sec.GetLittleEndian()
+	fmt.Printf("(SeqRead) buf=%x\n", buf)
+	for i := 0; i < len(buf)-1; i++ {
+		// ommit buf[len(buf) - 1] because it may be masked
+		if buf[i] != byte(i) {
+			t.Fatal("buf")
+		}
+	}
+	SetRandFunc(rand.Reader)
+	sec.SetByCSPRNG()
+	buf = sec.GetLittleEndian()
+	fmt.Printf("(rand.Reader) buf=%x\n", buf)
+	SetRandFunc(nil)
+	sec.SetByCSPRNG()
+	buf = sec.GetLittleEndian()
+	fmt.Printf("(default) buf=%x\n", buf)
+}
+
+func test(t *testing.T, c int) {
+	err := Init(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	unitN = GetOpUnitSize()
+	t.Logf("unitN=%d\n", unitN)
+	testReadRand(t)
+	testPre(t)
+	testRecoverSecretKey(t)
+	testAdd(t)
+	testSign(t)
+	testPop(t)
+	testData(t)
+	testStringConversion(t)
+	testOrder(t, c)
+	testDHKeyExchange(t)
+	testSerializeToHexStr(t)
+	testPairing(t)
+	testAggregate(t)
+	testHash(t)
+	testAggregateHashes(t)
+}
+
+func TestMain(t *testing.T) {
+	t.Logf("GetMaxOpUnitSize() = %d\n", GetMaxOpUnitSize())
+	t.Log("CurveFp254BNb")
+	test(t, CurveFp254BNb)
+	if GetMaxOpUnitSize() == 6 {
+		if GetFrUnitSize() == 6 {
+			t.Log("CurveFp382_1")
+			test(t, CurveFp382_1)
+		}
+		t.Log("BLS12_381")
+		test(t, BLS12_381)
+	}
+}
+
+// Benchmarks
+
+var curve = CurveFp382_1
+
+//var curve = CurveFp254BNb
+
+func BenchmarkPubkeyFromSeckey(b *testing.B) {
+	b.StopTimer()
+	err := Init(curve)
+	if err != nil {
+		b.Fatal(err)
+	}
+	var sec SecretKey
+	for n := 0; n < b.N; n++ {
+		sec.SetByCSPRNG()
+		b.StartTimer()
+		sec.GetPublicKey()
+		b.StopTimer()
+	}
+}
+
+func BenchmarkSigning(b *testing.B) {
+	b.StopTimer()
+	err := Init(curve)
+	if err != nil {
+		b.Fatal(err)
+	}
+	var sec SecretKey
+	for n := 0; n < b.N; n++ {
+		sec.SetByCSPRNG()
+		b.StartTimer()
+		sec.Sign(strconv.Itoa(n))
+		b.StopTimer()
+	}
+}
+
+func BenchmarkValidation(b *testing.B) {
+	b.StopTimer()
+	err := Init(curve)
+	if err != nil {
+		b.Fatal(err)
+	}
+	var sec SecretKey
+	for n := 0; n < b.N; n++ {
+		sec.SetByCSPRNG()
+		pub := sec.GetPublicKey()
+		m := strconv.Itoa(n)
+		sig := sec.Sign(m)
+		b.StartTimer()
+		sig.Verify(pub, m)
+		b.StopTimer()
+	}
+}
+
+func benchmarkDeriveSeckeyShare(k int, b *testing.B) {
+	b.StopTimer()
+	err := Init(curve)
+	if err != nil {
+		b.Fatal(err)
+	}
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	msk := sec.GetMasterSecretKey(k)
+	var id ID
+	for n := 0; n < b.N; n++ {
+		err = id.SetLittleEndian([]byte{1, 2, 3, 4, 5, byte(n)})
+		if err != nil {
+			b.Error(err)
+		}
+		b.StartTimer()
+		err := sec.Set(msk, &id)
+		b.StopTimer()
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+//func BenchmarkDeriveSeckeyShare100(b *testing.B)  { benchmarkDeriveSeckeyShare(100, b) }
+//func BenchmarkDeriveSeckeyShare200(b *testing.B)  { benchmarkDeriveSeckeyShare(200, b) }
+func BenchmarkDeriveSeckeyShare500(b *testing.B) { benchmarkDeriveSeckeyShare(500, b) }
+
+//func BenchmarkDeriveSeckeyShare1000(b *testing.B) { benchmarkDeriveSeckeyShare(1000, b) }
+
+func benchmarkRecoverSeckey(k int, b *testing.B) {
+	b.StopTimer()
+	err := Init(curve)
+	if err != nil {
+		b.Fatal(err)
+	}
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	msk := sec.GetMasterSecretKey(k)
+
+	// derive n shares
+	n := k
+	secVec := make([]SecretKey, n)
+	idVec := make([]ID, n)
+	for i := 0; i < n; i++ {
+		err := idVec[i].SetLittleEndian([]byte{1, 2, 3, 4, 5, byte(i)})
+		if err != nil {
+			b.Error(err)
+		}
+		err = secVec[i].Set(msk, &idVec[i])
+		if err != nil {
+			b.Error(err)
+		}
+	}
+
+	// recover from secVec and idVec
+	var sec2 SecretKey
+	b.StartTimer()
+	for n := 0; n < b.N; n++ {
+		err := sec2.Recover(secVec, idVec)
+		if err != nil {
+			b.Errorf("%s\n", err)
+		}
+	}
+}
+
+func BenchmarkRecoverSeckey100(b *testing.B)  { benchmarkRecoverSeckey(100, b) }
+func BenchmarkRecoverSeckey200(b *testing.B)  { benchmarkRecoverSeckey(200, b) }
+func BenchmarkRecoverSeckey500(b *testing.B)  { benchmarkRecoverSeckey(500, b) }
+func BenchmarkRecoverSeckey1000(b *testing.B) { benchmarkRecoverSeckey(1000, b) }
+
+func benchmarkRecoverSignature(k int, b *testing.B) {
+	b.StopTimer()
+	err := Init(curve)
+	if err != nil {
+		b.Fatal(err)
+	}
+	var sec SecretKey
+	sec.SetByCSPRNG()
+	msk := sec.GetMasterSecretKey(k)
+
+	// derive n shares
+	n := k
+	idVec := make([]ID, n)
+	secVec := make([]SecretKey, n)
+	signVec := make([]Sign, n)
+	for i := 0; i < n; i++ {
+		err := idVec[i].SetLittleEndian([]byte{1, 2, 3, 4, 5, byte(i)})
+		if err != nil {
+			b.Error(err)
+		}
+		err = secVec[i].Set(msk, &idVec[i])
+		if err != nil {
+			b.Error(err)
+		}
+		signVec[i] = *secVec[i].Sign("test message")
+	}
+
+	// recover signature
+	var sig Sign
+	b.StartTimer()
+	for n := 0; n < b.N; n++ {
+		err := sig.Recover(signVec, idVec)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkRecoverSignature100(b *testing.B)  { benchmarkRecoverSignature(100, b) }
+func BenchmarkRecoverSignature200(b *testing.B)  { benchmarkRecoverSignature(200, b) }
+func BenchmarkRecoverSignature500(b *testing.B)  { benchmarkRecoverSignature(500, b) }
+func BenchmarkRecoverSignature1000(b *testing.B) { benchmarkRecoverSignature(1000, b) }
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/callback.go b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/callback.go
new file mode 100644
index 000000000..ba73a5e15
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/callback.go
@@ -0,0 +1,12 @@
+package bls
+
+/*
+// exported from bls.go
+unsigned int wrapReadRandGo(void *buf, unsigned int n);
+int wrapReadRandCgo(void *self, void *buf, unsigned int n)
+{
+	(void)self;
+	return wrapReadRandGo(buf, n);
+}
+*/
+import "C"
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/config.h b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/config.h
new file mode 100644
index 000000000..07e148137
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/config.h
@@ -0,0 +1,6 @@
+#pragma
+// use bn384 unless tags is specified
+#ifndef MCLBN_FP_UNIT_SIZE
+	#define MCLBN_FP_UNIT_SIZE 6
+#endif
+
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/dummy.cpp b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/dummy.cpp
new file mode 100644
index 000000000..a5103a1c5
--- /dev/null
+++ b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/dummy.cpp
@@ -0,0 +1,3 @@
+// This is a dummy source file which forces cgo to use the C++ linker instead
+// of the default C linker. We can therefore eliminate non-portable linker
+// flags such as -lstdc++, which is likely to break on FreeBSD and OpenBSD.
diff --git a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/mcl.go b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/mcl.go
index 9771201ec..ca8d7f02b 100644
--- a/vendor/github.com/dexon-foundation/bls/ffi/go/bls/mcl.go
+++ b/vendor/github.com/dexon-foundation/bls/ffi/go/bls/mcl.go
@@ -1,7 +1,10 @@
 package bls
 
 /*
-#cgo CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
+#cgo bn256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=4
+#cgo bn384 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
+#cgo bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6 -DMCLBN_FR_UNIT_SIZE=4
+#cgo !bn256,!bn384,!bn384_256 CFLAGS:-DMCLBN_FP_UNIT_SIZE=6
 #include <mcl/bn.h>
 */
 import "C"
@@ -23,6 +26,17 @@ const BLS12_381 = C.MCL_BLS12_381
 // IoSerializeHexStr
 const IoSerializeHexStr = C.MCLBN_IO_SERIALIZE_HEX_STR
 
+// GetFrUnitSize() --
+func GetFrUnitSize() int {
+	return int(C.MCLBN_FR_UNIT_SIZE)
+}
+
+// GetFpUnitSize() --
+// same as GetMaxOpUnitSize()
+func GetFpUnitSize() int {
+	return int(C.MCLBN_FP_UNIT_SIZE)
+}
+
 // GetMaxOpUnitSize --
 func GetMaxOpUnitSize() int {
 	return int(C.MCLBN_FP_UNIT_SIZE)