_

1 files changed, 123 insertions, 111 deletions

diff --git a/src/bls_c.cpp b/src/bls_c.cpp
index d0f2802..4a16e6b 100644
--- a/src/bls_c.cpp
+++ b/src/bls_c.cpp
@@ -53,195 +53,207 @@ int blsGetFieldOrder(char *buf, size_t maxBufSize)
 } catch (std::exception&) {
 	return 0;
 }
-
-int blsIdIsEqual(const blsId *lhs, const blsId *rhs)
+void blsGetPublicKey(blsPublicKey *pub, const blsSecretKey *sec)
 {
-	return mclBnFr_isEqual(&lhs->v, &rhs->v);
+	((const bls::SecretKey*)sec)->getPublicKey(*(bls::PublicKey*)pub);
 }
-int blsIdSetLittleEndian(blsId *id, const void *buf, size_t bufSize)
+void blsSign(blsSignature *sig, const blsSecretKey *sec, const char *m, size_t size)
 {
-	return mclBnFr_setLittleEndian(&id->v, buf, bufSize);
+	((const bls::SecretKey*)sec)->sign(*(bls::Signature*)sig, std::string(m, size));
 }
-int blsIdSetDecStr(blsId *id, const char *buf, size_t bufSize)
+int blsSecretKeyShare(blsSecretKey *sec, const blsSecretKey* msk, size_t k, const blsId *id)
+	try
 {
-	return mclBnFr_setStr(&id->v, buf, bufSize, 10);
+	((bls::SecretKey*)sec)->set((const bls::SecretKey *)msk, k, *(const bls::Id*)id);
+	return 0;
+} catch (std::exception& e) {
+	fprintf(stderr, "err blsSecretKeyShare %s\n", e.what());
+	return -1;
 }
-int blsIdSetHexStr(blsId *id, const char *buf, size_t bufSize)
+
+int blsSecretKeyRecover(blsSecretKey *sec, const blsSecretKey *secVec, const blsId *idVec, size_t n)
+	try
 {
-	return mclBnFr_setStr(&id->v, buf, bufSize, 16);
+	((bls::SecretKey*)sec)->recover((const bls::SecretKey *)secVec, (const bls::Id *)idVec, n);
+	return 0;
+} catch (std::exception& e) {
+	fprintf(stderr, "err blsSecretKeyRecover %s\n", e.what());
+	return -1;
 }
-size_t blsIdGetLittleEndian(void *buf, size_t maxBufSize, const blsId *id)
+
+void blsGetPop(blsSignature *sig, const blsSecretKey *sec)
 {
-	return mclBnFr_serialize(buf, maxBufSize, &id->v);
+	((const bls::SecretKey*)sec)->getPop(*(bls::Signature*)sig);
 }
-size_t blsIdGetDecStr(char *buf, size_t maxBufSize, const blsId *id)
+int blsPublicKeyShare(blsPublicKey *pub, const blsPublicKey *mpk, size_t k, const blsId *id)
+	try
 {
-	return mclBnFr_getStr(buf, maxBufSize, &id->v, 10);
+	((bls::PublicKey*)pub)->set((const bls::PublicKey*)mpk, k, *(const bls::Id*)id);
+	return 0;
+} catch (std::exception& e) {
+	fprintf(stderr, "err blsPublicKeyShare %s\n", e.what());
+	return -1;
 }
-size_t blsIdGetHexStr(char *buf, size_t maxBufSize, const blsId *id)
+int blsPublicKeyRecover(blsPublicKey *pub, const blsPublicKey *pubVec, const blsId *idVec, size_t n)
+	try
 {
-	return mclBnFr_getStr(buf, maxBufSize, &id->v, 16);
+	((bls::PublicKey*)pub)->recover((const bls::PublicKey*)pubVec, (const bls::Id*)idVec, n);
+	return 0;
+} catch (std::exception& e) {
+	fprintf(stderr, "err blsPublicKeyRecover %s\n", e.what());
+	return -1;
 }
-int blsSecretKeyIsEqual(const blsSecretKey *lhs, const blsSecretKey *rhs)
+int blsSignatureRecover(blsSignature *sig, const blsSignature *sigVec, const blsId *idVec, size_t n)
+	try
 {
-	return mclBnFr_isEqual(&lhs->v, &rhs->v);
+	((bls::Signature*)sig)->recover((const bls::Signature*)sigVec, (const bls::Id*)idVec, n);
+	return 0;
+} catch (std::exception& e) {
+	fprintf(stderr, "err blsSignatureRecover %s\n", e.what());
+	return -1;
 }
