[js] refactor bls.js

6 files changed, 1332 insertions, 741 deletions

diff --git a/Makefile b/Makefile
index 9889889..2cc1ae4 100644
--- a/Makefile
+++ b/Makefile
@@ -86,13 +86,13 @@ test_go: go/bls/bls.go go/bls/bls_test.go $(BLS384_SLIB)
 	cd go/bls && ln -sf ../../lib . && env LD_RUN_PATH="../../lib" CGO_CFLAGS="-I../../include -I../../../mcl/include" CGO_LDFLAGS="-L../../lib -L../../../mcl/lib" go test $(MAC_GO_LDFLAGS) .
 
 EXPORTED_TXT=ffi/js/exported-bls.txt
-EXPORTED_JS=docs/demo/exported-bls.js
+EXPORTED_JS=docs/demo/exported-bls.json
 EXPORT_OPT=-re ffi/js/bls-re.txt
 $(EXPORTED_TXT): ./include/bls/bls.h ../mcl/include/mcl/bn.h
 	python ../mcl/ffi/js/export-functions.py $(EXPORT_OPT) $^ > $@
 
 $(EXPORTED_JS): ./include/bls/bls.h ../mcl/include/mcl/bn.h
-	python ../mcl/ffi/js/export-functions.py $(EXPORT_OPT) -js bls $^ > $@
+	python ../mcl/ffi/js/export-functions.py $(EXPORT_OPT) -json $^ > $@
 
 EXPORTED_BLS=$(shell cat $(EXPORTED_TXT))
 
diff --git a/docs/demo/bls-demo.js b/docs/demo/bls-demo.js
index 6c80a31..e6db3a0 100644
--- a/docs/demo/bls-demo.js
+++ b/docs/demo/bls-demo.js
@@ -3,47 +3,28 @@ function setValue(name, val) { document.getElementsByName(name)[0].value = val }
 function getText(name) { return document.getElementsByName(name)[0].innerText }
 function setText(name, val) { document.getElementsByName(name)[0].innerText = val }
 
