KeyAPI(backend=None)

The KeyAPI object is the primary API for interacting with the ethereum-keys libary. The object takes a single optional argument in it’s constructor which designates what backend will be used for eliptical curve cryptography operations. The built-in backends are:

• eth_keys.backends.NativeECCBackend A pure python implementation of the ECC operations.

• eth_keys.backends.CoinCurveECCBackend: Uses the `coincurve <https://github.com/ofek/coincurve>`__ library for ECC operations.

By default, ethereum-keys will try to use the CoinCurveECCBackend, falling back to the NativeECCBackend if the coincurve library is not available.

Note: The coincurve library is not automatically installed with ethereum-keys and must be installed separately.

The backend argument can be given in any of the following forms.

• Instance of the backend class

• The backend class

• String with the dot-separated import path for the backend class.

>>> from eth_keys import KeyAPI
>>> from eth_keys.backends import NativeECCBackend
# These are all the same
>>> keys = KeyAPI(NativeECCBackend)
>>> keys = KeyAPI(NativeECCBackend())
>>> keys = KeyAPI('eth_keys.backends.NativeECCBackend')
# Or for the coincurve base backend
>>> keys = KeyAPI('eth_keys.backends.CoinCurveECCBackend')

The backend can also be configured using the environment variable ECC_BACKEND_CLASS which should be set to the dot-separated python import path to the desired backend.

>>> import os
>>> os.environ['ECC_BACKEND_CLASS'] = 'eth_keys.backends.CoinCurveECCBackend'

KeyAPI.ecdsa_sign(message_hash, private_key) -> Signature

This method returns a signature for the given message_hash, signed by the provided public_key.

• message_hash: must be a byte string of length 32

• private_key: must be an instance of PrivateKey

KeyAPI.ecdsa_verify(message_hash, signature, public_key) -> bool

Returns True or False based on whether the provided signature is a valid signature for the provided message_hash and public_key.

• message_hash: must be a byte string of length 32

• signature: must be an instance of Signature

• public_key: must be an instance of PublicKey

KeyAPI.ecdsa_recover(message_hash, signature) -> PublicKey

Returns the PublicKey instances recovered from the given signature and message_hash.

• message_hash: must be a byte string of length 32

• signature: must be an instance of Signature

KeyAPI.private_key_to_public_key(private_key) -> PublicKey

Returns the PublicKey instances computed from the given private_key instance.

• private_key: must be an instance of PublicKey

Common APIs for PublicKey, PrivateKey and Signature

There is a common API for the following objects.

• PublicKey

• PrivateKey

• Signature

Each of these objects has all of the following APIs.

• obj.to_bytes(): Returns the object in it’s canonical bytes serialization.

• obj.to_hex(): Returns a text string of the hex encoded canonical representation.

• bytes(obj): Same as obj.to_bytes()

• hex(obj): Same as obj.to_hex()

KeyAPI.PublicKey(public_key_bytes)

The PublicKey class takes a single argument which must be a bytes string with length 64.

Note that some libraries prefix the byte serialized public key with a leading \x04 byte which must be removed before use with the PublicKey object.

The following methods are available:

KeyAPI.PrivateKey(private_key_bytes)

The PrivateKey class takes a single argument which must be a bytes string with length 32.

The following methods and properties are available

KeyAPI.Signature(signature_bytes=None, vrs=None)

The Signature class can be instantiated in one of two ways.

• signature_bytes: a bytes string with length 65.

• vrs: a 3-tuple composed of the integers v, r, and s.

  Note: If using the signature_bytes to instantiate, the byte string should be encoded as r_bytes | s_bytes | v_bytes where | represents concatenation. r_bytes and s_bytes should be 32 bytes in length. v_bytes should be a single byte \x00 or \x01.

The following methods and properties are available

Exceptions