Replaced secp256k1 with coincurve

raiden/encoding/signing.py

@@ -1,40 +1,22 @@
 # -*- coding: utf-8 -*-
-from secp256k1 import PublicKey, ALL_FLAGS
-
-from raiden.utils import sha3, GLOBAL_CTX
+from coincurve import PublicKey
+from raiden.utils import sha3
 
 
 def recover_publickey(messagedata, signature):
     if len(signature) != 65:
         raise ValueError('invalid signature')
 
-    key = PublicKey(
-        ctx=GLOBAL_CTX,
-        flags=ALL_FLAGS,  # FLAG_SIGN is required to recover publickeys
-    )
-
-    signature_data = key.ecdsa_recoverable_deserialize(
-        signature[:64],
-        ord(signature[64]),
-    )
-
-    message_hash = sha3(messagedata)
-    publickey_data = key.ecdsa_recover(message_hash, signature_data, raw=True)
-
-    publickey = PublicKey(
-        publickey_data,
-        ctx=GLOBAL_CTX
+    publickey = PublicKey.from_signature_and_message(
+        signature,
+        messagedata,
+        hasher=sha3,
     )
-
-    return publickey.serialize(compressed=False)
+    return publickey.format(compressed=False)
 
 
 def sign(messagedata, private_key):
-    message_hash = sha3(messagedata)
-    secp_signature = private_key.ecdsa_sign_recoverable(message_hash, raw=True)
-    signature_data = private_key.ecdsa_recoverable_serialize(secp_signature)
-    signature = signature_data[0] + chr(signature_data[1])
-
+    signature = private_key.sign_recoverable(messagedata, hasher=sha3)
     if len(signature) != 65:
         raise ValueError('invalid signature')
 

raiden/raiden_service.py

@@ -9,7 +9,8 @@
 from gevent.event import AsyncResult
 from ethereum import slogging
 from ethereum.utils import encode_hex
-from secp256k1 import PrivateKey
+
+from coincurve import PrivateKey
 
 from raiden.constants import UINT64_MAX
 from raiden.blockchain.events import (
@@ -105,7 +106,6 @@
     pex,
     privatekey_to_address,
     sha3,
-    GLOBAL_CTX,
 )
 
 log = slogging.get_logger(__name__)  # pylint: disable=invalid-name
@@ -144,12 +144,8 @@ def __init__(self, chain, private_key_bin, transport, discovery, config):
         if not isinstance(private_key_bin, bytes) or len(private_key_bin) != 32:
             raise ValueError('invalid private_key')
 
-        private_key = PrivateKey(
-            private_key_bin,
-            ctx=GLOBAL_CTX,
-            raw=True,
-        )
-        pubkey = private_key.pubkey.serialize(compressed=False)
+        private_key = PrivateKey(private_key_bin)
+        pubkey = private_key.public_key.format(compressed=False)
 
         self.channelgraphs = dict()
         self.manager_token = dict()

raiden/tests/benchmark/speed_decoding.py

@@ -4,7 +4,7 @@
 import contextlib
 import timeit
 
-import secp256k1
+import coincurve
 
 from raiden.utils import sha3, privatekey_to_address
 from raiden.messages import decode
@@ -13,10 +13,8 @@
     RefundTransfer, Secret, SecretRequest,
 )
 
-GLOBAL_CTX = secp256k1.lib.secp256k1_context_create(secp256k1.ALL_FLAGS)
-
 PRIVKEY_BIN = 'x' * 32
-PRIVKEY = secp256k1.PrivateKey(PRIVKEY_BIN, ctx=GLOBAL_CTX, raw=True)
+PRIVKEY = coincurve.PrivateKey(PRIVKEY_BIN)
 ADDRESS = privatekey_to_address(PRIVKEY_BIN)
 HASH = sha3(PRIVKEY)
 ITERATIONS = 1000000  # timeit default

raiden/tests/integration/test_settlement.py