-let moduleInited = false
-
-let module = setupWasm('bls_c.wasm', null, function(mod, ns) {
-	define_exported_bls(mod)
-	define_bls_extra_functions(mod)
-	moduleInited = true
-	onChangeSelectCurve()
+bls.init(bls.MCLBN_CURVE_FP254BNB, function() {
+	setText('status', 'ok')
+	setText('curveOrder', bls.capi.blsGetCurveOrder())
 })
 
-function putId(x, msg = "") {
-	console.log(msg + ' id=' + Uint8ArrayToHexString(blsIdSerialize(x)))
-}
-function putSecretKey(x, msg = "") {
-	console.log(msg + ' sk=' + Uint8ArrayToHexString(blsSecretKeySerialize(x)))
-}
-function putPublicKey(x, msg = "") {
-	console.log(msg + ' pk=' + Uint8ArrayToHexString(blsPublicKeySerialize(x)))
-}
-function putSignature(x, msg = "") {
-	console.log(msg + ' sig=' + Uint8ArrayToHexString(blsSignatureSerialize(x)))
-}
-
 let prevSelectedCurve = -1
 function onChangeSelectCurve() {
-	if (!moduleInited) return
 	let obj = document.selectCurve.curveType
 	let idx = obj.selectedIndex
 	let curve = obj.options[idx].value
 	if (curve == prevSelectedCurve) return
 	prevSelectedCurve = curve
 	console.log('idx=' + idx)
-	let r = blsInit(idx)
+	let r = bls.capi.blsInit(idx)
 	setText('status', r ? 'err:' + r : 'ok')
-	setText('curveOrder', blsGetCurveOrder())
+	setText('curveOrder', bls.capi.blsGetCurveOrder())
 }
 
 function rand(val) {
-	let x = mclBnFr_malloc()
-	mclBnFr_setByCSPRNG(x)
-	setValue(val, mclBnFr_getStr(x))
-	mcl_free(x)
+	let x = new she.Id()
+	x.setByCSPRNG()
+	setValue(val, c.toHexStr())
 }
 
 function bench(label, count, func) {
@@ -57,47 +38,48 @@ function bench(label, count, func) {
 }
 
 function benchPairing() {
-	let a = mclBnFr_malloc()
-	let P = mclBnG1_malloc()
-	let Q = mclBnG2_malloc()
-	let e = mclBnGT_malloc()
+	let capi = bls.capi
+	let a = capi.mclBnFr_malloc()
+	let P = capi.mclBnG1_malloc()
+	let Q = capi.mclBnG2_malloc()
+	let e = capi.mclBnGT_malloc()
 
 	let msg = 'hello wasm'
 
-	mclBnFr_setByCSPRNG(a)
-	console.log('a=' + mclBnFr_getStr(a))
-	mclBnG1_hashAndMapTo(P, 'abc')
-	mclBnG2_hashAndMapTo(Q, 'abc')
-	console.log('P=' + mclBnG1_getStr(P))
-	console.log('Q=' + mclBnG2_getStr(Q))
-	bench('time_pairing', 50, () => mclBn_pairing(e, P, Q))
-	bench('time_g1mul', 50, () => mclBnG1_mulCT(P, P, a))
-	bench('time_g2mul', 50, () => mclBnG2_mulCT(Q, Q, a))
-	bench('time_mapToG1', 50, () => mclBnG1_hashAndMapTo(P, msg))
-
-	mcl_free(e)
-	mcl_free(Q)
-	mcl_free(P)
-	mcl_free(a)
-
-	let sec = new BlsSecretKey()
+	capi.mclBnFr_setByCSPRNG(a)
+	console.log('a=' + capi.mclBnFr_getStr(a))
+	capi.mclBnG1_hashAndMapTo(P, 'abc')
+	capi.mclBnG2_hashAndMapTo(Q, 'abc')
+	console.log('P=' + capi.mclBnG1_getStr(P))
+	console.log('Q=' + capi.mclBnG2_getStr(Q))
+	bench('time_pairing', 50, () => capi.mclBn_pairing(e, P, Q))
+	bench('time_g1mul', 50, () => capi.mclBnG1_mulCT(P, P, a))
+	bench('time_g2mul', 50, () => capi.mclBnG2_mulCT(Q, Q, a))
+	bench('time_mapToG1', 50, () => capi.mclBnG1_hashAndMapTo(P, msg))
+
+	capi.mcl_free(e)
+	capi.mcl_free(Q)
+	capi.mcl_free(P)
+
+	let sec = new bls.SecretKey()
 	bench('time_setByCSPRNG', 50, () => sec.setByCSPRNG())
 }
 
 function benchBls() {
-	let sec = blsSecretKey_malloc()
-	let pub = blsPublicKey_malloc()
-	let sig = blsSignature_malloc()
+	let capi = bls.capi
+	let sec = capi.blsSecretKey_malloc()
+	let pub = capi.blsPublicKey_malloc()
+	let sig = capi.blsSignature_malloc()
 
-	blsSecretKeySetByCSPRNG(sec)
+	capi.blsSecretKeySetByCSPRNG(sec)
 	let msg = "hello wasm"
-	bench('time_sign', 50, () => blsSign(sig, sec, msg))
-	bench('time_verify', 50, () => blsVerify(sig, pub, msg))
+	bench('time_sign', 50, () => capi.blsSign(sig, sec, msg))
+	bench('time_verify', 50, () => capi.blsVerify(sig, pub, msg))
 
-	bls_free(sec)
-	bls_free(pub)
-	bls_free(sig)
-	sec = new BlsSecretKey()
+	capi.bls_free(sec)
+	capi.bls_free(pub)
+	capi.bls_free(sig)
+	sec = new bls.SecretKey()
 	sec.setByCSPRNG()
 	pub = sec.getPublicKey()
 	bench('time_sign_class', 50, () => sec.sign(msg))
@@ -110,93 +92,68 @@ function onClickBenchmark() {
 }
 
 function onClickTestPairing() {
+	let capi = bls.capi
 	document.getElementById('testPairing').disabled = true
-	let a = mclBnFr_malloc()
-	let b = mclBnFr_malloc()
-	let ab = mclBnFr_malloc()
-	let P = mclBnG1_malloc()
-	let aP = mclBnG1_malloc()
-	let Q = mclBnG2_malloc()
-	let bQ = mclBnG2_malloc()
-	let e1 = mclBnGT_malloc()
-	let e2 = mclBnGT_malloc()
-
-	mclBnFr_setStr(a, getValue('a'))
-	mclBnFr_setStr(b, getValue('b'))
-	mclBnFr_mul(ab, a, b)
-	setText('ab', mclBnFr_getStr(ab))
-
-	mclBnG1_hashAndMapTo(P, getValue('hash_P'))
-	setText('P', mclBnG1_getStr(P))
-	mclBnG2_hashAndMapTo(Q, getValue('hash_Q'))
-	setText('Q', mclBnG2_getStr(Q))
-	mclBnG1_mul(aP, P, a)
-	setText('aP', mclBnG1_getStr(aP))
-	mclBnG2_mul(bQ, Q, b)
-	setText('bQ', mclBnG2_getStr(bQ))
-
-	mclBn_pairing(e1, P, Q);
-	setText('ePQ', mclBnGT_getStr(e1))
-	mclBn_pairing(e2, aP, bQ);
-	setText('eaPbQ', mclBnGT_getStr(e2))
-	mclBnGT_pow(e1, e1, ab)
-	setText('ePQab', mclBnGT_getStr(e1))
-	setText('verify_pairing', !!mclBnGT_isEqual(e1, e2))
-
-	mcl_free(e2)
-	mcl_free(e1)
-	mcl_free(bQ)
-	mcl_free(Q)
-	mcl_free(aP)
-	mcl_free(P)
-	mcl_free(ab)
-	mcl_free(b)
-	mcl_free(a)
+	let a = capi.mclBnFr_malloc()
+	let b = capi.mclBnFr_malloc()
+	let ab = capi.mclBnFr_malloc()
+	let P = capi.mclBnG1_malloc()
+	let aP = capi.mclBnG1_malloc()
+	let Q = capi.mclBnG2_malloc()
+	let bQ = capi.mclBnG2_malloc()
+	let e1 = capi.mclBnGT_malloc()
+	let e2 = capi.mclBnGT_malloc()
+
+	capi.mclBnFr_setStr(a, getValue('a'))
+	capi.mclBnFr_setStr(b, getValue('b'))
+	capi.mclBnFr_mul(ab, a, b)
+	setText('ab', capi.mclBnFr_getStr(ab))
+
+	capi.mclBnG1_hashAndMapTo(P, getValue('hash_P'))
+	setText('P', capi.mclBnG1_getStr(P))
+	capi.mclBnG2_hashAndMapTo(Q, getValue('hash_Q'))
+	setText('Q', capi.mclBnG2_getStr(Q))
+	capi.mclBnG1_mul(aP, P, a)
+	setText('aP', capi.mclBnG1_getStr(aP))
+	capi.mclBnG2_mul(bQ, Q, b)
+	setText('bQ', capi.mclBnG2_getStr(bQ))
+
+	capi.mclBn_pairing(e1, P, Q);
+	setText('ePQ', capi.mclBnGT_getStr(e1))
+	capi.mclBn_pairing(e2, aP, bQ);
+	setText('eaPbQ', capi.mclBnGT_getStr(e2))
+	capi.mclBnGT_pow(e1, e1, ab)
+	setText('ePQab', capi.mclBnGT_getStr(e1))
+	setText('verify_pairing', !!capi.mclBnGT_isEqual(e1, e2))
+
+	capi.mcl_free(e2)
+	capi.mcl_free(e1)
+	capi.mcl_free(bQ)
+	capi.mcl_free(Q)
+	capi.mcl_free(aP)
+	capi.mcl_free(P)
+	capi.mcl_free(ab)
+	capi.mcl_free(b)
+	capi.mcl_free(a)
 	document.getElementById('testPairing').disabled = false
 }
 
-function Uint8ArrayToHexString(a) {
-	let s = ''
-	for (let i = 0; i < a.length; i++) {
-		s += ('0' + a[i].toString(16)).slice(-2)
-	}
-	return s
-}
-
-function HexStringToUint8Array(s) {
-	let n = (s.length + 1) / 2
-	let a = new Uint8Array(n)
-	for (let i = 0; i < s.length / 2; i++) {
-		a[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16)
-	}
-	if ((s.length & 1) != 0) {
-		a[n - 1] = parseInt(s[s.length - 1] + '0', 16)
-	}
-	return a
-}
-
 function onClickTestSignature() {
-	let secretKey = blsSecretKey_malloc()
-	let publicKey = blsPublicKey_malloc()
-	let signature = blsSignature_malloc()
+	let sec = new bls.SecretKey()
 
-	blsSecretKeySetByCSPRNG(secretKey)
-	setText('secretKey', Uint8ArrayToHexString(blsSecretKeySerialize(secretKey)))
+	sec.setByCSPRNG()
+	setText('secretKey', sec.toHexStr())
 
-	blsGetPublicKey(publicKey, secretKey)
-	setText('publicKey', Uint8ArrayToHexString(blsPublicKeySerialize(publicKey)))
+	let pub = sec.getPublicKey()
+	setText('publicKey', pub.toHexStr())
 
 	let msg = getValue('msg')
 	console.log('msg=' + msg)
-	blsSign(signature, secretKey, msg)
-	setText('signature', Uint8ArrayToHexString(blsSignatureSerialize(signature)))
+	let sig = sec.sign(msg)
+	setText('signature', sig.toHexStr())
 
-	let r = blsVerify(signature, publicKey, msg)	
+	let r = pub.verify(sig, msg)
 	setText('verifyResult', r ? 'ok' : 'err')
-
-	bls_free(signature)
-	bls_free(publicKey)
-	bls_free(secretKey)
 }
 
 /*
@@ -221,164 +178,21 @@ function randSelect(k, n) {
 	return a
 }
 
-function evalFunc(y, vec, x) {
-	mclBnFr_mul(y, vec[1], x)
-	mclBnFr_add(y, y, vec[0])
-}
-
-function onClickTestShare()
-{
-	let k = parseInt(getValue('ss_k'))
-	let n = parseInt(getValue('ss_n'))
-	let msg = getValue('msg2')
-	console.log('k = ' + k)
-	console.log('n = ' + n)
-	console.log('msg = ' + msg)
-	if (n < k) {
-		alert('err : n is smaller than k')
-		return
-	}
-	let msk = []
-	let mpk = []
-	let idVec = []
-	let secVec = []
-	let pubVec = []
-	let sigVec = []
-
-	/*
-		setup master secret key
-	*/
-	for (let i = 0; i < k; i++) {
-		let sk = blsSecretKey_malloc()
-		blsSecretKeySetByCSPRNG(sk)
-		msk.push(sk)
-
-		let pk = blsPublicKey_malloc()
-		blsGetPublicKey(pk, sk)
-		mpk.push(pk)
-	}
-	setText('msk', Uint8ArrayToHexString(blsSecretKeySerialize(msk[0])))
-	setText('mpk', Uint8ArrayToHexString(blsPublicKeySerialize(mpk[0])))
-	{
-		let sig = blsSignature_malloc()
-		blsSign(sig, msk[0], msg)
-		setText('signature2', Uint8ArrayToHexString(blsSignatureSerialize(sig)))
-		bls_free(sig)
-	}
-
-	/*
-		key sharing
-	*/
-	for (let i = 0; i < n; i++) {
-		let id = blsId_malloc()
-//		blsIdSetInt(id, i + 1)
-		blsSecretKeySetByCSPRNG(id) // Id is same type of SecretKey
-		idVec.push(id)
-		let sk = blsSecretKey_malloc()
-		blsSecretKeyShare(sk, msk, idVec[i])
-		secVec.push(sk)
-
-		let pk = blsPublicKey_malloc()
-		blsPublicKeyShare(pk, mpk, idVec[i])
-		pubVec.push(pk)
-
-		{
-			let pk2 = blsPublicKey_malloc()
-			blsGetPublicKey(pk2, sk)
-			console.log(i + ' : pk == pk2 : ' + mclBnG2_isEqual(pk, pk2))
-			bls_free(pk2)
-		}
-
-		let sig = blsSignature_malloc()
-		blsSign(sig, sk, msg)
-		sigVec.push(sig)
-		console.log(i + ' : verify msg : ' + blsVerify(sig, pk, msg))
-	}
-
-	let o = document.getElementById('idlist')
-	let ol = document.createElement('ol')
-	let t = ''
-	for (let i = 0; i < n; i++) {
-		let id = Uint8ArrayToHexString(blsIdSerialize(idVec[i]))
-		let sk = Uint8ArrayToHexString(blsSecretKeySerialize(secVec[i]))
-		let pk = Uint8ArrayToHexString(blsPublicKeySerialize(pubVec[i]))
-		let sig = Uint8ArrayToHexString(blsSignatureSerialize(sigVec[i]))
-		t += '<li id="ui"' + i + '"> '
-		t += 'id : <span id="id"' + i + '">' + id + '</span><br>'
-		t += 'pk : <span id="pk"' + i + '">' + pk + '</span><br>'
-		t += 'sk : <span id="sk"' + i + '">' + sk + '</span><br>'
-		t += 'sig: <span id="sig"' + i + '">' + sig + '</span><br>'
-	}
-	ol.innerHTML = t
-	o.firstElementChild.innerHTML = ol.innerHTML
-
-	/*
-		recover
-	*/
-	let idxVec = randSelect(k, n)
-	setText('idxVec', idxVec.toString())
-	let subIdVec = []
-	let subSecVec = []
-	let subPubVec = []
-	let subSigVec = []
-	for (let i = 0; i < idxVec.length; i++) {
-		let idx = idxVec[i]
-		subIdVec.push(idVec[idx])
-		subSecVec.push(secVec[idx])
-		subPubVec.push(pubVec[idx])
-		subSigVec.push(sigVec[idx])
-	}
-	{
-		let sec = blsSecretKey_malloc()
-		let pub = blsPublicKey_malloc()
-		let sig = blsSignature_malloc()
-
-		blsSecretKeyRecover(sec, subSecVec, subIdVec)
-		blsPublicKeyRecover(pub, subPubVec, subIdVec)
-		blsSignatureRecover(sig, subSigVec, subIdVec)
-		let s = Uint8ArrayToHexString(blsSecretKeySerialize(sec))
-		s += s == getText('msk') ? ' :ok' : ' :ng'
-		setText('recoverSec', s)
-		s = Uint8ArrayToHexString(blsPublicKeySerialize(pub))
-		s += s == getText('mpk') ? ' :ok' : ' :ng'
-		setText('recoverPub', s)
-		s = Uint8ArrayToHexString(blsSignatureSerialize(sig))
-		s += s == getText('signature2') ? ' :ok' : ' :ng'
-		setText('recoverSig', s)
-
-		bls_free(sig)
-		bls_free(pub)
-		bls_free(sec)
-	}
-
-
-	for (let i = 0; i < n; i++) {
-		bls_free(idVec[i])
-		bls_free(secVec[i])
-		bls_free(pubVec[i])
-		bls_free(sigVec[i])
-	}
-	for (let i = 0; i < mpk.length; i++) {
-		bls_free(mpk[i])
-		bls_free(msk[i])
-	}
-}
-
 function onClickTestMisc()
 {
 	let idDec = getValue('idDec')
 	console.log('idDec=' + idDec)
-	var id = new BlsId()
+	var id = new bls.Id()
 	id.setStr(idDec)
 	setText('idDec2', id.getStr())
 	setText('idHex', id.getStr(16))
-	var sec = new BlsSecretKey()
-	sec.setLittleEndian(HexStringToUint8Array(getValue('sec1')))
+	var sec = new bls.SecretKey()
+	sec.setLittleEndian(bls.fromHexStr(getValue('sec1')))
 	var a = sec.serialize()
-	setText('secSerialize', Uint8ArrayToHexString(a))
+	setText('secSerialize', bls.toHexStr(a))
 }
 
-function onClickTestShareClass()
+function onClickTestShare()
 {
 	let k = parseInt(getValue('ss_k'))
 	let n = parseInt(getValue('ss_n'))
@@ -401,18 +215,18 @@ function onClickTestShareClass()
 		setup master secret key
 	*/
 	for (let i = 0; i < k; i++) {
-		let sk = new BlsSecretKey()
+		let sk = new bls.SecretKey()
 		sk.setByCSPRNG()
 		msk.push(sk)
 
 		let pk = sk.getPublicKey()
 		mpk.push(pk)
 	}
-	setText('msk', Uint8ArrayToHexString(msk[0].serialize()))
-	setText('mpk', Uint8ArrayToHexString(mpk[0].serialize()))
+	setText('msk', bls.toHexStr(msk[0].serialize()))
+	setText('mpk', bls.toHexStr(mpk[0].serialize()))
 	{
 		let sig = msk[0].sign(msg)
-		setText('signature2', Uint8ArrayToHexString(sig.serialize()))
+		setText('signature2', bls.toHexStr(sig.serialize()))
 		console.log('mpk[0] verify ' + mpk[0].verify(sig, msg))
 	}
 
@@ -420,15 +234,15 @@ function onClickTestShareClass()
 		key sharing
 	*/
 	for (let i = 0; i < n; i++) {
-		let id = new BlsId()
+		let id = new bls.Id()
 //		blsIdSetInt(id, i + 1)
 		id.setByCSPRNG()
 		idVec.push(id)
-		let sk = new BlsSecretKey()
+		let sk = new bls.SecretKey()
 		sk.share(msk, idVec[i])
 		secVec.push(sk)
 
-		let pk = new BlsPublicKey()
+		let pk = new bls.PublicKey()
 		pk.share(mpk, idVec[i])
 		pubVec.push(pk)
 
@@ -441,10 +255,10 @@ function onClickTestShareClass()
 	let ol = document.createElement('ol')
 	let t = ''
 	for (let i = 0; i < n; i++) {
-		let id = Uint8ArrayToHexString(idVec[i].serialize())
-		let sk = Uint8ArrayToHexString(secVec[i].serialize())
-		let pk = Uint8ArrayToHexString(pubVec[i].serialize())
-		let sig = Uint8ArrayToHexString(sigVec[i].serialize())
+		let id = idVec[i].toHexStr()
+		let sk = secVec[i].toHexStr()
+		let pk = pubVec[i].toHexStr()
+		let sig = sigVec[i].toHexStr()
 		t += '<li id="ui"' + i + '"> '
 		t += 'id : <span id="id"' + i + '">' + id + '</span><br>'
 		t += 'pk : <span id="pk"' + i + '">' + pk + '</span><br>'
@@ -471,20 +285,20 @@ function onClickTestShareClass()
 		subSigVec.push(sigVec[idx])
 	}
 	{
-		let sec = new BlsSecretKey()
-		let pub = new BlsPublicKey()
-		let sig = new BlsSignature()
+		let sec = new bls.SecretKey()
+		let pub = new bls.PublicKey()
+		let sig = new bls.Signature()
 
 		sec.recover(subSecVec, subIdVec)
 		pub.recover(subPubVec, subIdVec)
 		sig.recover(subSigVec, subIdVec)
-		let s = Uint8ArrayToHexString(sec.serialize())
+		let s = sec.toHexStr()
 		s += s == getText('msk') ? ' :ok' : ' :ng'
 		setText('recoverSec', s)
-		s = Uint8ArrayToHexString(pub.serialize())
+		s = pub.toHexStr()
 		s += s == getText('mpk') ? ' :ok' : ' :ng'
 		setText('recoverPub', s)
-		s = Uint8ArrayToHexString(sig.serialize())
+		s = sig.toHexStr()
 		s += s == getText('signature2') ? ' :ok' : ' :ng'
 		setText('recoverSig', s)
 	}
diff --git a/docs/demo/bls.html b/docs/demo/bls.html
index 8c84a2e..14e09dd 100644
--- a/docs/demo/bls.html
+++ b/docs/demo/bls.html
@@ -43,7 +43,6 @@ signature : <span name="signature"></span><br>
 verify : <span name="verifyResult"></span><br>
 </div>
 <button type="text" id="testBls" onclick="onClickTestShare()">test sharing</button>
-<button type="text" id="testBls" onclick="onClickTestShareClass()">test sharing class</button>
 <div>
 threshold(k)         : <input type="text" name="ss_k" value="3"><br>
 number of players(n) : <input type="text" name="ss_n" value="5"><br>
diff --git a/docs/demo/bls.js b/docs/demo/bls.js
index 81c8107..75d6c98 100644
--- a/docs/demo/bls.js
+++ b/docs/demo/bls.js
@@ -1,32 +1,49 @@
-function setupWasm(fileName, nameSpace, setupFct) {
-	console.log('setupWasm ' + fileName)
-	let mod = {}
-	fetch(fileName)
-		.then(response => response.arrayBuffer())
-		.then(buffer => new Uint8Array(buffer))
-		.then(binary => {
-			mod['wasmBinary'] = binary
-			mod['onRuntimeInitialized'] = function() {
-				setupFct(mod, nameSpace)
-				console.log('setupWasm end')
-			}
-			Module(mod)
-		})
-	return mod
-}
+(function(return_bls) {
+	if (typeof exports === 'object') {
+		module.exports = return_bls()
+	} else {
+		window.bls = return_bls()
+	}
+})(function() {
+	const crypto = window.crypto || window.msCrypto
 
-const MCLBN_CURVE_FP254BNB = 0
-const MCLBN_CURVE_FP382_1 = 1
-const MCLBN_CURVE_FP382_2 = 2
+	const MCLBN_CURVE_FP254BNB = 0
+	const MCLBN_CURVE_FP382_1 = 1
+	const MCLBN_CURVE_FP382_2 = 2
 
-const MCLBN_FP_UNIT_SIZE = 6
+	const MCLBN_FP_UNIT_SIZE = 6
 
-const BLS_ID_SIZE = MCLBN_FP_UNIT_SIZE * 8
-const BLS_SECRETKEY_SIZE = BLS_ID_SIZE
-const BLS_PUBLICKEY_SIZE = BLS_ID_SIZE * 3 * 2
-const BLS_SIGNATURE_SIZE = BLS_ID_SIZE * 3
+	const MCLBN_FP_SIZE = MCLBN_FP_UNIT_SIZE * 8
+	const MCLBN_G1_SIZE = MCLBN_FP_SIZE * 3
+	const MCLBN_G2_SIZE = MCLBN_FP_SIZE * 6
+	const MCLBN_GT_SIZE = MCLBN_FP_SIZE * 12
 
-function define_bls_extra_functions(mod) {
+	const BLS_ID_SIZE = MCLBN_FP_UNIT_SIZE * 8
+	const BLS_SECRETKEY_SIZE = BLS_ID_SIZE
+	const BLS_PUBLICKEY_SIZE = BLS_ID_SIZE * 3 * 2
+	const BLS_SIGNATURE_SIZE = BLS_ID_SIZE * 3
+
+	let mod = {}
+	let capi = {}
+	let self = {}
+	self.mod = mod
+	self.capi = capi
+
+	const setupWasm = function(fileName, nameSpace, setupFct) {
+		console.log('setupWasm ' + fileName)
+		fetch(fileName)
+			.then(response => response.arrayBuffer())
+			.then(buffer => new Uint8Array(buffer))
+			.then(binary => {
+				mod['wasmBinary'] = binary
+				mod['onRuntimeInitialized'] = function() {
+					setupFct(mod, nameSpace)
+					console.log('setupWasm end')
+				}
+				Module(mod)
+			})
+		return mod
+	}
 	const ptrToStr = function(pos, n) {
 		let s = ''
 			for (let i = 0; i < n; i++) {
@@ -44,6 +61,38 @@ function define_bls_extra_functions(mod) {
 			mod.HEAP8[pos + i] = s.charCodeAt(i)
 		}
 	}
+	const copyToUint32Array = function(a, pos) {
+		for (let i = 0; i < a.length; i++) {
+			a[i] = mod.HEAP32[pos / 4 + i]
+		}
+	}
+	const copyFromUint32Array = function(pos, a) {
+		for (let i = 0; i < a.length; i++) {
+			mod.HEAP32[pos / 4 + i] = a[i]
+		}
+	}
+	self.toHex = function(a, start, n) {
+		let s = ''
+		for (let i = 0; i < n; i++) {
+			s += ('0' + a[start + i].toString(16)).slice(-2)
+		}
+		return s
+	}
+	// Uint8Array to hex string
+	self.toHexStr = function(a) {
+		return self.toHex(a, 0, a.length)
+	}
+	// hex string to Uint8Array
+	self.fromHexStr = function(s) {
+		if (s.length & 1) throw('fromHexStr:length must be even ' + s.length)
+		let n = s.length / 2
+		let a = new Uint8Array(n)
+		for (let i = 0; i < n; i++) {
+			a[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16)
+		}
+		return a
+	}
+
 	const wrap_outputString = function(func, doesReturnString = true) {
 		return function(x, ioMode = 0) {
 			let maxBufSize = 2048
@@ -70,6 +119,29 @@ function define_bls_extra_functions(mod) {
 	const wrap_outputArray = function(func) {
 		return wrap_outputString(func, false)
 	}
+	/*
+		argNum : n
+		func(x0, ..., x_(n-1), buf, ioMode)
+		=> func(x0, ..., x_(n-1), pos, buf.length, ioMode)
+	*/
+	const wrap_input = function(func, argNum, returnValue = false) {
+		return function() {
+			const args = [...arguments]
+			let buf = args[argNum]
+			let ioMode = args[argNum + 1] // may undefined
+			let stack = mod.Runtime.stackSave()
+			let pos = mod.Runtime.stackAlloc(buf.length)
+			if (typeof(buf) == "string") {
+				AsciiStrToMem(pos, buf)
+			} else {
+				Uint8ArrayToMem(pos, buf)
+			}
+			let r = func(...args.slice(0, argNum), pos, buf.length, ioMode)
+			mod.Runtime.stackRestore(stack)
+			if (returnValue) return r
+			if (r) throw('err wrap_input0 ' + buf)
+		}
+	}
 	const wrap_input0 = function(func, returnValue = false) {
 		return function(buf, ioMode = 0) {
 			let stack = mod.Runtime.stackSave()
@@ -115,6 +187,26 @@ function define_bls_extra_functions(mod) {
 			if (r) throw('err wrap_input2 ' + buf)
 		}
 	}
+	const callSetter = function(func, a, p1, p2) {
+		let pos = mod._malloc(a.length * 4)
+		func(pos, p1, p2) // p1, p2 may be undefined
+		copyToUint32Array(a, pos)
+		mod._free(pos)
+	}
+	const callGetter = function(func, a, p1, p2) {
+		let pos = mod._malloc(a.length * 4)
+		mod.HEAP32.set(a, pos / 4)
+		let s = func(pos, p1, p2)
+		mod._free(pos)
+		return s
+	}
+	const callModifier = function(func, a, p1, p2) {
+		let pos = mod._malloc(a.length * 4)
+		mod.HEAP32.set(a, pos / 4)
+		func(pos, p1, p2) // p1, p2 may be undefined
+		copyToUint32Array(a, pos)
+		mod._free(pos)
+	}
 	const wrap_keyShare = function(func, dataSize) {
 		return function(x, vec, id) {
 			let k = vec.length
@@ -142,257 +234,7 @@ function define_bls_extra_functions(mod) {
 			if (r) throw('recover ' + n)
 		}
 	}
-
-	let crypto = window.crypto || window.msCrypto
-
-	let copyToUint32Array = function(a, pos) {
-		for (let i = 0; i < a.length; i++) {
-			a[i] = mod.HEAP32[pos / 4 + i]
-		}
-	}
-	let copyFromUint32Array = function(pos, a) {
-		for (let i = 0; i < a.length; i++) {
-			mod.HEAP32[pos / 4 + i] = a[i]
-		}
-	}
-	let callSetter = function(func, a, p1, p2) {
-		let pos = mod._malloc(a.length * 4)
-		func(pos, p1, p2) // p1, p2 may be undefined
-		copyToUint32Array(a, pos)
-		mod._free(pos)
-	}
-	let callGetter = function(func, a, p1, p2) {
-		let pos = mod._malloc(a.length * 4)
-		mod.HEAP32.set(a, pos / 4)
-		let s = func(pos, p1, p2)
-		mod._free(pos)
-		return s
-	}
-	let callModifier = function(func, a, p1, p2) {
-		let pos = mod._malloc(a.length * 4)
-		mod.HEAP32.set(a, pos / 4)
-		func(pos, p1, p2) // p1, p2 may be undefined
-		copyToUint32Array(a, pos)
-		mod._free(pos)
-	}
-	///////////////////////////////////////////////////////////////
-	const FR_SIZE = MCLBN_FP_UNIT_SIZE * 8
-	const G1_SIZE = FR_SIZE * 3
-	const G2_SIZE = FR_SIZE * 3 * 2
-	const GT_SIZE = FR_SIZE * 12
-
-	mclBnFr_malloc = function() {
-		return mod._malloc(FR_SIZE)
-	}
-	mcl_free = function(x) {
-		mod._free(x)
-	}
-	mclBnFr_deserialize = wrap_input1(_mclBnFr_deserialize)
-	mclBnFr_setLittleEndian = wrap_input1(_mclBnFr_setLittleEndian)
-	mclBnFr_setStr = wrap_input1(_mclBnFr_setStr)
-	mclBnFr_getStr = wrap_outputString(_mclBnFr_getStr)
-	mclBnFr_setHashOf = wrap_input1(_mclBnFr_setHashOf)
-
-	///////////////////////////////////////////////////////////////
-	mclBnG1_malloc = function() {
-		return mod._malloc(G1_SIZE)
-	}
-	mclBnG1_setStr = wrap_input1(_mclBnG1_setStr)
-	mclBnG1_getStr = wrap_outputString(_mclBnG1_getStr)
-	mclBnG1_deserialize = wrap_input1(_mclBnG1_deserialize)
-	mclBnG1_serialize = wrap_outputArray(_mclBnG1_serialize)
-	mclBnG1_hashAndMapTo = wrap_input1(_mclBnG1_hashAndMapTo)
-
-	///////////////////////////////////////////////////////////////
-	mclBnG2_malloc = function() {
-		return mod._malloc(G2_SIZE)
-	}
-	mclBnG2_setStr = wrap_input1(_mclBnG2_setStr)
-	mclBnG2_getStr = wrap_outputString(_mclBnG2_getStr)
-	mclBnG2_deserialize = wrap_input1(_mclBnG2_deserialize)
-	mclBnG2_serialize = wrap_outputArray(_mclBnG2_serialize)
-	mclBnG2_hashAndMapTo = wrap_input1(_mclBnG2_hashAndMapTo)
-
-	///////////////////////////////////////////////////////////////
-	mclBnGT_malloc = function() {
-		return mod._malloc(GT_SIZE)
-	}
-	mclBnGT_deserialize = wrap_input1(_mclBnGT_deserialize)
-	mclBnGT_serialize = wrap_outputArray(_mclBnGT_serialize)
-	mclBnGT_setStr = wrap_input1(_mclBnGT_setStr)
-	mclBnGT_getStr = wrap_outputString(_mclBnGT_getStr)
-	///////////////////////////////////////////////////////////////
-	bls_free = mcl_free
-	blsId_malloc = mclBnFr_malloc
-	blsSecretKey_malloc = mclBnFr_malloc
-	blsPublicKey_malloc = mclBnG2_malloc
-	blsSignature_malloc = mclBnG1_malloc
-
-	blsInit = function(curveType) {
-		return _blsInit(curveType, MCLBN_FP_UNIT_SIZE)
-	}
-
-	blsGetCurveOrder = wrap_outputString(_blsGetCurveOrder)
-	blsGetFieldOrder = wrap_outputString(_blsGetFieldOrder)
-
-	blsIdSetDecStr = wrap_input1(_blsIdSetDecStr)
-	blsIdSetHexStr = wrap_input1(_blsIdSetHexStr)
-	blsIdGetDecStr = wrap_outputString(_blsIdGetDecStr)
-	blsIdGetHexStr = wrap_outputString(_blsIdGetHexStr)
-
-	blsSecretKeySetDecStr = wrap_input1(_blsSecretKeySetDecStr)
-	blsSecretKeySetHexStr = wrap_input1(_blsSecretKeySetHexStr)
-	blsSecretKeyGetDecStr = wrap_outputString(_blsSecretKeyGetDecStr)
-	blsSecretKeyGetHexStr = wrap_outputString(_blsSecretKeyGetHexStr)
-
-	blsIdSerialize = wrap_outputArray(_blsIdSerialize)
-	blsSecretKeySerialize = wrap_outputArray(_blsSecretKeySerialize)
-	blsPublicKeySerialize = wrap_outputArray(_blsPublicKeySerialize)
-	blsSignatureSerialize = wrap_outputArray(_blsSignatureSerialize)
-
-	blsIdDeserialize = wrap_input1(_blsIdDeserialize)
-	blsSecretKeyDeserialize = wrap_input1(_blsSecretKeyDeserialize)
-	blsPublicKeyDeserialize = wrap_input1(_blsPublicKeyDeserialize)
-	blsSignatureDeserialize = wrap_input1(_blsSignatureDeserialize)
-
-	blsSecretKeySetLittleEndian = wrap_input1(_blsSecretKeySetLittleEndian)
-	blsHashToSecretKey = wrap_input1(_blsHashToSecretKey)
-	blsSign = wrap_input2(_blsSign)
-	blsVerify = wrap_input2(_blsVerify, true)
-
-	blsSecretKeyShare = wrap_keyShare(_blsSecretKeyShare, BLS_SECRETKEY_SIZE)
-	blsPublicKeyShare = wrap_keyShare(_blsPublicKeyShare, BLS_PUBLICKEY_SIZE)
-
-	blsSecretKeyRecover = wrap_recover(_blsSecretKeyRecover, BLS_SECRETKEY_SIZE, BLS_ID_SIZE)
-	blsPublicKeyRecover = wrap_recover(_blsPublicKeyRecover, BLS_PUBLICKEY_SIZE, BLS_ID_SIZE)
-	blsSignatureRecover = wrap_recover(_blsSignatureRecover, BLS_SIGNATURE_SIZE, BLS_ID_SIZE)
-
-	/// BlsId
-	BlsId = function() {
-		this.a_ = new Uint32Array(BLS_ID_SIZE / 4)
-	}
-	BlsId.prototype.setInt = function(x) {
-		callSetter(blsIdSetInt, this.a_, x)
-	}
-	BlsId.prototype.setByCSPRNG = function() {
-		callSetter(blsSecretKeySetByCSPRNG, this.a_) // same type of BlsSecretKey
-	}
-	BlsId.prototype.setStr = function(s, base = 10) {
-		switch (base) {
-		case 10:
-			callSetter(blsIdSetDecStr, this.a_, s)
-			return
-		case 16:
-			callSetter(blsIdSetHexStr, this.a_, s)
-			return
-		default:
-			throw('BlsId.setStr:bad base:' + base)
-		}
-	}
-	BlsId.prototype.deserialize = function(s) {
-		callSetter(blsIdDeserialize, this.a_, s)
-	}
-	BlsId.prototype.getStr = function(base = 10) {
-		switch (base) {
-		case 10:
-			return callGetter(blsIdGetDecStr, this.a_)
-		case 16:
-			return callGetter(blsIdGetHexStr, this.a_)
-		default:
-			throw('BlsId.getStr:bad base:' + base)
-		}
-	}
-	BlsId.prototype.serialize = function() {
-		return callGetter(blsIdSerialize, this.a_)
-	}
-	/// BlsSecretKey
-	BlsSecretKey = function() {
-		this.a_ = new Uint32Array(BLS_SECRETKEY_SIZE / 4)
-	}
-	BlsSecretKey.prototype.setInt = function(x) {
-		callSetter(blsIdSetInt, this.a_, x) // same as Id
-	}
-	BlsSecretKey.prototype.deserialize = function(s) {
-		callSetter(blsSecretKeyDeserialize, this.a_, s)
-	}
-	BlsSecretKey.prototype.setLittleEndian = function(s) {
-		callSetter(blsSecretKeySetLittleEndian, this.a_, s)
-	}
-	BlsSecretKey.prototype.serialize = function() {
-		return callGetter(blsSecretKeySerialize, this.a_)
-	}
-	BlsSecretKey.prototype.setHashOf = function(s) {
-		callSetter(blsHashToSecretKey, this.a_, s)
-	}
-	BlsSecretKey.prototype.setByCSPRNG = function() {
-		let a = new Uint8Array(BLS_SECRETKEY_SIZE)
-		crypto.getRandomValues(a)
-		this.setLittleEndian(a)
-//		callSetter(blsSecretKeySetByCSPRNG, this.a_)
-	}
-	// return BlsPublicKey
-	BlsSecretKey.prototype.getPublicKey = function() {
-		let pub = new BlsPublicKey()
-		let stack = mod.Runtime.stackSave()
-		let secPos = mod.Runtime.stackAlloc(this.a_.length * 4)
-		let pubPos = mod.Runtime.stackAlloc(pub.a_.length * 4)
-		mod.HEAP32.set(this.a_, secPos / 4)
-		blsGetPublicKey(pubPos, secPos)
-		copyToUint32Array(pub.a_, pubPos)
-		mod.Runtime.stackRestore(stack)
-		return pub
-	}
-	/*
-		input
-		m : message (string or Uint8Array)
-		return
-		BlsSignature
-	*/
-	BlsSecretKey.prototype.sign = function(m) {
-		let sig = new BlsSignature()
-		let stack = mod.Runtime.stackSave()
-		let secPos = mod.Runtime.stackAlloc(this.a_.length * 4)
-		let sigPos = mod.Runtime.stackAlloc(sig.a_.length * 4)
-		mod.HEAP32.set(this.a_, secPos / 4)
-		blsSign(sigPos, secPos, m)
-		copyToUint32Array(sig.a_, sigPos)
-		mod.Runtime.stackRestore(stack)
-		return sig
-	}
-
-	/// BlsPublicKey
-	BlsPublicKey = function() {
-		this.a_ = new Uint32Array(BLS_PUBLICKEY_SIZE / 4)
-	}
-	BlsPublicKey.prototype.deserialize = function(s) {
-		callSetter(blsPublicKeyDeserialize, this.a_, s)
-	}
-	BlsPublicKey.prototype.serialize = function() {
-		return callGetter(blsPublicKeySerialize, this.a_)
-	}
-	BlsPublicKey.prototype.verify = function(sig, m) {
-		let stack = mod.Runtime.stackSave()
-		let pubPos = mod.Runtime.stackAlloc(this.a_.length * 4)
-		let sigPos = mod.Runtime.stackAlloc(sig.a_.length * 4)
-		mod.HEAP32.set(this.a_, pubPos / 4)
-		mod.HEAP32.set(sig.a_, sigPos / 4)
-		let r = blsVerify(sigPos, pubPos, m)
-		mod.Runtime.stackRestore(stack)
-		return r != 0
-	}
-
-	/// BlsSignature
-	BlsSignature = function() {
-		this.a_ = new Uint32Array(BLS_SIGNATURE_SIZE / 4)
-	}
-	BlsSignature.prototype.deserialize = function(s) {
-		callSetter(blsSignatureDeserialize, this.a_, s)
-	}
-	BlsSignature.prototype.serialize = function() {
-		return callGetter(blsSignatureSerialize, this.a_)
-	}
-
-	const share = function(func, a, size, vec, id) {
+	const callShare = function(func, a, size, vec, id) {
 		let stack = mod.Runtime.stackSave()
 		let pos = mod.Runtime.stackAlloc(a.length * 4)
 		let idPos = mod.Runtime.stackAlloc(id.a_.length * 4)
@@ -407,20 +249,7 @@ function define_bls_extra_functions(mod) {
 		copyToUint32Array(a, pos)
 		mod.Runtime.stackRestore(stack)
 	}
-	/*
-		set shared BlsSecretKey by msk and id
-		input
-		msk : master secret key(array of BlsSecretKey)
-		id : BlsId
-	*/
-	BlsSecretKey.prototype.share = function(msk, id) {
-		share(_blsSecretKeyShare, this.a_, BLS_SECRETKEY_SIZE, msk, id)
-	}
-	BlsPublicKey.prototype.share = function(msk, id) {
-		share(_blsPublicKeyShare, this.a_, BLS_PUBLICKEY_SIZE, msk, id)
-	}
-
-	const recover = function(func, a, size, vec, idVec) {
+	const callRecover = function(func, a, size, vec, idVec) {
 		let n = vec.length
 		if (n != idVec.length) throw('recover:bad length')
 		let stack = mod.Runtime.stackSave()
@@ -437,18 +266,292 @@ function define_bls_extra_functions(mod) {
 		copyToUint32Array(a, secPos)
 		mod.Runtime.stackRestore(stack)
 	}
-	/*
-		recover BlsSecretKey from (secVec, idVec)
-		secVec : array of BlsSecretKey
-	*/
-	BlsSecretKey.prototype.recover = function(secVec, idVec) {
-		recover(_blsSecretKeyRecover, this.a_, BLS_SECRETKEY_SIZE, secVec, idVec)
-	}
-	BlsPublicKey.prototype.recover = function(secVec, idVec) {
-		recover(_blsPublicKeyRecover, this.a_, BLS_PUBLICKEY_SIZE, secVec, idVec)
+	const define_extra_functions = function(mod) {
+		capi.mclBnFr_malloc = function() {
+			return mod._malloc(MCLBN_FP_SIZE)
+		}
+		capi.mcl_free = function(x) {
+			mod._free(x)
+		}
+		capi.mclBnFr_deserialize = wrap_input1(capi._mclBnFr_deserialize)
+		capi.mclBnFr_setLittleEndian = wrap_input1(capi._mclBnFr_setLittleEndian)
+		capi.mclBnFr_setStr = wrap_input1(capi._mclBnFr_setStr)
+		capi.mclBnFr_getStr = wrap_outputString(capi._mclBnFr_getStr)
+		capi.mclBnFr_setHashOf = wrap_input1(capi._mclBnFr_setHashOf)
+
+		///////////////////////////////////////////////////////////////
+		capi.mclBnG1_malloc = function() {
+			return mod._malloc(MCLBN_G1_SIZE)
+		}
+		capi.mclBnG1_setStr = wrap_input1(capi._mclBnG1_setStr)
+		capi.mclBnG1_getStr = wrap_outputString(capi._mclBnG1_getStr)
+		capi.mclBnG1_deserialize = wrap_input1(capi._mclBnG1_deserialize)
+		capi.mclBnG1_serialize = wrap_outputArray(capi._mclBnG1_serialize)
+		capi.mclBnG1_hashAndMapTo = wrap_input1(capi._mclBnG1_hashAndMapTo)
+
+		///////////////////////////////////////////////////////////////
+		capi.mclBnG2_malloc = function() {
+			return mod._malloc(MCLBN_G2_SIZE)
+		}
+		capi.mclBnG2_setStr = wrap_input1(capi._mclBnG2_setStr)
+		capi.mclBnG2_getStr = wrap_outputString(capi._mclBnG2_getStr)
+		capi.mclBnG2_deserialize = wrap_input1(capi._mclBnG2_deserialize)
+		capi.mclBnG2_serialize = wrap_outputArray(capi._mclBnG2_serialize)
+		capi.mclBnG2_hashAndMapTo = wrap_input1(capi._mclBnG2_hashAndMapTo)
+
+		///////////////////////////////////////////////////////////////
+		capi.mclBnGT_malloc = function() {
+			return mod._malloc(MCLBN_GT_SIZE)
+		}
+		capi.mclBnGT_deserialize = wrap_input1(capi._mclBnGT_deserialize)
+		capi.mclBnGT_serialize = wrap_outputArray(capi._mclBnGT_serialize)
+		capi.mclBnGT_setStr = wrap_input1(capi._mclBnGT_setStr)
+		capi.mclBnGT_getStr = wrap_outputString(capi._mclBnGT_getStr)
+		///////////////////////////////////////////////////////////////
+		capi.bls_free = capi.mcl_free
+		capi.blsId_malloc = capi.mclBnFr_malloc
+		capi.blsSecretKey_malloc = capi.mclBnFr_malloc
+		capi.blsPublicKey_malloc = capi.mclBnG2_malloc
+		capi.blsSignature_malloc = capi.mclBnG1_malloc
+
+		capi.blsInit = function(curveType = MCLBN_CURVE_FP254BNB) {
+			return capi._blsInit(curveType, MCLBN_FP_UNIT_SIZE)
+		}
+
+		capi.blsGetCurveOrder = wrap_outputString(capi._blsGetCurveOrder)
+		capi.blsGetFieldOrder = wrap_outputString(capi._blsGetFieldOrder)
+
+		capi.blsIdSetDecStr = wrap_input1(capi._blsIdSetDecStr)
+		capi.blsIdSetHexStr = wrap_input1(capi._blsIdSetHexStr)
+		capi.blsIdGetDecStr = wrap_outputString(capi._blsIdGetDecStr)
+		capi.blsIdGetHexStr = wrap_outputString(capi._blsIdGetHexStr)
+
+		capi.blsSecretKeySetDecStr = wrap_input1(capi._blsSecretKeySetDecStr)
+		capi.blsSecretKeySetHexStr = wrap_input1(capi._blsSecretKeySetHexStr)
+		capi.blsSecretKeyGetDecStr = wrap_outputString(capi._blsSecretKeyGetDecStr)
+		capi.blsSecretKeyGetHexStr = wrap_outputString(capi._blsSecretKeyGetHexStr)
+
+		capi.blsIdSerialize = wrap_outputArray(capi._blsIdSerialize)
+		capi.blsSecretKeySerialize = wrap_outputArray(capi._blsSecretKeySerialize)
+		capi.blsPublicKeySerialize = wrap_outputArray(capi._blsPublicKeySerialize)
+		capi.blsSignatureSerialize = wrap_outputArray(capi._blsSignatureSerialize)
+
+		capi.blsIdDeserialize = wrap_input1(capi._blsIdDeserialize)
+		capi.blsSecretKeyDeserialize = wrap_input1(capi._blsSecretKeyDeserialize)
+		capi.blsPublicKeyDeserialize = wrap_input1(capi._blsPublicKeyDeserialize)
+		capi.blsSignatureDeserialize = wrap_input1(capi._blsSignatureDeserialize)
+
+		capi.blsSecretKeySetLittleEndian = wrap_input1(capi._blsSecretKeySetLittleEndian)
+		capi.blsHashToSecretKey = wrap_input1(capi._blsHashToSecretKey)
+		capi.blsSign = wrap_input2(capi._blsSign)
+		capi.blsVerify = wrap_input2(capi._blsVerify, true)
+
+		capi.blsSecretKeyShare = wrap_keyShare(capi._blsSecretKeyShare, BLS_SECRETKEY_SIZE)
+		capi.blsPublicKeyShare = wrap_keyShare(capi._blsPublicKeyShare, BLS_PUBLICKEY_SIZE)
+		capi.blsSecretKeyRecover = wrap_recover(capi._blsSecretKeyRecover, BLS_SECRETKEY_SIZE, BLS_ID_SIZE)
+		capi.blsPublicKeyRecover = wrap_recover(capi._blsPublicKeyRecover, BLS_PUBLICKEY_SIZE, BLS_ID_SIZE)
+		capi.blsSignatureRecover = wrap_recover(capi._blsSignatureRecover, BLS_SIGNATURE_SIZE, BLS_ID_SIZE)
+
+		capi.sheInit = function(curveType = MCLBN_CURVE_FP254BNB) {
+			let r = capi._sheInit(curveType, MCLBN_FP_UNIT_SIZE)
+			console.log('sheInit ' + r)
+			if (r) throw('sheInit')
+		}
+		class Common {
+			constructor(size) {
+				this.a_ = new Uint32Array(size / 4)
+			}
+			fromHexStr(s) {
+				this.deserialize(self.fromHexStr(s))
+			}
+			toHexStr() {
+				return self.toHexStr(this.serialize())
+			}
+			dump(msg = '') {
+				console.log(msg + this.toHexStr())
+			}
+		}
+
+		self.Id = class extends Common {
+			constructor() {
+				super(BLS_ID_SIZE)
+			}
+			setInt(x) {
+				callSetter(capi.blsIdSetInt, this.a_, x)
+			}
+			setByCSPRNG() {
+				callSetter(capi.blsSecretKeySetByCSPRNG, this.a_) // same type of BlsSecretKey
+			}
+			setStr(s, base = 10) {
+				switch (base) {
+				case 10:
+					callSetter(capi.blsIdSetDecStr, this.a_, s)
+					return
+				case 16:
+					callSetter(capi.blsIdSetHexStr, this.a_, s)
+					return
+				default:
+					throw('BlsId.setStr:bad base:' + base)
+				}
+			}
+			deserialize(s) {
+				callSetter(capi.blsIdDeserialize, this.a_, s)
+			}
+			getStr(base = 10) {
+				switch (base) {
+				case 10:
+					return callGetter(capi.blsIdGetDecStr, this.a_)
+				case 16:
+					return callGetter(capi.blsIdGetHexStr, this.a_)
+				default:
+					throw('BlsId.getStr:bad base:' + base)
+				}
+			}
+			serialize() {
+				return callGetter(capi.blsIdSerialize, this.a_)
+			}
+		}
+		self.getIdFromHexStr = function(s) {
+			r = new self.Id()
+			r.fromHexStr(s)
+			return r
+		}
+
+		self.SecretKey = class extends Common {
+			constructor() {
+				super(BLS_SECRETKEY_SIZE)
+			}
+			setInt(x) {
+				callSetter(capi.blsIdSetInt, this.a_, x) // same as Id
+			}
+			deserialize(s) {
+				callSetter(capi.blsSecretKeyDeserialize, this.a_, s)
+			}
+			setLittleEndian(s) {
+				callSetter(capi.blsSecretKeySetLittleEndian, this.a_, s)
+			}
+			serialize() {
+				return callGetter(capi.blsSecretKeySerialize, this.a_)
+			}
+			share(msk, id) {
+				callShare(capi._blsSecretKeyShare, this.a_, BLS_SECRETKEY_SIZE, msk, id)
+			}
+			recover(secVec, idVec) {
+				callRecover(capi._blsSecretKeyRecover, this.a_, BLS_SECRETKEY_SIZE, secVec, idVec)
+			}
+			setHashOf(s) {
+				callSetter(capi.blsHashToSecretKey, this.a_, s)
+			}
+			setByCSPRNG() {
+				let a = new Uint8Array(BLS_SECRETKEY_SIZE)
+				crypto.getRandomValues(a)
+				this.setLittleEndian(a)
+		//		callSetter(capi.blsSecretKeySetByCSPRNG, this.a_)
+			}
+			getPublicKey() {
+				let pub = new self.PublicKey()
+				let stack = mod.Runtime.stackSave()
+				let secPos = mod.Runtime.stackAlloc(this.a_.length * 4)
+				let pubPos = mod.Runtime.stackAlloc(pub.a_.length * 4)
+				mod.HEAP32.set(this.a_, secPos / 4)
+				capi.blsGetPublicKey(pubPos, secPos)
+				copyToUint32Array(pub.a_, pubPos)
+				mod.Runtime.stackRestore(stack)
+				return pub
+			}
+			/*
+				input
+				m : message (string or Uint8Array)
+				return
+				BlsSignature
+			*/
+			sign(m) {
+				let sig = new self.Signature()
+				let stack = mod.Runtime.stackSave()
+				let secPos = mod.Runtime.stackAlloc(this.a_.length * 4)
+				let sigPos = mod.Runtime.stackAlloc(sig.a_.length * 4)
+				mod.HEAP32.set(this.a_, secPos / 4)
+				capi.blsSign(sigPos, secPos, m)
+				copyToUint32Array(sig.a_, sigPos)
+				mod.Runtime.stackRestore(stack)
+				return sig
+			}
+		}
+		self.getSecretKeyFromHexStr = function(s) {
+			r = new self.SecretKey()
+			r.fromHexStr(s)
+			return r
+		}
+
+		self.PublicKey = class extends Common {
+			constructor() {
+				super(BLS_PUBLICKEY_SIZE)
+			}
+			deserialize(s) {
+				callSetter(capi.blsPublicKeyDeserialize, this.a_, s)
+			}
+			serialize() {
+				return callGetter(capi.blsPublicKeySerialize, this.a_)
+			}
+			share(msk, id) {
+				callShare(capi._blsPublicKeyShare, this.a_, BLS_PUBLICKEY_SIZE, msk, id)
+			}
+			recover(secVec, idVec) {
+				callRecover(capi._blsPublicKeyRecover, this.a_, BLS_PUBLICKEY_SIZE, secVec, idVec)
+			}
+			verify(sig, m) {
+				let stack = mod.Runtime.stackSave()
+				let pubPos = mod.Runtime.stackAlloc(this.a_.length * 4)
+				let sigPos = mod.Runtime.stackAlloc(sig.a_.length * 4)
+				mod.HEAP32.set(this.a_, pubPos / 4)
+				mod.HEAP32.set(sig.a_, sigPos / 4)
+				let r = capi.blsVerify(sigPos, pubPos, m)
+				mod.Runtime.stackRestore(stack)
+				return r != 0
+			}
+		}
+		self.getPublicKeyFromHexStr = function(s) {
+			r = new self.PublicKey()
+			r.fromHexStr(s)
+			return r
+		}
+
+		self.Signature = class extends Common {
+			constructor() {
+				super(BLS_SIGNATURE_SIZE)
+			}
+			deserialize(s) {
+				callSetter(capi.blsSignatureDeserialize, this.a_, s)
+			}
+			serialize() {
+				return callGetter(capi.blsSignatureSerialize, this.a_)
+			}
+			recover(secVec, idVec) {
+				callRecover(capi._blsSignatureRecover, this.a_, BLS_SIGNATURE_SIZE, secVec, idVec)
+			}
+		}
+		self.getSignatureFromHexStr = function(s) {
+			r = new self.Signature()
+			r.fromHexStr(s)
+			return r
+		}
 	}
-	BlsSignature.prototype.recover = function(secVec, idVec) {
-		recover(_blsSignatureRecover, this.a_, BLS_SIGNATURE_SIZE, secVec, idVec)
+	self.init = function(curveType = MCLBN_CURVE_FP254BNB, callback = null) {
+		setupWasm('bls_c.wasm', null, function(_mod, ns) {
+			mod = _mod
+			fetch('exported-bls.json')
+				.then(response => response.json())
+				.then(json => {
+					mod.json = json
+					json.forEach(func => {
+						capi[func.exportName] = mod.cwrap(func.name, func.returns, func.args)
+					})
+					define_extra_functions(mod)
+					let r = capi.blsInit(curveType)
+					console.log('finished ' + r)
+					if (callback) callback()
+				})
+		})
 	}
-}
-
+	return self
+})
diff --git a/docs/demo/exported-bls.js b/docs/demo/exported-bls.js
deleted file mode 100644
index 3cb47d7..0000000
--- a/docs/demo/exported-bls.js
+++ /dev/null
@@ -1,137 +0,0 @@
-function define_exported_bls(mod) {
-_blsInit = mod.cwrap('blsInit', 'number', ['number', 'number', ])
-_blsInitNotThreadSafe = mod.cwrap('blsInitNotThreadSafe', 'number', ['number', 'number', ])
-blsGetOpUnitSize = mod.cwrap('blsGetOpUnitSize', 'number', [])
-_blsGetCurveOrder = mod.cwrap('blsGetCurveOrder', 'number', ['number', 'number', ])
-_blsGetFieldOrder = mod.cwrap('blsGetFieldOrder', 'number', ['number', 'number', ])
-blsGetGeneratorOfG2 = mod.cwrap('blsGetGeneratorOfG2', 'null', ['number', ])
-blsIdSetInt = mod.cwrap('blsIdSetInt', 'null', ['number', 'number', ])
-_blsIdSetDecStr = mod.cwrap('blsIdSetDecStr', 'number', ['number', 'number', 'number', ])
-_blsIdSetHexStr = mod.cwrap('blsIdSetHexStr', 'number', ['number', 'number', 'number', ])
-_blsIdGetDecStr = mod.cwrap('blsIdGetDecStr', 'number', ['number', 'number', 'number', ])
-_blsIdGetHexStr = mod.cwrap('blsIdGetHexStr', 'number', ['number', 'number', 'number', ])
-_blsIdSerialize = mod.cwrap('blsIdSerialize', 'number', ['number', 'number', 'number', ])
-_blsSecretKeySerialize = mod.cwrap('blsSecretKeySerialize', 'number', ['number', 'number', 'number', ])
-_blsPublicKeySerialize = mod.cwrap('blsPublicKeySerialize', 'number', ['number', 'number', 'number', ])
-_blsSignatureSerialize = mod.cwrap('blsSignatureSerialize', 'number', ['number', 'number', 'number', ])
-_blsIdDeserialize = mod.cwrap('blsIdDeserialize', 'number', ['number', 'number', 'number', ])
-_blsSecretKeyDeserialize = mod.cwrap('blsSecretKeyDeserialize', 'number', ['number', 'number', 'number', ])
-_blsPublicKeyDeserialize = mod.cwrap('blsPublicKeyDeserialize', 'number', ['number', 'number', 'number', ])
-_blsSignatureDeserialize = mod.cwrap('blsSignatureDeserialize', 'number', ['number', 'number', 'number', ])
-blsIdIsEqual = mod.cwrap('blsIdIsEqual', 'number', ['number', 'number', ])
-blsSecretKeyIsEqual = mod.cwrap('blsSecretKeyIsEqual', 'number', ['number', 'number', ])
-blsPublicKeyIsEqual = mod.cwrap('blsPublicKeyIsEqual', 'number', ['number', 'number', ])
-_blsSignatureIsEqual = mod.cwrap('blsSignatureIsEqual', 'number', ['number', 'number', ])
-blsSecretKeyAdd = mod.cwrap('blsSecretKeyAdd', 'null', ['number', 'number', ])
-blsPublicKeyAdd = mod.cwrap('blsPublicKeyAdd', 'null', ['number', 'number', ])
-_blsSignatureAdd = mod.cwrap('blsSignatureAdd', 'null', ['number', 'number', ])
-_blsHashToSecretKey = mod.cwrap('blsHashToSecretKey', 'number', ['number', 'number', 'number', ])
-blsSecretKeySetByCSPRNG = mod.cwrap('blsSecretKeySetByCSPRNG', 'number', ['number', ])
-blsGetPublicKey = mod.cwrap('blsGetPublicKey', 'null', ['number', 'number', ])
-blsGetPop = mod.cwrap('blsGetPop', 'null', ['number', 'number', ])
-_blsSecretKeyShare = mod.cwrap('blsSecretKeyShare', 'number', ['number', 'number', 'number', 'number', ])
-_blsPublicKeyShare = mod.cwrap('blsPublicKeyShare', 'number', ['number', 'number', 'number', 'number', ])
-_blsSecretKeyRecover = mod.cwrap('blsSecretKeyRecover', 'number', ['number', 'number', 'number', 'number', ])
-_blsPublicKeyRecover = mod.cwrap('blsPublicKeyRecover', 'number', ['number', 'number', 'number', 'number', ])
-_blsSignatureRecover = mod.cwrap('blsSignatureRecover', 'number', ['number', 'number', 'number', 'number', ])
-_blsSign = mod.cwrap('blsSign', 'null', ['number', 'number', 'number', 'number', ])
-_blsVerify = mod.cwrap('blsVerify', 'number', ['number', 'number', 'number', 'number', ])
-_blsVerifyPop = mod.cwrap('blsVerifyPop', 'number', ['number', 'number', ])
-_blsIdSetLittleEndian = mod.cwrap('blsIdSetLittleEndian', 'number', ['number', 'number', 'number', ])
-_blsIdGetLittleEndian = mod.cwrap('blsIdGetLittleEndian', 'number', ['number', 'number', 'number', ])
-_blsSecretKeySetLittleEndian = mod.cwrap('blsSecretKeySetLittleEndian', 'number', ['number', 'number', 'number', ])
-_blsSecretKeySetDecStr = mod.cwrap('blsSecretKeySetDecStr', 'number', ['number', 'number', 'number', ])
-_blsSecretKeySetHexStr = mod.cwrap('blsSecretKeySetHexStr', 'number', ['number', 'number', 'number', ])
-_blsSecretKeyGetLittleEndian = mod.cwrap('blsSecretKeyGetLittleEndian', 'number', ['number', 'number', 'number', ])
-_blsSecretKeyGetDecStr = mod.cwrap('blsSecretKeyGetDecStr', 'number', ['number', 'number', 'number', ])
-_blsSecretKeyGetHexStr = mod.cwrap('blsSecretKeyGetHexStr', 'number', ['number', 'number', 'number', ])
-_blsPublicKeySetHexStr = mod.cwrap('blsPublicKeySetHexStr', 'number', ['number', 'number', 'number', ])
-_blsPublicKeyGetHexStr = mod.cwrap('blsPublicKeyGetHexStr', 'number', ['number', 'number', 'number', ])
-_blsSignatureSetHexStr = mod.cwrap('blsSignatureSetHexStr', 'number', ['number', 'number', 'number', ])
-_blsSignatureGetHexStr = mod.cwrap('blsSignatureGetHexStr', 'number', ['number', 'number', 'number', ])
-blsDHKeyExchange = mod.cwrap('blsDHKeyExchange', 'null', ['number', 'number', 'number', ])
-mclBn_setErrFile = mod.cwrap('mclBn_setErrFile', 'number', ['number', ])
-_mclBn_init = mod.cwrap('mclBn_init', 'number', ['number', 'number', ])
-mclBn_getOpUnitSize = mod.cwrap('mclBn_getOpUnitSize', 'number', [])
-mclBn_getCurveOrder = mod.cwrap('mclBn_getCurveOrder', 'number', ['number', 'number', ])
-mclBn_getFieldOrder = mod.cwrap('mclBn_getFieldOrder', 'number', ['number', 'number', ])
-mclBnFr_clear = mod.cwrap('mclBnFr_clear', 'null', ['number', ])
-mclBnFr_setInt = mod.cwrap('mclBnFr_setInt', 'null', ['number', 'number', ])
-_mclBnFr_setStr = mod.cwrap('mclBnFr_setStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnFr_deserialize = mod.cwrap('mclBnFr_deserialize', 'number', ['number', 'number', 'number', ])
-_mclBnFr_setLittleEndian = mod.cwrap('mclBnFr_setLittleEndian', 'number', ['number', 'number', 'number', ])
-mclBnFr_isValid = mod.cwrap('mclBnFr_isValid', 'number', ['number', ])
-mclBnFr_isEqual = mod.cwrap('mclBnFr_isEqual', 'number', ['number', 'number', ])
-mclBnFr_isZero = mod.cwrap('mclBnFr_isZero', 'number', ['number', ])
-mclBnFr_isOne = mod.cwrap('mclBnFr_isOne', 'number', ['number', ])
-mclBnFr_setByCSPRNG = mod.cwrap('mclBnFr_setByCSPRNG', 'number', ['number', ])
-_mclBnFr_setHashOf = mod.cwrap('mclBnFr_setHashOf', 'number', ['number', 'number', 'number', ])
-_mclBnFr_getStr = mod.cwrap('mclBnFr_getStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnFr_serialize = mod.cwrap('mclBnFr_serialize', 'number', ['number', 'number', 'number', ])
-mclBnFr_neg = mod.cwrap('mclBnFr_neg', 'null', ['number', 'number', ])
-mclBnFr_inv = mod.cwrap('mclBnFr_inv', 'null', ['number', 'number', ])
-mclBnFr_add = mod.cwrap('mclBnFr_add', 'null', ['number', 'number', 'number', ])
-mclBnFr_sub = mod.cwrap('mclBnFr_sub', 'null', ['number', 'number', 'number', ])
-mclBnFr_mul = mod.cwrap('mclBnFr_mul', 'null', ['number', 'number', 'number', ])
-mclBnFr_div = mod.cwrap('mclBnFr_div', 'null', ['number', 'number', 'number', ])
-mclBnG1_clear = mod.cwrap('mclBnG1_clear', 'null', ['number', ])
-_mclBnG1_setStr = mod.cwrap('mclBnG1_setStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnG1_deserialize = mod.cwrap('mclBnG1_deserialize', 'number', ['number', 'number', 'number', ])
-mclBnG1_isValid = mod.cwrap('mclBnG1_isValid', 'number', ['number', ])
-mclBnG1_isEqual = mod.cwrap('mclBnG1_isEqual', 'number', ['number', 'number', ])
-mclBnG1_isZero = mod.cwrap('mclBnG1_isZero', 'number', ['number', ])
-_mclBnG1_hashAndMapTo = mod.cwrap('mclBnG1_hashAndMapTo', 'number', ['number', 'number', 'number', ])
-_mclBnG1_getStr = mod.cwrap('mclBnG1_getStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnG1_serialize = mod.cwrap('mclBnG1_serialize', 'number', ['number', 'number', 'number', ])
-mclBnG1_neg = mod.cwrap('mclBnG1_neg', 'null', ['number', 'number', ])
-mclBnG1_dbl = mod.cwrap('mclBnG1_dbl', 'null', ['number', 'number', ])
-mclBnG1_add = mod.cwrap('mclBnG1_add', 'null', ['number', 'number', 'number', ])
-mclBnG1_sub = mod.cwrap('mclBnG1_sub', 'null', ['number', 'number', 'number', ])
-mclBnG1_mul = mod.cwrap('mclBnG1_mul', 'null', ['number', 'number', 'number', ])
-mclBnG1_mulCT = mod.cwrap('mclBnG1_mulCT', 'null', ['number', 'number', 'number', ])
-mclBnG2_clear = mod.cwrap('mclBnG2_clear', 'null', ['number', ])
-_mclBnG2_setStr = mod.cwrap('mclBnG2_setStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnG2_deserialize = mod.cwrap('mclBnG2_deserialize', 'number', ['number', 'number', 'number', ])
-mclBnG2_isValid = mod.cwrap('mclBnG2_isValid', 'number', ['number', ])
-mclBnG2_isEqual = mod.cwrap('mclBnG2_isEqual', 'number', ['number', 'number', ])
-mclBnG2_isZero = mod.cwrap('mclBnG2_isZero', 'number', ['number', ])
-_mclBnG2_hashAndMapTo = mod.cwrap('mclBnG2_hashAndMapTo', 'number', ['number', 'number', 'number', ])
-_mclBnG2_getStr = mod.cwrap('mclBnG2_getStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnG2_serialize = mod.cwrap('mclBnG2_serialize', 'number', ['number', 'number', 'number', ])
-mclBnG2_neg = mod.cwrap('mclBnG2_neg', 'null', ['number', 'number', ])
-mclBnG2_dbl = mod.cwrap('mclBnG2_dbl', 'null', ['number', 'number', ])
-mclBnG2_add = mod.cwrap('mclBnG2_add', 'null', ['number', 'number', 'number', ])
-mclBnG2_sub = mod.cwrap('mclBnG2_sub', 'null', ['number', 'number', 'number', ])
-mclBnG2_mul = mod.cwrap('mclBnG2_mul', 'null', ['number', 'number', 'number', ])
-mclBnG2_mulCT = mod.cwrap('mclBnG2_mulCT', 'null', ['number', 'number', 'number', ])
-mclBnGT_clear = mod.cwrap('mclBnGT_clear', 'null', ['number', ])
-mclBnGT_setInt = mod.cwrap('mclBnGT_setInt', 'null', ['number', 'number', ])
-_mclBnGT_setStr = mod.cwrap('mclBnGT_setStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnGT_deserialize = mod.cwrap('mclBnGT_deserialize', 'number', ['number', 'number', 'number', ])
-mclBnGT_isEqual = mod.cwrap('mclBnGT_isEqual', 'number', ['number', 'number', ])
-mclBnGT_isZero = mod.cwrap('mclBnGT_isZero', 'number', ['number', ])
-mclBnGT_isOne = mod.cwrap('mclBnGT_isOne', 'number', ['number', ])
-_mclBnGT_getStr = mod.cwrap('mclBnGT_getStr', 'number', ['number', 'number', 'number', 'number', ])
-_mclBnGT_serialize = mod.cwrap('mclBnGT_serialize', 'number', ['number', 'number', 'number', ])
-mclBnGT_neg = mod.cwrap('mclBnGT_neg', 'null', ['number', 'number', ])
-mclBnGT_inv = mod.cwrap('mclBnGT_inv', 'null', ['number', 'number', ])
-mclBnGT_add = mod.cwrap('mclBnGT_add', 'null', ['number', 'number', 'number', ])
-mclBnGT_sub = mod.cwrap('mclBnGT_sub', 'null', ['number', 'number', 'number', ])
-mclBnGT_mul = mod.cwrap('mclBnGT_mul', 'null', ['number', 'number', 'number', ])
-mclBnGT_div = mod.cwrap('mclBnGT_div', 'null', ['number', 'number', 'number', ])
-mclBnGT_powGeneric = mod.cwrap('mclBnGT_powGeneric', 'null', ['number', 'number', 'number', ])
-mclBnGT_pow = mod.cwrap('mclBnGT_pow', 'null', ['number', 'number', 'number', ])
-mclBn_pairing = mod.cwrap('mclBn_pairing', 'null', ['number', 'number', 'number', ])
-mclBn_finalExp = mod.cwrap('mclBn_finalExp', 'null', ['number', 'number', ])
-mclBn_millerLoop = mod.cwrap('mclBn_millerLoop', 'null', ['number', 'number', 'number', ])
-mclBn_getUint64NumToPrecompute = mod.cwrap('mclBn_getUint64NumToPrecompute', 'number', [])
-mclBn_precomputeG2 = mod.cwrap('mclBn_precomputeG2', 'null', ['number', 'number', ])
-mclBn_precomputedMillerLoop = mod.cwrap('mclBn_precomputedMillerLoop', 'null', ['number', 'number', 'number', ])
-mclBn_precomputedMillerLoop2 = mod.cwrap('mclBn_precomputedMillerLoop2', 'null', ['number', 'number', 'number', 'number', 'number', ])
-mclBn_FrLagrangeInterpolation = mod.cwrap('mclBn_FrLagrangeInterpolation', 'number', ['number', 'number', 'number', 'number', ])
-mclBn_G1LagrangeInterpolation = mod.cwrap('mclBn_G1LagrangeInterpolation', 'number', ['number', 'number', 'number', 'number', ])
-mclBn_G2LagrangeInterpolation = mod.cwrap('mclBn_G2LagrangeInterpolation', 'number', ['number', 'number', 'number', 'number', ])
-mclBn_FrEvaluatePolynomial = mod.cwrap('mclBn_FrEvaluatePolynomial', 'number', ['number', 'number', 'number', 'number', ])
-mclBn_G1EvaluatePolynomial = mod.cwrap('mclBn_G1EvaluatePolynomial', 'number', ['number', 'number', 'number', 'number', ])
-mclBn_G2EvaluatePolynomial = mod.cwrap('mclBn_G2EvaluatePolynomial', 'number', ['number', 'number', 'number', 'number', ])
-}
diff --git a/docs/demo/exported-bls.json b/docs/demo/exported-bls.json
new file mode 100644
index 0000000..e3c4eb5
--- /dev/null
+++ b/docs/demo/exported-bls.json
@@ -0,0 +1,812 @@
+[
+{
+  "name":"blsInit",
+  "exportName":"_blsInit",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsInitNotThreadSafe",
+  "exportName":"_blsInitNotThreadSafe",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsGetOpUnitSize",
+  "exportName":"blsGetOpUnitSize",
+  "ret":"number",
+  "args":[ ]
+}
+,{
+  "name":"blsGetCurveOrder",
+  "exportName":"_blsGetCurveOrder",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsGetFieldOrder",
+  "exportName":"_blsGetFieldOrder",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsGetGeneratorOfG2",
+  "exportName":"blsGetGeneratorOfG2",
+  "ret":"null",
+  "args":[ "number" ]
+}
+,{
+  "name":"blsIdSetInt",
+  "exportName":"blsIdSetInt",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsIdSetDecStr",
+  "exportName":"_blsIdSetDecStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdSetHexStr",
+  "exportName":"_blsIdSetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdGetDecStr",
+  "exportName":"_blsIdGetDecStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdGetHexStr",
+  "exportName":"_blsIdGetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdSerialize",
+  "exportName":"_blsIdSerialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeySerialize",
+  "exportName":"_blsSecretKeySerialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsPublicKeySerialize",
+  "exportName":"_blsPublicKeySerialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSignatureSerialize",
+  "exportName":"_blsSignatureSerialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdDeserialize",
+  "exportName":"_blsIdDeserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyDeserialize",
+  "exportName":"_blsSecretKeyDeserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsPublicKeyDeserialize",
+  "exportName":"_blsPublicKeyDeserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSignatureDeserialize",
+  "exportName":"_blsSignatureDeserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdIsEqual",
+  "exportName":"blsIdIsEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyIsEqual",
+  "exportName":"blsSecretKeyIsEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsPublicKeyIsEqual",
+  "exportName":"blsPublicKeyIsEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsSignatureIsEqual",
+  "exportName":"_blsSignatureIsEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyAdd",
+  "exportName":"blsSecretKeyAdd",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsPublicKeyAdd",
+  "exportName":"blsPublicKeyAdd",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsSignatureAdd",
+  "exportName":"_blsSignatureAdd",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsHashToSecretKey",
+  "exportName":"_blsHashToSecretKey",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeySetByCSPRNG",
+  "exportName":"blsSecretKeySetByCSPRNG",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"blsGetPublicKey",
+  "exportName":"blsGetPublicKey",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsGetPop",
+  "exportName":"blsGetPop",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyShare",
+  "exportName":"_blsSecretKeyShare",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsPublicKeyShare",
+  "exportName":"_blsPublicKeyShare",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyRecover",
+  "exportName":"_blsSecretKeyRecover",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsPublicKeyRecover",
+  "exportName":"_blsPublicKeyRecover",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsSignatureRecover",
+  "exportName":"_blsSignatureRecover",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsSign",
+  "exportName":"_blsSign",
+  "ret":"null",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsVerify",
+  "exportName":"_blsVerify",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"blsVerifyPop",
+  "exportName":"_blsVerifyPop",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"blsIdSetLittleEndian",
+  "exportName":"_blsIdSetLittleEndian",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsIdGetLittleEndian",
+  "exportName":"_blsIdGetLittleEndian",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeySetLittleEndian",
+  "exportName":"_blsSecretKeySetLittleEndian",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeySetDecStr",
+  "exportName":"_blsSecretKeySetDecStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeySetHexStr",
+  "exportName":"_blsSecretKeySetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyGetLittleEndian",
+  "exportName":"_blsSecretKeyGetLittleEndian",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyGetDecStr",
+  "exportName":"_blsSecretKeyGetDecStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSecretKeyGetHexStr",
+  "exportName":"_blsSecretKeyGetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsPublicKeySetHexStr",
+  "exportName":"_blsPublicKeySetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsPublicKeyGetHexStr",
+  "exportName":"_blsPublicKeyGetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSignatureSetHexStr",
+  "exportName":"_blsSignatureSetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsSignatureGetHexStr",
+  "exportName":"_blsSignatureGetHexStr",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"blsDHKeyExchange",
+  "exportName":"blsDHKeyExchange",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_setErrFile",
+  "exportName":"mclBn_setErrFile",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBn_init",
+  "exportName":"_mclBn_init",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBn_getOpUnitSize",
+  "exportName":"mclBn_getOpUnitSize",
+  "ret":"number",
+  "args":[ ]
+}
+,{
+  "name":"mclBn_getCurveOrder",
+  "exportName":"mclBn_getCurveOrder",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBn_getFieldOrder",
+  "exportName":"mclBn_getFieldOrder",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnFr_clear",
+  "exportName":"mclBnFr_clear",
+  "ret":"null",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnFr_setInt",
+  "exportName":"mclBnFr_setInt",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnFr_setStr",
+  "exportName":"_mclBnFr_setStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_deserialize",
+  "exportName":"_mclBnFr_deserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_setLittleEndian",
+  "exportName":"_mclBnFr_setLittleEndian",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_isValid",
+  "exportName":"mclBnFr_isValid",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnFr_isEqual",
+  "exportName":"mclBnFr_isEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnFr_isZero",
+  "exportName":"mclBnFr_isZero",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnFr_isOne",
+  "exportName":"mclBnFr_isOne",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnFr_setByCSPRNG",
+  "exportName":"mclBnFr_setByCSPRNG",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnFr_setHashOf",
+  "exportName":"_mclBnFr_setHashOf",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_getStr",
+  "exportName":"_mclBnFr_getStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_serialize",
+  "exportName":"_mclBnFr_serialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_neg",
+  "exportName":"mclBnFr_neg",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnFr_inv",
+  "exportName":"mclBnFr_inv",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnFr_add",
+  "exportName":"mclBnFr_add",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_sub",
+  "exportName":"mclBnFr_sub",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_mul",
+  "exportName":"mclBnFr_mul",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnFr_div",
+  "exportName":"mclBnFr_div",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_clear",
+  "exportName":"mclBnG1_clear",
+  "ret":"null",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnG1_setStr",
+  "exportName":"_mclBnG1_setStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_deserialize",
+  "exportName":"_mclBnG1_deserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_isValid",
+  "exportName":"mclBnG1_isValid",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnG1_isEqual",
+  "exportName":"mclBnG1_isEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnG1_isZero",
+  "exportName":"mclBnG1_isZero",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnG1_hashAndMapTo",
+  "exportName":"_mclBnG1_hashAndMapTo",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_getStr",
+  "exportName":"_mclBnG1_getStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_serialize",
+  "exportName":"_mclBnG1_serialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_neg",
+  "exportName":"mclBnG1_neg",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnG1_dbl",
+  "exportName":"mclBnG1_dbl",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnG1_add",
+  "exportName":"mclBnG1_add",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_sub",
+  "exportName":"mclBnG1_sub",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_mul",
+  "exportName":"mclBnG1_mul",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG1_mulCT",
+  "exportName":"mclBnG1_mulCT",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_clear",
+  "exportName":"mclBnG2_clear",
+  "ret":"null",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnG2_setStr",
+  "exportName":"_mclBnG2_setStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_deserialize",
+  "exportName":"_mclBnG2_deserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_isValid",
+  "exportName":"mclBnG2_isValid",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnG2_isEqual",
+  "exportName":"mclBnG2_isEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnG2_isZero",
+  "exportName":"mclBnG2_isZero",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnG2_hashAndMapTo",
+  "exportName":"_mclBnG2_hashAndMapTo",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_getStr",
+  "exportName":"_mclBnG2_getStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_serialize",
+  "exportName":"_mclBnG2_serialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_neg",
+  "exportName":"mclBnG2_neg",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnG2_dbl",
+  "exportName":"mclBnG2_dbl",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnG2_add",
+  "exportName":"mclBnG2_add",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_sub",
+  "exportName":"mclBnG2_sub",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_mul",
+  "exportName":"mclBnG2_mul",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnG2_mulCT",
+  "exportName":"mclBnG2_mulCT",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_clear",
+  "exportName":"mclBnGT_clear",
+  "ret":"null",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnGT_setInt",
+  "exportName":"mclBnGT_setInt",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnGT_setStr",
+  "exportName":"_mclBnGT_setStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_deserialize",
+  "exportName":"_mclBnGT_deserialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_isEqual",
+  "exportName":"mclBnGT_isEqual",
+  "ret":"number",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnGT_isZero",
+  "exportName":"mclBnGT_isZero",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnGT_isOne",
+  "exportName":"mclBnGT_isOne",
+  "ret":"number",
+  "args":[ "number" ]
+}
+,{
+  "name":"mclBnGT_getStr",
+  "exportName":"_mclBnGT_getStr",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_serialize",
+  "exportName":"_mclBnGT_serialize",
+  "ret":"number",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_neg",
+  "exportName":"mclBnGT_neg",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnGT_inv",
+  "exportName":"mclBnGT_inv",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBnGT_add",
+  "exportName":"mclBnGT_add",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_sub",
+  "exportName":"mclBnGT_sub",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_mul",
+  "exportName":"mclBnGT_mul",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_div",
+  "exportName":"mclBnGT_div",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_powGeneric",
+  "exportName":"mclBnGT_powGeneric",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBnGT_pow",
+  "exportName":"mclBnGT_pow",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_pairing",
+  "exportName":"mclBn_pairing",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_finalExp",
+  "exportName":"mclBn_finalExp",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBn_millerLoop",
+  "exportName":"mclBn_millerLoop",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_getUint64NumToPrecompute",
+  "exportName":"mclBn_getUint64NumToPrecompute",
+  "ret":"number",
+  "args":[ ]
+}
+,{
+  "name":"mclBn_precomputeG2",
+  "exportName":"mclBn_precomputeG2",
+  "ret":"null",
+  "args":[ "number", "number" ]
+}
+,{
+  "name":"mclBn_precomputedMillerLoop",
+  "exportName":"mclBn_precomputedMillerLoop",
+  "ret":"null",
+  "args":[ "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_precomputedMillerLoop2",
+  "exportName":"mclBn_precomputedMillerLoop2",
+  "ret":"null",
+  "args":[ "number", "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_FrLagrangeInterpolation",
+  "exportName":"mclBn_FrLagrangeInterpolation",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_G1LagrangeInterpolation",
+  "exportName":"mclBn_G1LagrangeInterpolation",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_G2LagrangeInterpolation",
+  "exportName":"mclBn_G2LagrangeInterpolation",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_FrEvaluatePolynomial",
+  "exportName":"mclBn_FrEvaluatePolynomial",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_G1EvaluatePolynomial",
+  "exportName":"mclBn_G1EvaluatePolynomial",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+,{
+  "name":"mclBn_G2EvaluatePolynomial",
+  "exportName":"mclBn_G2EvaluatePolynomial",
+  "ret":"number",
+  "args":[ "number", "number", "number", "number" ]
+}
+]