-int blsSecretKeySetLittleEndian(blsSecretKey *sec, const void *buf, size_t bufSize)
+
+int blsVerify(const blsSignature *sig, const blsPublicKey *pub, const char *m, size_t size)
 {
-	return mclBnFr_setLittleEndian(&sec->v, buf, bufSize);
+	return ((const bls::Signature*)sig)->verify(*(const bls::PublicKey*)pub, std::string(m, size));
 }
-int blsSecretKeySetDecStr(blsSecretKey *sec, const char *buf, size_t bufSize)
+
+int blsVerifyPop(const blsSignature *sig, const blsPublicKey *pub)
 {
-	return mclBnFr_setStr(&sec->v, buf, bufSize, 10);
+	return ((const bls::Signature*)sig)->verify(*(const bls::PublicKey*)pub);
 }
-int blsSecretKeySetHexStr(blsSecretKey *sec, const char *buf, size_t bufSize)
+
+size_t blsIdSerialize(void *buf, size_t maxBufSize, const blsId *id)
 {
-	return mclBnFr_setStr(&sec->v, buf, bufSize, 16);
+	return mclBnFr_serialize(buf, maxBufSize, &id->v);
 }
-size_t blsSecretKeyGetLittleEndian(void *buf, size_t maxBufSize, const blsSecretKey *sec)
+size_t blsSecretKeySerialize(void *buf, size_t maxBufSize, const blsSecretKey *sec)
 {
 	return mclBnFr_serialize(buf, maxBufSize, &sec->v);
 }
-size_t blsSecretKeyGetDecStr(char *buf, size_t maxBufSize, const blsSecretKey *sec)
+size_t blsPublicKeySerialize(void *buf, size_t maxBufSize, const blsPublicKey *pub)
 {
-	return mclBnFr_getStr(buf, maxBufSize, &sec->v, 10);
+	return mclBnG2_serialize(buf, maxBufSize, &pub->v);
 }
-size_t blsSecretKeyGetHexStr(char *buf, size_t maxBufSize, const blsSecretKey *sec)
+size_t blsSignatureSerialize(void *buf, size_t maxBufSize, const blsSignature *sig)
 {
-	return mclBnFr_getStr(buf, maxBufSize, &sec->v, 16);
+	return mclBnG1_serialize(buf, maxBufSize, &sig->v);
 }
-
-int blsHashToSecretKey(blsSecretKey *sec, const void *buf, size_t bufSize)
+int blsIdDeserialize(blsId *id, const void *buf, size_t bufSize)
 {
-	return mclBnFr_setHashOf(&sec->v, buf, bufSize);
+	return mclBnFr_deserialize(&id->v, buf, bufSize);
 }
-
-int blsSecretKeySetByCSPRNG(blsSecretKey *sec)
+int blsSecretKeyDeserialize(blsSecretKey *sig, const void *buf, size_t bufSize)
 {
-	return mclBnFr_setByCSPRNG(&sec->v);
+	return mclBnFr_deserialize(&sig->v, buf, bufSize);
 }
-void blsSecretKeyAdd(blsSecretKey *sec, const blsSecretKey *rhs)
+int blsPublicKeyDeserialize(blsPublicKey *pub, const void *buf, size_t bufSize)
 {
-	((bls::SecretKey*)sec)->add(*(const bls::SecretKey*)rhs);
+	return mclBnG2_deserialize(&pub->v, buf, bufSize);
 }
-
-void blsGetPublicKey(blsPublicKey *pub, const blsSecretKey *sec)
+int blsSignatureDeserialize(blsSignature *sig, const void *buf, size_t bufSize)
 {
-	((const bls::SecretKey*)sec)->getPublicKey(*(bls::PublicKey*)pub);
+	return mclBnG1_deserialize(&sig->v, buf, bufSize);
 }
-void blsSign(blsSignature *sig, const blsSecretKey *sec, const char *m, size_t size)
+int blsIdIsEqual(const blsId *lhs, const blsId *rhs)
 {
-	((const bls::SecretKey*)sec)->sign(*(bls::Signature*)sig, std::string(m, size));
+	return mclBnFr_isEqual(&lhs->v, &rhs->v);
 }
-int blsSecretKeyShare(blsSecretKey *sec, const blsSecretKey* msk, size_t k, const blsId *id)
-	try
+int blsSecretKeyIsEqual(const blsSecretKey *lhs, const blsSecretKey *rhs)
 {
-	((bls::SecretKey*)sec)->set((const bls::SecretKey *)msk, k, *(const bls::Id*)id);
-	return 0;
-} catch (std::exception& e) {
-	fprintf(stderr, "err blsSecretKeyShare %s\n", e.what());
-	return -1;
+	return mclBnFr_isEqual(&lhs->v, &rhs->v);
 }