@@ -316,8 +316,8 @@ def test_automatic_dispute(raiden_network, deposit, settle_timeout, reveal_timeo
     channel1 = app1.raiden.channelgraphs.values()[0].partneraddress_channel.values()[0]
     privatekey0 = app0.raiden.private_key
     privatekey1 = app1.raiden.private_key
-    address0 = privatekey_to_address(privatekey0.private_key)
-    address1 = privatekey_to_address(privatekey1.private_key)
+    address0 = privatekey_to_address(privatekey0.secret)
+    address1 = privatekey_to_address(privatekey1.secret)
     token = app0.raiden.chain.token(channel0.token_address)
     initial_balance0 = token.balance_of(address0)
     initial_balance1 = token.balance_of(address1)

raiden/tests/smart_contracts/test_channel_manager.py

@@ -4,9 +4,8 @@
 from ethereum import tester
 from ethereum.utils import encode_hex, sha3
 from raiden.utils import get_contract_path, privatekey_to_address
-from raiden.encoding.signing import GLOBAL_CTX
 from ethereum.tester import ABIContract, ContractTranslator, TransactionFailed
-from secp256k1 import PrivateKey
+from coincurve import PrivateKey
 
 from raiden.tests.utils.tester import new_channelmanager
 
@@ -154,7 +153,7 @@ def test_reopen_channel(
 
     privatekey0_raw, privatekey1_raw, nettingchannel, channel0, _ = tester_channels[0]
 
-    privatekey0 = PrivateKey(privatekey0_raw, ctx=GLOBAL_CTX, raw=True)
+    privatekey0 = PrivateKey(privatekey0_raw)
     address0 = privatekey_to_address(privatekey0_raw)
     address1 = privatekey_to_address(privatekey1_raw)
     address2 = tester.a2

raiden/tests/smart_contracts/test_decoder_netting_channel.py

@@ -4,21 +4,22 @@
 import pytest
 from ethereum import tester
 from ethereum.tester import TransactionFailed
-from secp256k1 import PrivateKey
+
+from coincurve import PrivateKey
 from pyethapp.jsonrpc import address_decoder
 
 from raiden.encoding import messages
-from raiden.utils import sha3, privatekey_to_address, get_project_root
 from raiden.encoding.format import compute_slices
-from raiden.encoding.signing import GLOBAL_CTX
+from raiden.utils import sha3, privatekey_to_address, get_project_root
+
+
 from raiden.tests.utils.tests import get_test_contract_path
 from raiden.tests.utils.messages import (
     make_direct_transfer,
     make_mediated_transfer,
     make_refund_transfer,
 )
 
-
 VALID_LOCKSROOT = [
     sha3('WaldemarstrWaldemarstrWaldemarst'),
     sha3('SikorkaSikorkaSikorkaSikorkaSiko'),
@@ -83,7 +84,7 @@ def test_decode_direct_transfer(
         transferred_amount=transferred_amount,
         locksroot=locksroot,
     )
-    direct_transfer.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
+    direct_transfer.sign(PrivateKey(privatekey0), address0)
 
     assert_decoder_results(direct_transfer, decoder)
 
@@ -118,8 +119,7 @@ def test_decode_mediated_transfer(
         locksroot=locksroot,
     )
 
-    mediated_transfer.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
-
+    mediated_transfer.sign(PrivateKey(privatekey0), address0)
     assert_decoder_results(mediated_transfer, decoder)
 
 
@@ -149,8 +149,7 @@ def test_decode_refund_transfer(
         transferred_amount=transferred_amount,
         locksroot=locksroot,
     )
-    refund_transfer.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
-
+    refund_transfer.sign(PrivateKey(privatekey0), address0)
     assert_decoder_results(refund_transfer, decoder)
 
 
@@ -161,7 +160,7 @@ def test_decode_tampered_direct_transfer(tester_state, tester_nettingchannel_lib
     decoder = deploy_decoder_tester(tester_state, tester_nettingchannel_library_address)
 
     direct_transfer = make_direct_transfer()
-    direct_transfer.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
+    direct_transfer.sign(PrivateKey(privatekey0), address0)
 
     message_encoded = direct_transfer.encode()
     transfer_raw, _ = decoder.getTransferRawAddress(message_encoded)
@@ -192,7 +191,7 @@ def test_decode_tampered_mediated_transfer(tester_state, tester_nettingchannel_l
 
     mediated_transfer = make_mediated_transfer()
 
-    mediated_transfer.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
+    mediated_transfer.sign(PrivateKey(privatekey0), address0)
 
     message_encoded = mediated_transfer.encode()
     transfer_raw, _ = decoder.getTransferRawAddress(message_encoded)
@@ -222,7 +221,7 @@ def test_decode_tampered_refund_transfer(tester_state, tester_nettingchannel_lib
     decoder = deploy_decoder_tester(tester_state, tester_nettingchannel_library_address)
 
     refund_transfer = make_refund_transfer()
-    refund_transfer.sign(PrivateKey(privatekey0, ctx=GLOBAL_CTX, raw=True), address0)
+    refund_transfer.sign(PrivateKey(privatekey0), address0)
 
     message_encoded = refund_transfer.encode()
     transfer_raw, _ = decoder.getTransferRawAddress(message_encoded)

raiden/tests/smart_contracts/test_netting_channel.py

@@ -6,9 +6,8 @@
 from ethereum import abi, tester
 from ethereum.tester import TransactionFailed
 from ethereum.utils import encode_hex
-from secp256k1 import PrivateKey
+from coincurve import PrivateKey
 
-from raiden.encoding.signing import GLOBAL_CTX
 from raiden.messages import Lock, DirectTransfer, MediatedTransfer
 from raiden.mtree import Merkletree
 from raiden.tests.utils.messages import (
@@ -46,7 +45,7 @@ def make_direct_transfer_from_channel(channel, partner_channel, amount, pkey):
     )
 
     address = privatekey_to_address(pkey)
-    sign_key = PrivateKey(pkey, ctx=GLOBAL_CTX, raw=True)
+    sign_key = PrivateKey(pkey)
     direct_transfer.sign(sign_key, address)
 
     # if this fails it's not the right key for the current `channel`
@@ -84,7 +83,7 @@ def make_mediated_transfer(
     )
 
     address = privatekey_to_address(pkey)
-    sign_key = PrivateKey(pkey, ctx=GLOBAL_CTX, raw=True)
+    sign_key = PrivateKey(pkey)
     mediated_transfer.sign(sign_key, address)
 
     channel.block_number = block_number
@@ -360,7 +359,7 @@ def test_close_accepts_only_transfer_from_participants(tester_channels, private_
     )
 
     nonparticipant_address = privatekey_to_address(nonparticipant_key)
-    nonparticipant_sign_key = PrivateKey(nonparticipant_key, ctx=GLOBAL_CTX, raw=True)
+    nonparticipant_sign_key = PrivateKey(nonparticipant_key)
 
     transfer_nonparticipant.sign(nonparticipant_sign_key, nonparticipant_address)
     transfer_nonparticipant_data = str(transfer_nonparticipant.packed().data)
@@ -418,7 +417,7 @@ def test_close_valid_tranfer_different_token(
     )
 
     address = privatekey_to_address(pkey0)
-    sign_key = PrivateKey(pkey0, ctx=GLOBAL_CTX, raw=True)
+    sign_key = PrivateKey(pkey0)
     direct_transfer_other_token.sign(sign_key, address)
 
     direct_transfer_data = direct_transfer_other_token.encode()
@@ -520,7 +519,7 @@ def test_update_must_fail_with_a_nonparticipant_transfer(tester_channels, privat
     )
 
     nonparticipant_address = privatekey_to_address(nonparticipant_key)
-    nonparticipant_sign_key = PrivateKey(nonparticipant_key, ctx=GLOBAL_CTX, raw=True)
+    nonparticipant_sign_key = PrivateKey(nonparticipant_key)
 
     transfer_nonparticipant.sign(nonparticipant_sign_key, nonparticipant_address)
     transfer_nonparticipant_data = str(transfer_nonparticipant.packed().data)
@@ -1083,7 +1082,7 @@ def test_withdraw_at_settlement_block(
         fee=0,
     )
 
-    sign_key0 = PrivateKey(pkey0, ctx=GLOBAL_CTX, raw=True)
+    sign_key0 = PrivateKey(pkey0)
     mediated0.sign(sign_key0, address0)
     mediated0_data = str(mediated0.packed().data)
     nettingchannel.close(mediated0_data, sender=pkey1)
@@ -1319,7 +1318,7 @@ def test_withdraw_fails_with_partial_merkle_proof(
     )
 
     address = privatekey_to_address(pkey0)
-    sign_key = PrivateKey(pkey0, ctx=GLOBAL_CTX, raw=True)
+    sign_key = PrivateKey(pkey0)
     direct_transfer.sign(sign_key, address)
 
     direct_transfer_data = str(direct_transfer.packed().data)
@@ -1369,7 +1368,7 @@ def test_withdraw_tampered_merkle_proof(tree, tester_channels, tester_state, set
     )
 
     address = privatekey_to_address(pkey0)
-    sign_key = PrivateKey(pkey0, ctx=GLOBAL_CTX, raw=True)
+    sign_key = PrivateKey(pkey0)
     direct_transfer.sign(sign_key, address)
 
     direct_transfer_data = str(direct_transfer.packed().data)
@@ -1431,7 +1430,7 @@ def test_withdraw_tampered_lock_amount(
     )
 
     address = privatekey_to_address(pkey0)
-    sign_key = PrivateKey(pkey0, ctx=GLOBAL_CTX, raw=True)
+    sign_key = PrivateKey(pkey0)
     direct_transfer.sign(sign_key, address)
 
     direct_transfer_data = str(direct_transfer.packed().data)

raiden/tests/unit/test_transfer.py

@@ -4,9 +4,8 @@
 import gevent
 import pytest
 from ethereum import slogging
-from secp256k1 import PrivateKey
+from coincurve import PrivateKey
 
-from raiden.encoding.signing import GLOBAL_CTX
 from raiden.messages import (
     Ack,
     decode,
@@ -395,8 +394,8 @@ def test_receive_directtransfer_unknown(raiden_network):
     app0 = raiden_network[0]  # pylint: disable=unbalanced-tuple-unpacking
     graph0 = app0.raiden.channelgraphs.values()[0]
 
-    other_key = PrivateKey(HASH, ctx=GLOBAL_CTX, raw=True)
-    other_address = privatekey_to_address(other_key.private_key)
+    other_key = PrivateKey(HASH)
+    other_address = privatekey_to_address(HASH)
     direct_transfer = DirectTransfer(
         identifier=1,
         nonce=1,
@@ -415,8 +414,8 @@ def test_receive_mediatedtransfer_unknown(raiden_network):
     app0 = raiden_network[0]  # pylint: disable=unbalanced-tuple-unpacking
     graph0 = app0.raiden.channelgraphs.values()[0]
 
-    other_key = PrivateKey(HASH, ctx=GLOBAL_CTX, raw=True)
-    other_address = privatekey_to_address(other_key.private_key)
+    other_key = PrivateKey(HASH)
+    other_address = privatekey_to_address(HASH)
     amount = 10
     locksroot = HASH
     mediated_transfer = MediatedTransfer(
@@ -442,8 +441,8 @@ def test_receive_hashlocktransfer_unknown(raiden_network):
 
     graph0 = app0.raiden.channelgraphs.values()[0]
 
-    other_key = PrivateKey(HASH2, ctx=GLOBAL_CTX, raw=True)
-    other_address = privatekey_to_address(other_key.private_key)
+    other_key = PrivateKey(HASH2)
+    other_address = privatekey_to_address(HASH2)
     amount = 10
     lock = Lock(amount, 1, HASH)
     refund_transfer = RefundTransfer(