diff options
Diffstat (limited to 'Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/ethash.cc')
| -rw-r--r-- | Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/ethash.cc | 587 |
1 files changed, 587 insertions, 0 deletions
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/ethash.cc b/Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/ethash.cc new file mode 100644 index 000000000..6ab9730be --- /dev/null +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/ethash.cc @@ -0,0 +1,587 @@ +#include <nan.h> +#include <iostream> +#include <node.h> +#include <stdint.h> +#include <stdlib.h> +#include "../libethash/ethash.h" + +using namespace v8; + +class EthashValidator : public NanAsyncWorker { + public: + // Constructor + EthashValidator(NanCallback *callback, const unsigned blocknumber, const unsigned char * seed) + : NanAsyncWorker(callback), blocknumber(blocknumber), seed(seed) {} + // Destructor + ~EthashValidator() { + free(this->cache); + free(this->params); + } + + // Executed inside the worker-thread. + // It is not safe to access V8, or V8 data structures + // here, so everything we need for input and output + // should go on `this`. + void Execute () { + + /* this->result = secp256k1_ecdsa_sign(this->msg, this->sig , &this->sig_len, this->pk, NULL, NULL); */ + } + + // Executed when the async work is complete + // this function will be run inside the main event loop + // so it is safe to use V8 again + void HandleOKCallback () { + NanScope(); + Handle<Value> argv[] = { + NanNew<Number>(this->result) + }; + callback->Call(2, argv); + } + + protected: + const unsigned blocknumber; + const unsigned char * seed; + ethash_params * params; + ethash_cache * cache; + bool result; + bool ready = 0; +}; + +/* class CompactSignWorker : public SignWorker { */ +/* public: */ +/* CompactSignWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *pk ) */ +/* : SignWorker(callback, msg, pk){} */ + +/* void Execute () { */ +/* this->result = secp256k1_ecdsa_sign_compact(this->msg, this->sig , this->pk, NULL, NULL, &this->sig_len); */ +/* } */ + +/* void HandleOKCallback () { */ +/* NanScope(); */ +/* Handle<Value> argv[] = { */ +/* NanNew<Number>(this->result), */ +/* NanNewBufferHandle((char *)this->sig, 64), */ +/* NanNew<Number>(this->sig_len) */ +/* }; */ +/* callback->Call(3, argv); */ +/* } */ +/* }; */ + +/* class RecoverWorker : public NanAsyncWorker { */ +/* public: */ +/* // Constructor */ +/* RecoverWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *sig, int compressed, int rec_id) */ +/* : NanAsyncWorker(callback), msg(msg), sig(sig), compressed(compressed), rec_id(rec_id) {} */ +/* // Destructor */ +/* ~RecoverWorker() {} */ + +/* void Execute () { */ +/* if(this->compressed == 1){ */ +/* this->pubkey = new unsigned char[33]; */ +/* }else{ */ +/* this->pubkey = new unsigned char[65]; */ +/* } */ + +/* this->result = secp256k1_ecdsa_recover_compact(this->msg, this->sig, this->pubkey, &this->pubkey_len, this->compressed, this->rec_id); */ +/* } */ + +/* void HandleOKCallback () { */ +/* NanScope(); */ +/* Handle<Value> argv[] = { */ +/* NanNew<Number>(this->result), */ +/* NanNewBufferHandle((char *)this->pubkey, this->pubkey_len) */ +/* }; */ +/* callback->Call(2, argv); */ +/* } */ + +/* protected: */ +/* const unsigned char * msg; */ +/* const unsigned char * sig; */ +/* int compressed; */ +/* int rec_id; */ +/* int result; */ +/* unsigned char * pubkey; */ +/* int pubkey_len; */ +/* }; */ + +/* class VerifyWorker : public NanAsyncWorker { */ +/* public: */ +/* // Constructor */ +/* VerifyWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *sig, int sig_len, const unsigned char *pub_key, int pub_key_len) */ +/* : NanAsyncWorker(callback), msg(msg), sig(sig), sig_len(sig_len), pub_key(pub_key), pub_key_len(pub_key_len) {} */ +/* // Destructor */ +/* ~VerifyWorker() {} */ + +/* void Execute () { */ +/* this->result = secp256k1_ecdsa_verify(this->msg, this->sig, this->sig_len, this->pub_key, this->pub_key_len); */ +/* } */ + +/* void HandleOKCallback () { */ +/* NanScope(); */ +/* Handle<Value> argv[] = { */ +/* NanNew<Number>(this->result), */ +/* }; */ +/* callback->Call(1, argv); */ +/* } */ + +/* protected: */ +/* int result; */ +/* const unsigned char * msg; */ +/* const unsigned char * sig; */ +/* int sig_len; */ +/* const unsigned char * pub_key; */ +/* int pub_key_len; */ +/* }; */ + +/* NAN_METHOD(Verify){ */ +/* NanScope(); */ + +/* Local<Object> pub_buf = args[0].As<Object>(); */ +/* const unsigned char *pub_data = (unsigned char *) node::Buffer::Data(pub_buf); */ +/* int pub_len = node::Buffer::Length(args[0]); */ + +/* Local<Object> msg_buf = args[1].As<Object>(); */ +/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ + +/* Local<Object> sig_buf = args[2].As<Object>(); */ +/* const unsigned char *sig_data = (unsigned char *) node::Buffer::Data(sig_buf); */ +/* int sig_len = node::Buffer::Length(args[2]); */ + +/* int result = secp256k1_ecdsa_verify(msg_data, sig_data, sig_len, pub_data, pub_len ); */ + +/* NanReturnValue(NanNew<Number>(result)); */ +/* } */ + +/* NAN_METHOD(Verify_Async){ */ +/* NanScope(); */ + +/* Local<Object> pub_buf = args[0].As<Object>(); */ +/* const unsigned char *pub_data = (unsigned char *) node::Buffer::Data(pub_buf); */ +/* int pub_len = node::Buffer::Length(args[0]); */ + +/* Local<Object> msg_buf = args[1].As<Object>(); */ +/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ + +/* Local<Object> sig_buf = args[2].As<Object>(); */ +/* const unsigned char *sig_data = (unsigned char *) node::Buffer::Data(sig_buf); */ +/* int sig_len = node::Buffer::Length(args[2]); */ + +/* Local<Function> callback = args[3].As<Function>(); */ +/* NanCallback* nanCallback = new NanCallback(callback); */ + +/* VerifyWorker* worker = new VerifyWorker(nanCallback, msg_data, sig_data, sig_len, pub_data, pub_len); */ +/* NanAsyncQueueWorker(worker); */ + +/* NanReturnUndefined(); */ +/* } */ + +/* NAN_METHOD(Sign){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Local<Object> pk_buf = args[0].As<Object>(); */ +/* const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ +/* int sec_len = node::Buffer::Length(args[0]); */ +/* //the second argument is the message that we are signing */ +/* Local<Object> msg_buf = args[1].As<Object>(); */ +/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ + +/* unsigned char sig[72]; */ +/* int sig_len = 72; */ +/* int msg_len = node::Buffer::Length(args[1]); */ + +/* if(sec_len != 32){ */ +/* return NanThrowError("the secret key needs tobe 32 bytes"); */ +/* } */ + +/* if(msg_len == 0){ */ +/* return NanThrowError("messgae cannot be null"); */ +/* } */ + +/* int result = secp256k1_ecdsa_sign(msg_data, sig , &sig_len, pk_data, NULL, NULL); */ + +/* if(result == 1){ */ +/* NanReturnValue(NanNewBufferHandle((char *)sig, sig_len)); */ +/* }else{ */ +/* return NanThrowError("nonce invalid, try another one"); */ +/* } */ +/* } */ + +/* NAN_METHOD(Sign_Async){ */ + +/* NanScope(); */ +/* //the first argument should be the private key as a buffer */ +/* Local<Object> sec_buf = args[0].As<Object>(); */ +/* const unsigned char *sec_data = (unsigned char *) node::Buffer::Data(sec_buf); */ +/* int sec_len = node::Buffer::Length(args[0]); */ +/* //the second argument is the message that we are signing */ +/* Local<Object> msg_buf = args[1].As<Object>(); */ +/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ + +/* Local<Function> callback = args[2].As<Function>(); */ +/* NanCallback* nanCallback = new NanCallback(callback); */ + +/* int msg_len = node::Buffer::Length(args[1]); */ + +/* if(sec_len != 32){ */ +/* return NanThrowError("the secret key needs tobe 32 bytes"); */ +/* } */ + +/* if(msg_len == 0){ */ +/* return NanThrowError("messgae cannot be null"); */ +/* } */ + +/* SignWorker* worker = new SignWorker(nanCallback, msg_data, sec_data); */ +/* NanAsyncQueueWorker(worker); */ + +/* NanReturnUndefined(); */ +/* } */ + +/* NAN_METHOD(Sign_Compact){ */ + +/* NanScope(); */ + +/* Local<Object> seckey_buf = args[0].As<Object>(); */ +/* const unsigned char *seckey_data = (unsigned char *) node::Buffer::Data(seckey_buf); */ +/* int sec_len = node::Buffer::Length(args[0]); */ + +/* Local<Object> msg_buf = args[1].As<Object>(); */ +/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ +/* int msg_len = node::Buffer::Length(args[1]); */ + +/* if(sec_len != 32){ */ +/* return NanThrowError("the secret key needs tobe 32 bytes"); */ +/* } */ + +/* if(msg_len == 0){ */ +/* return NanThrowError("messgae cannot be null"); */ +/* } */ + +/* unsigned char sig[64]; */ +/* int rec_id; */ + +/* //TODO: change the nonce */ +/* int valid_nonce = secp256k1_ecdsa_sign_compact(msg_data, sig, seckey_data, NULL, NULL, &rec_id ); */ + +/* Local<Array> array = NanNew<Array>(3); */ +/* array->Set(0, NanNew<Integer>(valid_nonce)); */ +/* array->Set(1, NanNew<Integer>(rec_id)); */ +/* array->Set(2, NanNewBufferHandle((char *)sig, 64)); */ + +/* NanReturnValue(array); */ +/* } */ + +/* NAN_METHOD(Sign_Compact_Async){ */ +/* NanScope(); */ +/* //the first argument should be the private key as a buffer */ +/* Local<Object> sec_buf = args[0].As<Object>(); */ +/* const unsigned char *sec_data = (unsigned char *) node::Buffer::Data(sec_buf); */ +/* int sec_len = node::Buffer::Length(args[0]); */ + +/* //the second argument is the message that we are signing */ +/* Local<Object> msg_buf = args[1].As<Object>(); */ +/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ + + +/* Local<Function> callback = args[2].As<Function>(); */ +/* NanCallback* nanCallback = new NanCallback(callback); */ + +/* int msg_len = node::Buffer::Length(args[1]); */ + +/* if(sec_len != 32){ */ +/* return NanThrowError("the secret key needs tobe 32 bytes"); */ +/* } */ + +/* if(msg_len == 0){ */ +/* return NanThrowError("messgae cannot be null"); */ +/* } */ + +/* CompactSignWorker* worker = new CompactSignWorker(nanCallback, msg_data, sec_data); */ +/* NanAsyncQueueWorker(worker); */ + +/* NanReturnUndefined(); */ +/* } */ + +/* NAN_METHOD(Recover_Compact){ */ + +/* NanScope(); */ + +/* Local<Object> msg_buf = args[0].As<Object>(); */ +/* const unsigned char *msg = (unsigned char *) node::Buffer::Data(msg_buf); */ +/* int msg_len = node::Buffer::Length(args[0]); */ + +/* Local<Object> sig_buf = args[1].As<Object>(); */ +/* const unsigned char *sig = (unsigned char *) node::Buffer::Data(sig_buf); */ + +/* Local<Number> compressed = args[2].As<Number>(); */ +/* int int_compressed = compressed->IntegerValue(); */ + +/* Local<Number> rec_id = args[3].As<Number>(); */ +/* int int_rec_id = rec_id->IntegerValue(); */ + +/* if(msg_len == 0){ */ +/* return NanThrowError("messgae cannot be null"); */ +/* } */ + +/* unsigned char pubKey[65]; */ + +/* int pubKeyLen; */ + +/* int result = secp256k1_ecdsa_recover_compact(msg, sig, pubKey, &pubKeyLen, int_compressed, int_rec_id); */ +/* if(result == 1){ */ +/* NanReturnValue(NanNewBufferHandle((char *)pubKey, pubKeyLen)); */ +/* }else{ */ + +/* NanReturnValue(NanFalse()); */ +/* } */ +/* } */ + +/* NAN_METHOD(Recover_Compact_Async){ */ + +/* NanScope(); */ + +/* //the message */ +/* Local<Object> msg_buf = args[0].As<Object>(); */ +/* const unsigned char *msg = (unsigned char *) node::Buffer::Data(msg_buf); */ +/* int msg_len = node::Buffer::Length(args[0]); */ + +/* //the signature length */ +/* Local<Object> sig_buf = args[1].As<Object>(); */ +/* const unsigned char *sig = (unsigned char *) node::Buffer::Data(sig_buf); */ +/* //todo sig len needs tobe 64 */ +/* int sig_len = node::Buffer::Length(args[1]); */ + +/* //to compress or not? */ +/* Local<Number> compressed = args[2].As<Number>(); */ +/* int int_compressed = compressed->IntegerValue(); */ + +/* //the rec_id */ +/* Local<Number> rec_id = args[3].As<Number>(); */ +/* int int_rec_id = rec_id->IntegerValue(); */ + +/* //the callback */ +/* Local<Function> callback = args[4].As<Function>(); */ +/* NanCallback* nanCallback = new NanCallback(callback); */ + +/* if(sig_len != 64){ */ +/* return NanThrowError("the signature needs to be 64 bytes"); */ +/* } */ + +/* if(msg_len == 0){ */ +/* return NanThrowError("messgae cannot be null"); */ +/* } */ + +/* RecoverWorker* worker = new RecoverWorker(nanCallback, msg, sig, int_compressed, int_rec_id); */ +/* NanAsyncQueueWorker(worker); */ + +/* NanReturnUndefined(); */ +/* } */ + +/* NAN_METHOD(Seckey_Verify){ */ +/* NanScope(); */ + +/* const unsigned char *data = (const unsigned char*) node::Buffer::Data(args[0]); */ +/* int result = secp256k1_ec_seckey_verify(data); */ +/* NanReturnValue(NanNew<Number>(result)); */ +/* } */ + +/* NAN_METHOD(Pubkey_Verify){ */ + +/* NanScope(); */ + +/* Local<Object> pub_buf = args[0].As<Object>(); */ +/* const unsigned char *pub_key = (unsigned char *) node::Buffer::Data(pub_buf); */ +/* int pub_key_len = node::Buffer::Length(args[0]); */ + +/* int result = secp256k1_ec_pubkey_verify(pub_key, pub_key_len); */ + +/* NanReturnValue(NanNew<Number>(result)); */ +/* } */ + +/* NAN_METHOD(Pubkey_Create){ */ +/* NanScope(); */ + +/* Handle<Object> pk_buf = args[0].As<Object>(); */ +/* const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ +/* int pk_len = node::Buffer::Length(args[0]); */ + +/* Local<Number> l_compact = args[1].As<Number>(); */ +/* int compact = l_compact->IntegerValue(); */ +/* int pubKeyLen; */ + +/* if(pk_len != 32){ */ +/* return NanThrowError("the secert key need to be 32 bytes"); */ +/* } */ + +/* unsigned char *pubKey; */ +/* if(compact == 1){ */ +/* pubKey = new unsigned char[33]; */ +/* }else{ */ +/* pubKey = new unsigned char[65]; */ +/* } */ + +/* int results = secp256k1_ec_pubkey_create(pubKey,&pubKeyLen, pk_data, compact ); */ +/* if(results == 0){ */ +/* return NanThrowError("secret was invalid, try again."); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)pubKey, pubKeyLen)); */ +/* } */ +/* } */ + +/* NAN_METHOD(Pubkey_Decompress){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Local<Object> pk_buf = args[0].As<Object>(); */ +/* unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ + +/* int pk_len = node::Buffer::Length(args[0]); */ + +/* int results = secp256k1_ec_pubkey_decompress(pk_data, &pk_len); */ + +/* if(results == 0){ */ +/* return NanThrowError("invalid public key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)pk_data, pk_len)); */ +/* } */ +/* } */ + + +/* NAN_METHOD(Privkey_Import){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Handle<Object> pk_buf = args[0].As<Object>(); */ +/* const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ + +/* int pk_len = node::Buffer::Length(args[0]); */ + +/* unsigned char sec_key[32]; */ +/* int results = secp256k1_ec_privkey_import(sec_key, pk_data, pk_len); */ + +/* if(results == 0){ */ +/* return NanThrowError("invalid private key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)sec_key, 32)); */ +/* } */ +/* } */ + +/* NAN_METHOD(Privkey_Export){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Handle<Object> sk_buf = args[0].As<Object>(); */ +/* const unsigned char *sk_data = (unsigned char *) node::Buffer::Data(sk_buf); */ + +/* Local<Number> l_compressed = args[1].As<Number>(); */ +/* int compressed = l_compressed->IntegerValue(); */ + +/* unsigned char *privKey; */ +/* int pk_len; */ +/* int results = secp256k1_ec_privkey_export(sk_data, privKey, &pk_len, compressed); */ +/* if(results == 0){ */ +/* return NanThrowError("invalid private key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)privKey, pk_len)); */ +/* } */ +/* } */ + +/* NAN_METHOD(Privkey_Tweak_Add){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Handle<Object> sk_buf = args[0].As<Object>(); */ +/* unsigned char *sk = (unsigned char *) node::Buffer::Data(sk_buf); */ + +/* Handle<Object> tweak_buf = args[1].As<Object>(); */ +/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ + +/* int results = secp256k1_ec_privkey_tweak_add(sk, tweak); */ +/* if(results == 0){ */ +/* return NanThrowError("invalid key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)sk, 32)); */ +/* } */ +/* } */ + +/* NAN_METHOD(Privkey_Tweak_Mul){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Handle<Object> sk_buf = args[0].As<Object>(); */ +/* unsigned char *sk = (unsigned char *) node::Buffer::Data(sk_buf); */ + +/* Handle<Object> tweak_buf = args[1].As<Object>(); */ +/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ + +/* int results = secp256k1_ec_privkey_tweak_mul(sk, tweak); */ +/* if(results == 0){ */ +/* return NanThrowError("invalid key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)sk, 32)); */ +/* } */ +/* } */ + +/* NAN_METHOD(Pubkey_Tweak_Add){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Handle<Object> pk_buf = args[0].As<Object>(); */ +/* unsigned char *pk = (unsigned char *) node::Buffer::Data(pk_buf); */ +/* int pk_len = node::Buffer::Length(args[0]); */ + +/* Handle<Object> tweak_buf = args[1].As<Object>(); */ +/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ + +/* int results = secp256k1_ec_pubkey_tweak_add(pk, pk_len, tweak); */ +/* if(results == 0){ */ +/* return NanThrowError("invalid key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)pk, pk_len)); */ +/* } */ +/* } */ + +/* NAN_METHOD(Pubkey_Tweak_Mul){ */ +/* NanScope(); */ + +/* //the first argument should be the private key as a buffer */ +/* Handle<Object> pk_buf = args[0].As<Object>(); */ +/* unsigned char *pk = (unsigned char *) node::Buffer::Data(pk_buf); */ +/* int pk_len = node::Buffer::Length(args[0]); */ + +/* Handle<Object> tweak_buf = args[1].As<Object>(); */ +/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ + +/* int results = secp256k1_ec_pubkey_tweak_mul(pk, pk_len, tweak); */ +/* if(results == 0){ */ +/* return NanThrowError("invalid key"); */ +/* }else{ */ +/* NanReturnValue(NanNewBufferHandle((char *)pk, pk_len)); */ +/* } */ +/* } */ + +void Init(Handle<Object> exports) { + + /* secp256k1_start(SECP256K1_START_SIGN | SECP256K1_START_VERIFY); */ + /* exports->Set(NanNew("seckeyVerify"), NanNew<FunctionTemplate>(Seckey_Verify)->GetFunction()); */ + /* exports->Set(NanNew("sign"), NanNew<FunctionTemplate>(Sign)->GetFunction()); */ + /* exports->Set(NanNew("signAsync"), NanNew<FunctionTemplate>(Sign_Async)->GetFunction()); */ + /* exports->Set(NanNew("signCompact"), NanNew<FunctionTemplate>(Sign_Compact)->GetFunction()); */ + /* exports->Set(NanNew("signCompactAsync"), NanNew<FunctionTemplate>(Sign_Compact_Async)->GetFunction()); */ + /* exports->Set(NanNew("recoverCompact"), NanNew<FunctionTemplate>(Recover_Compact)->GetFunction()); */ + /* exports->Set(NanNew("recoverCompactAsync"), NanNew<FunctionTemplate>(Recover_Compact_Async)->GetFunction()); */ + /* exports->Set(NanNew("verify"), NanNew<FunctionTemplate>(Verify)->GetFunction()); */ + /* exports->Set(NanNew("verifyAsync"), NanNew<FunctionTemplate>(Verify_Async)->GetFunction()); */ + /* exports->Set(NanNew("secKeyVerify"), NanNew<FunctionTemplate>(Seckey_Verify)->GetFunction()); */ + /* exports->Set(NanNew("pubKeyVerify"), NanNew<FunctionTemplate>(Pubkey_Verify)->GetFunction()); */ + /* exports->Set(NanNew("pubKeyCreate"), NanNew<FunctionTemplate>(Pubkey_Create)->GetFunction()); */ + /* exports->Set(NanNew("pubKeyDecompress"), NanNew<FunctionTemplate>(Pubkey_Decompress)->GetFunction()); */ + /* exports->Set(NanNew("privKeyExport"), NanNew<FunctionTemplate>(Privkey_Export)->GetFunction()); */ + /* exports->Set(NanNew("privKeyImport"), NanNew<FunctionTemplate>(Privkey_Import)->GetFunction()); */ + /* exports->Set(NanNew("privKeyTweakAdd"), NanNew<FunctionTemplate>(Privkey_Tweak_Add)->GetFunction()); */ + /* exports->Set(NanNew("privKeyTweakMul"), NanNew<FunctionTemplate>(Privkey_Tweak_Mul)->GetFunction()); */ + /* exports->Set(NanNew("pubKeyTweakAdd"), NanNew<FunctionTemplate>(Privkey_Tweak_Add)->GetFunction()); */ + /* exports->Set(NanNew("pubKeyTweakMul"), NanNew<FunctionTemplate>(Privkey_Tweak_Mul)->GetFunction()); */ +} + +NODE_MODULE(secp256k1, Init) |