-
-int blsSecretKeyRecover(blsSecretKey *sec, const blsSecretKey *secVec, const blsId *idVec, size_t n)
-	try
+int blsPublicKeyIsEqual(const blsPublicKey *lhs, const blsPublicKey *rhs)
 {
-	((bls::SecretKey*)sec)->recover((const bls::SecretKey *)secVec, (const bls::Id *)idVec, n);
-	return 0;
-} catch (std::exception& e) {
-	fprintf(stderr, "err blsSecretKeyRecover %s\n", e.what());
-	return -1;
+	return mclBnG2_isEqual(&lhs->v, &rhs->v);
 }
-
-void blsGetPop(blsSignature *sig, const blsSecretKey *sec)
+int blsSignatureIsEqual(const blsSignature *lhs, const blsSignature *rhs)
 {
-	((const bls::SecretKey*)sec)->getPop(*(bls::Signature*)sig);
+	return mclBnG1_isEqual(&lhs->v, &rhs->v);
 }
-
-int blsPublicKeyIsEqual(const blsPublicKey *lhs, const blsPublicKey *rhs)
+void blsSecretKeyAdd(blsSecretKey *sec, const blsSecretKey *rhs)
 {
-	return mclBnG2_isEqual(&lhs->v, &rhs->v);
+	mclBnFr_add(&sec->v, &sec->v, &rhs->v);
 }
-int blsPublicKeyDeserialize(blsPublicKey *pub, const void *buf, size_t bufSize)
+void blsSignatureAdd(blsSignature *sig, const blsSignature *rhs)
 {
-	return mclBnG2_deserialize(&pub->v, buf, bufSize);
+	mclBnG1_add(&sig->v, &sig->v, &rhs->v);
 }
-size_t blsPublicKeySerialize(void *buf, size_t maxBufSize, const blsPublicKey *pub)
+void blsPublicKeyAdd(blsPublicKey *pub, const blsPublicKey *rhs)
 {
-	return mclBnG2_serialize(buf, maxBufSize, &pub->v);
+	mclBnG2_add(&pub->v, &pub->v, &rhs->v);
 }
-int blsPublicKeySetHexStr(blsPublicKey *pub, const char *buf, size_t bufSize)
+int blsIdSetLittleEndian(blsId *id, const void *buf, size_t bufSize)
 {
-	return mclBnG2_setStr(&pub->v, buf, bufSize, 16);
+	return mclBnFr_setLittleEndian(&id->v, buf, bufSize);
 }
-size_t blsPublicKeyGetHexStr(char *buf, size_t maxBufSize, const blsPublicKey *pub)
+int blsIdSetDecStr(blsId *id, const char *buf, size_t bufSize)
 {
-	return mclBnG2_getStr(buf, maxBufSize, &pub->v, 16);
+	return mclBnFr_setStr(&id->v, buf, bufSize, 10);
 }
-void blsPublicKeyAdd(blsPublicKey *pub, const blsPublicKey *rhs)
+int blsIdSetHexStr(blsId *id, const char *buf, size_t bufSize)
 {
-	((bls::PublicKey*)pub)->add(*(const bls::PublicKey*)rhs);
+	return mclBnFr_setStr(&id->v, buf, bufSize, 16);
 }
-int blsPublicKeyShare(blsPublicKey *pub, const blsPublicKey *mpk, size_t k, const blsId *id)
-	try
+size_t blsIdGetLittleEndian(void *buf, size_t maxBufSize, const blsId *id)
 {
-	((bls::PublicKey*)pub)->set((const bls::PublicKey*)mpk, k, *(const bls::Id*)id);
-	return 0;
-} catch (std::exception& e) {
-	fprintf(stderr, "err blsPublicKeyShare %s\n", e.what());
-	return -1;
+	return mclBnFr_serialize(buf, maxBufSize, &id->v);
 }
-int blsPublicKeyRecover(blsPublicKey *pub, const blsPublicKey *pubVec, const blsId *idVec, size_t n)
-	try
+size_t blsIdGetDecStr(char *buf, size_t maxBufSize, const blsId *id)
 {
-	((bls::PublicKey*)pub)->recover((const bls::PublicKey*)pubVec, (const bls::Id*)idVec, n);
-	return 0;
-} catch (std::exception& e) {
-	fprintf(stderr, "err blsPublicKeyRecover %s\n", e.what());
-	return -1;
+	return mclBnFr_getStr(buf, maxBufSize, &id->v, 10);
 }
