[js] refactor bls.js

1 files changed, 406 insertions, 303 deletions

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
+})