def create(cls) -> 'Member':
"""
Creates new member with a signing (private) key
"""
verify_key_bytes, signing_key_bytes = crypto_sign_keypair()
verify_key = base64_encode(verify_key_bytes).decode("UTF-8")
signing_key = base64_encode(signing_key_bytes).decode("UTF-8")
new_member = Member(verify_key, signing_key)
new_member.name = "Me"
bptc.logger.info("Created new Member: " + str(new_member))
return new_member
def __init__(self, identifier, seed=None):
"""
Initialize the signer with an identifier and a seed.
:param identifier: some identifier that directly or indirectly references this client
:param seed: the seed used to generate a signing key.
"""
self.identifier = identifier
# should be stored securely/privately
self.seed = seed if seed else randombytes(32)
# generates key pair based on seed
self.sk = SigningKey(seed=self.seed)
# helper for signing
self.naclSigner = NaclSigner(self.sk)
# this is the public key used to verify signatures (securely shared
# before-hand with recipient)
self.verkey = self.naclSigner.verhex
self.verstr = base64_encode(self.naclSigner.keyraw).decode('utf-8')
def hex_to_base64(string: str) -> str:
"""
Compresses a given string for web sharing
:param string: str
:return: str
"""
return decode(base64_encode(hex_decode(string)))
def sign(self, msg: Mapping) -> Mapping:
"""
Return a signature for the given message.
"""
ser = serializeForSig(msg)
bsig = self.naclSigner.signature(ser)
b64sig = base64_encode(bsig)
sig = b64sig.decode('utf-8')
return sig
def sign(self, msg: Dict) -> Dict:
"""
Return a signature for the given message.
"""
ser = serializeForSig(msg)
bsig = self.naclSigner.signature(ser)
b64sig = base64_encode(bsig)
sig = b64sig.decode('utf-8')
return sig
def sign(self, signing_key) -> None:
"""
Signs an event with the given signing key, setting its signature
:param signing_key: The signing key to use
:return: None
"""
signing_key_byte = base64_decode(signing_key.encode("UTF-8"))
self.signature = base64_encode(
crypto_sign(self.body.encode("UTF-8"),
signing_key_byte)).decode("UTF-8")
def __init__(self,
verify_key,
data: List[Transaction],
parents: Parents,
time=None):
# Immutable body of Event
self.data = data
self.parents = parents
self.time = datetime.datetime.now().isoformat(
) if time is None else time
self.verify_key = verify_key
# End of immutable body
# Compute Event hash and ID
self.__id = base64_encode(crypto_hash_sha512(
self.body.encode("UTF-8"))).decode("UTF-8")
# Event is always created with height 0
# The real height is determined once the event is added to the hashgraph
self.height = 0
# assigned round number of each event
self.round = 0
# {event-hash => bool}
self.votes = dict()
# The signature is empty at the beginning - use sign() to sign the event once it is finished
self.signature = None
# Whether this event is a witness
self.is_witness = False
# Whether this event is famous
self.is_famous = Fame.UNDECIDED
# Ordering info
self.round_received = None
self.consensus_time = None
# A cache for event visibility
self.can_see_cache = dict()
# time when the client learns about the confirmation
self.confirmation_time = None
def __init__(self, identifier=None, seed=None):
"""
Initialize the signer with an identifier and a seed.
:param identifier: some identifier that directly or indirectly references this client
:param seed: the seed used to generate a signing key.
"""
# should be stored securely/privately
self.seed = seed if seed else randombytes(32)
# generates key pair based on seed
self.sk = SigningKey(seed=self.seed)
# helper for signing
self.naclSigner = NaclSigner(self.sk)
# this is the public key used to verify signatures (securely shared
# before-hand with recipient)
self.verkey = self.naclSigner.verhex
self.verstr = base64_encode(self.naclSigner.verraw).decode('utf-8')
self._identifier = identifier or self.verstr