-
-int blsSignatureIsEqual(const blsSignature *lhs, const blsSignature *rhs)
+size_t blsIdGetHexStr(char *buf, size_t maxBufSize, const blsId *id)
 {
-	return mclBnG1_isEqual(&lhs->v, &rhs->v);
+	return mclBnFr_getStr(buf, maxBufSize, &id->v, 16);
 }
-int blsSignatureDeserialize(blsSignature *sig, const void *buf, size_t bufSize)
+int blsSecretKeySetLittleEndian(blsSecretKey *sec, const void *buf, size_t bufSize)
 {
-	return mclBnG1_deserialize(&sig->v, buf, bufSize);
+	return mclBnFr_setLittleEndian(&sec->v, buf, bufSize);
 }
-int blsSignatureSetHexStr(blsSignature *sig, const char *buf, size_t bufSize)
+int blsSecretKeySetDecStr(blsSecretKey *sec, const char *buf, size_t bufSize)
 {
-	return mclBnG1_setStr(&sig->v, buf, bufSize, 16);
+	return mclBnFr_setStr(&sec->v, buf, bufSize, 10);
 }
-size_t blsSignatureGetHexStr(char *buf, size_t maxBufSize, const blsSignature *sig)
+int blsSecretKeySetHexStr(blsSecretKey *sec, const char *buf, size_t bufSize)
 {
-	return mclBnG1_getStr(buf, maxBufSize, &sig->v, 16);
+	return mclBnFr_setStr(&sec->v, buf, bufSize, 16);
 }
-size_t blsSignatureSerialize(void *buf, size_t maxBufSize, const blsSignature *sig)
+size_t blsSecretKeyGetLittleEndian(void *buf, size_t maxBufSize, const blsSecretKey *sec)
 {
-	return mclBnG1_serialize(buf, maxBufSize, &sig->v);
+	return mclBnFr_serialize(buf, maxBufSize, &sec->v);
 }
-void blsSignatureAdd(blsSignature *sig, const blsSignature *rhs)
+size_t blsSecretKeyGetDecStr(char *buf, size_t maxBufSize, const blsSecretKey *sec)
 {
-	((bls::Signature*)sig)->add(*(const bls::Signature*)rhs);
+	return mclBnFr_getStr(buf, maxBufSize, &sec->v, 10);
 }
-int blsSignatureRecover(blsSignature *sig, const blsSignature *sigVec, const blsId *idVec, size_t n)
-	try
+size_t blsSecretKeyGetHexStr(char *buf, size_t maxBufSize, const blsSecretKey *sec)
 {
-	((bls::Signature*)sig)->recover((const bls::Signature*)sigVec, (const bls::Id*)idVec, n);
-	return 0;
-} catch (std::exception& e) {
-	fprintf(stderr, "err blsSignatureRecover %s\n", e.what());
-	return -1;
+	return mclBnFr_getStr(buf, maxBufSize, &sec->v, 16);
 }
-
-int blsVerify(const blsSignature *sig, const blsPublicKey *pub, const char *m, size_t size)
+int blsHashToSecretKey(blsSecretKey *sec, const void *buf, size_t bufSize)
 {
-	return ((const bls::Signature*)sig)->verify(*(const bls::PublicKey*)pub, std::string(m, size));
+	return mclBnFr_setHashOf(&sec->v, buf, bufSize);
 }
 
-int blsVerifyPop(const blsSignature *sig, const blsPublicKey *pub)
+int blsSecretKeySetByCSPRNG(blsSecretKey *sec)
 {
-	return ((const bls::Signature*)sig)->verify(*(const bls::PublicKey*)pub);
+	return mclBnFr_setByCSPRNG(&sec->v);
+}
+int blsPublicKeySetHexStr(blsPublicKey *pub, const char *buf, size_t bufSize)
+{
+	return mclBnG2_setStr(&pub->v, buf, bufSize, 16);
+}
+size_t blsPublicKeyGetHexStr(char *buf, size_t maxBufSize, const blsPublicKey *pub)
+{
+	return mclBnG2_getStr(buf, maxBufSize, &pub->v, 16);
+}
+int blsSignatureSetHexStr(blsSignature *sig, const char *buf, size_t bufSize)
+{
+	return mclBnG1_setStr(&sig->v, buf, bufSize, 16);
+}
+size_t blsSignatureGetHexStr(char *buf, size_t maxBufSize, const blsSignature *sig)
+{
+	return mclBnG1_getStr(buf, maxBufSize, &sig->v, 16);
 }