def __init__(self,
is_me: bool = True,
network_middleware: RestMiddleware = None,
known_certificates_dir: str = None,
crypto_power: CryptoPower = None,
crypto_power_ups: List[CryptoPowerUp] = None,
federated_only: bool = False,
checksum_address: bytes = None,
*args,
**kwargs) -> None:
"""
Base class for Nucypher protocol actors.
PowerUps
========
:param crypto_power: A CryptoPower object; if provided, this will be the character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new one will be made to consume all CryptoPowerUps.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
super().__init__(*args, **kwargs)
self.federated_only = federated_only # type: bool
self.known_certificates_dir = known_certificates_dir
#
# Power-ups and Powers
#
if crypto_power and crypto_power_ups:
raise ValueError(
"Pass crypto_power or crypto_power_ups (or neither), but not both."
)
crypto_power_ups = crypto_power_ups or [] # type: list
if crypto_power:
self._crypto_power = crypto_power # type: CryptoPower
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(
power_ups=self._default_crypto_powerups)
#
# Identity and Network
#
if is_me is True:
self.treasure_maps = {} # type: dict
self.network_middleware = network_middleware or RestMiddleware()
try:
signing_power = self._crypto_power.power_ups(
SigningPower) # type: SigningPower
self._stamp = signing_power.get_signature_stamp(
) # type: SignatureStamp
except NoSigningPower:
self._stamp = constants.NO_SIGNING_POWER
else: # Feel like a stranger
if network_middleware is not None:
raise TypeError(
"Can't attach network middleware to a Character who isn't me. What are you even trying to do?"
)
self._stamp = StrangerStamp(self.public_keys(SigningPower))
# Decentralized
if not federated_only:
if not checksum_address:
raise ValueError(
"No checksum_address provided while running in a non-federated mode."
)
else:
self._checksum_address = checksum_address # type: str
# Federated
elif federated_only:
self._checksum_address = constants.NO_BLOCKCHAIN_CONNECTION
if checksum_address:
# We'll take a checksum address, as long as it matches their singing key
self._set_checksum_address() # type: str
if not checksum_address == self.checksum_public_address:
error = "Federated-only Characters derive their address from their Signing key; got {} instead."
raise self.SuspiciousActivity(
error.format(checksum_address))
def __init__(self,
domains: Set = None,
known_node_class: object = None,
is_me: bool = True,
federated_only: bool = False,
checksum_address: str = NO_BLOCKCHAIN_CONNECTION.bool_value(
False),
network_middleware: RestMiddleware = None,
keyring: NucypherKeyring = None,
keyring_root: str = None,
crypto_power: CryptoPower = None,
crypto_power_ups: List[CryptoPowerUp] = None,
provider_uri: str = None,
signer: Signer = None,
registry: BaseContractRegistry = None,
*args,
**kwargs) -> None:
"""
Base class for Nucypher protocol actors.
PowerUps
========
:param crypto_power: A CryptoPower object; if provided, this will be the character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new one will be made to consume all CryptoPowerUps.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
#
# Operating Mode
if hasattr(self, '_interface_class'
): # TODO: have argument about meaning of 'lawful'
# and whether maybe only Lawful characters have an interface
self.interface = self._interface_class(character=self)
if is_me:
if not known_node_class:
# Once in a while, in tests or demos, we init a plain Character who doesn't already know about its node class.
from nucypher.characters.lawful import Ursula
known_node_class = Ursula
# If we're federated only, we assume that all other nodes in our domain are as well.
known_node_class.set_federated_mode(federated_only)
else:
# What an awful hack. The last convulsions of #466.
# TODO: Anything else.
with suppress(AttributeError):
federated_only = known_node_class._federated_only_instances
if federated_only:
if registry or provider_uri:
raise ValueError(
f"Cannot init federated-only character with {registry or provider_uri}."
)
self.federated_only = bool(federated_only) # type: bool
#
# Powers
#
# Derive powers from keyring
if keyring_root and keyring:
if keyring_root != keyring.keyring_root:
raise ValueError("Inconsistent keyring root directory path")
if keyring:
keyring_root, checksum_address = keyring.keyring_root, keyring.checksum_address
crypto_power_ups = list()
for power_up in self._default_crypto_powerups:
power = keyring.derive_crypto_power(power_class=power_up)
crypto_power_ups.append(power)
self.keyring_root = keyring_root
self.keyring = keyring
if crypto_power and crypto_power_ups:
raise ValueError(
"Pass crypto_power or crypto_power_ups (or neither), but not both."
)
crypto_power_ups = crypto_power_ups or list() # type: list
if crypto_power:
self._crypto_power = crypto_power # type: CryptoPower
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(
power_ups=self._default_crypto_powerups)
self._checksum_address = checksum_address
# Fleet and Blockchain Connection (Everyone)
if not domains:
domains = {CharacterConfiguration.DEFAULT_DOMAIN}
#
# Self-Character
#
if is_me:
self.treasure_maps = {} # type: dict
#
# Signing Power
#
self.signer = signer
try:
signing_power = self._crypto_power.power_ups(
SigningPower) # type: SigningPower
self._stamp = signing_power.get_signature_stamp(
) # type: SignatureStamp
except NoSigningPower:
self._stamp = NO_SIGNING_POWER
#
# Blockchain
#
self.provider_uri = provider_uri
if not self.federated_only:
self.registry = registry or InMemoryContractRegistry.from_latest_publication(
network=list(domains)[0]) #TODO: #1580
else:
self.registry = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
# REST
self.network_middleware = network_middleware or RestMiddleware(
registry=self.registry)
#
# Learner
#
Learner.__init__(self,
domains=domains,
network_middleware=self.network_middleware,
node_class=known_node_class,
*args,
**kwargs)
#
# Stranger-Character
#
else: # Feel like a stranger
if network_middleware is not None:
raise TypeError(
"Network middleware cannot be attached to a Stranger-Character."
)
if registry is not None:
raise TypeError(
"Registry cannot be attached to stranger-Characters.")
verifying_key = self.public_keys(SigningPower)
self._stamp = StrangerStamp(verifying_key)
self.keyring_root = STRANGER
self.network_middleware = STRANGER
#
# Decentralized
#
if not federated_only:
self._checksum_address = checksum_address # TODO: Check that this matches TransactingPower
#
# Federated
#
elif federated_only:
try:
self._set_checksum_address() # type: str
except NoSigningPower:
self._checksum_address = NO_BLOCKCHAIN_CONNECTION
if checksum_address:
# We'll take a checksum address, as long as it matches their singing key
if not checksum_address == self.checksum_address:
error = "Federated-only Characters derive their address from their Signing key; got {} instead."
raise self.SuspiciousActivity(
error.format(checksum_address))
#
# Nicknames
#
if self._checksum_address is NO_BLOCKCHAIN_CONNECTION and not self.federated_only and not is_me:
# Sometimes we don't care about the nickname. For example, if Alice is granting to Bob, she usually
# doesn't know or care about his wallet. Maybe this needs to change?
# Currently, if this is a stranger and there's no blockchain connection, we assign NO_NICKNAME:
self.nickname = self.nickname_metadata = NO_NICKNAME
else:
try:
self.nickname, self.nickname_metadata = nickname_from_seed(
self.checksum_address)
except SigningPower.not_found_error: # TODO: Handle NO_BLOCKCHAIN_CONNECTION more coherently - #1547
if self.federated_only:
self.nickname = self.nickname_metadata = NO_NICKNAME
else:
raise
#
# Fleet state
#
if is_me is True:
self.known_nodes.record_fleet_state()
#
# Character Control
#
self.controller = NO_CONTROL_PROTOCOL
def __init__(self,
domains: Set = (GLOBAL_DOMAIN, ),
is_me: bool = True,
federated_only: bool = False,
blockchain: Blockchain = None,
checksum_public_address: bytes = NO_BLOCKCHAIN_CONNECTION.
bool_value(False),
network_middleware: RestMiddleware = None,
keyring_dir: str = None,
crypto_power: CryptoPower = None,
crypto_power_ups: List[CryptoPowerUp] = None,
*args,
**kwargs) -> None:
"""
Base class for Nucypher protocol actors.
PowerUps
========
:param crypto_power: A CryptoPower object; if provided, this will be the character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new one will be made to consume all CryptoPowerUps.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
self.federated_only = federated_only # type: bool
#
# Powers
#
if crypto_power and crypto_power_ups:
raise ValueError(
"Pass crypto_power or crypto_power_ups (or neither), but not both."
)
crypto_power_ups = crypto_power_ups or list() # type: list
if crypto_power:
self._crypto_power = crypto_power # type: CryptoPower
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(
power_ups=self._default_crypto_powerups)
self._checksum_address = checksum_public_address
#
# Self-Character
#
if is_me is True:
if not self.federated_only:
self.blockchain = blockchain or Blockchain.connect()
self.keyring_dir = keyring_dir # type: str
self.treasure_maps = {} # type: dict
self.network_middleware = network_middleware or RestMiddleware()
#
# Signing Power
#
try:
signing_power = self._crypto_power.power_ups(
SigningPower) # type: SigningPower
self._stamp = signing_power.get_signature_stamp(
) # type: SignatureStamp
except NoSigningPower:
self._stamp = NO_SIGNING_POWER
#
# Learner
#
Learner.__init__(self,
domains=domains,
network_middleware=network_middleware,
*args,
**kwargs)
#
# Stranger-Character
#
else: # Feel like a stranger
if network_middleware is not None:
raise TypeError(
"Network middleware cannot be attached to a Stanger-Character."
)
self._stamp = StrangerStamp(self.public_keys(SigningPower))
self.keyring_dir = STRANGER
self.network_middleware = STRANGER
#
# Decentralized
#
if not federated_only:
if not checksum_public_address:
raise ValueError(
"No checksum_public_address provided while running in a non-federated mode."
)
else:
self._checksum_address = checksum_public_address # TODO: Check that this matches BlockchainPower
#
# Federated
#
elif federated_only:
try:
self._set_checksum_address() # type: str
except NoSigningPower:
self._checksum_address = NO_BLOCKCHAIN_CONNECTION
if checksum_public_address:
# We'll take a checksum address, as long as it matches their singing key
if not checksum_public_address == self.checksum_public_address:
error = "Federated-only Characters derive their address from their Signing key; got {} instead."
raise self.SuspiciousActivity(
error.format(checksum_public_address))
#
# Nicknames
#
try:
self.nickname, self.nickname_metadata = nickname_from_seed(
self.checksum_public_address)
except SigningPower.not_found_error:
if self.federated_only:
self.nickname = self.nickname_metadata = NO_NICKNAME
else:
raise
#
# Fleet state
#
if is_me is True:
self.known_nodes.record_fleet_state()
#
# Character Control
#
self.controller = NO_CONTROL_PROTOCOL
def get_signature_stamp(self):
if self._privkey == constants.PUBLIC_ONLY:
return StrangerStamp(verifying_key=self.pubkey)
else:
signer = Signer(self._privkey)
return SignatureStamp(verifying_key=self.pubkey, signer=signer)
def __init__(self,
domain: str = None,
known_node_class: object = None,
is_me: bool = True,
federated_only: bool = False,
checksum_address: str = None,
network_middleware: RestMiddleware = None,
keyring: NucypherKeyring = None,
crypto_power: CryptoPower = None,
crypto_power_ups: List[CryptoPowerUp] = None,
provider_uri: str = None,
signer: Signer = None,
registry: BaseContractRegistry = None,
include_self_in_the_state: bool = False,
*args,
**kwargs) -> None:
"""
A participant in the cryptological drama (a screenplay, if you like) of NuCypher.
Characters can represent users, nodes, wallets, offline devices, or other objects of varying levels of abstraction.
The Named Characters use this class as a Base, and achieve their individuality from additional methods and PowerUps.
PowerUps
========
:param crypto_power: A CryptoPower object; if provided, this will be the character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new one will be made to consume all CryptoPowerUps.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
#
# Prologue of the federation
#
# FIXME: excuse me... can I speak to the manager?
if is_me:
# If this is a federated-is_me-character, assume everyone else is too.
self._set_known_node_class(known_node_class, federated_only)
else:
# What an awful hack. The last convulsions of #466. # TODO: Anything else.
with suppress(AttributeError):
federated_only = known_node_class._federated_only_instances
if federated_only:
if registry or provider_uri:
raise ValueError(
f"Cannot init federated-only character with {registry or provider_uri}."
)
self.federated_only: bool = federated_only
##########################################
#
# Keys & Powers
#
if keyring:
keyring_root, keyring_checksum_address = keyring.keyring_root, keyring.checksum_address
if checksum_address and (keyring_checksum_address !=
checksum_address):
raise ValueError(
f"Provided checksum address {checksum_address} "
f"does not match character's keyring checksum address {keyring_checksum_address}"
)
checksum_address = keyring_checksum_address
crypto_power_ups = list()
for power_up in self._default_crypto_powerups:
power = keyring.derive_crypto_power(power_class=power_up)
crypto_power_ups.append(power)
self.keyring = keyring
if crypto_power and crypto_power_ups:
raise ValueError(
"Pass crypto_power or crypto_power_ups (or neither), but not both."
)
crypto_power_ups = crypto_power_ups or list() # type: list
if crypto_power:
self._crypto_power = crypto_power # type: CryptoPower
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(
power_ups=self._default_crypto_powerups)
#
# Self
#
if is_me:
# Signing Power
self.signer = signer
try:
signing_power = self._crypto_power.power_ups(
SigningPower) # type: SigningPower
self._stamp = signing_power.get_signature_stamp(
) # type: SignatureStamp
except NoSigningPower:
self._stamp = NO_SIGNING_POWER
# Blockchainy
if not self.federated_only:
self.provider_uri = provider_uri
# TODO: Implicit / lazy blockchain connection here?
# if not BlockchainInterfaceFactory.is_interface_initialized(provider_uri=provider_uri):
# BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri)
self.registry = registry or InMemoryContractRegistry.from_latest_publication(
network=domain) # See #1580
else:
self.registry = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
# REST
self.network_middleware = network_middleware or RestMiddleware(
registry=self.registry)
# Learner
Learner.__init__(
self,
domain=domain,
network_middleware=self.network_middleware,
node_class=known_node_class,
include_self_in_the_state=include_self_in_the_state,
*args,
**kwargs)
if self.federated_only:
try:
derived_federated_address = self.derive_federated_address()
except NoSigningPower:
derived_federated_address = NO_SIGNING_POWER.bool_value(
False)
if checksum_address and (checksum_address !=
derived_federated_address):
raise ValueError(
f"Provided checksum address {checksum_address} "
f"does not match federated character's verifying key {derived_federated_address}"
)
checksum_address = derived_federated_address
self.checksum_address = checksum_address
#
# Stranger
#
else:
if network_middleware is not None:
raise TypeError(
"Network middleware cannot be attached to a Stranger-Character."
)
if registry is not None:
raise TypeError(
"Registry cannot be attached to stranger-Characters.")
verifying_key = self.public_keys(SigningPower)
self._stamp = StrangerStamp(verifying_key)
self.keyring_root = STRANGER
self.network_middleware = STRANGER
self.checksum_address = checksum_address
self.__setup_nickname(is_me=is_me)
# Character Control
# TODO: have argument about meaning of 'lawful' and whether maybe only Lawful characters have an interface
if hasattr(self, '_interface_class'):
# Controller Interface
self.interface = self._interface_class(character=self)
self.controller = NO_CONTROL_PROTOCOL
def __init__(self,
domains: Set = None,
is_me: bool = True,
federated_only: bool = False,
checksum_address: str = NO_BLOCKCHAIN_CONNECTION.bool_value(False),
network_middleware: RestMiddleware = None,
keyring: NucypherKeyring = None,
keyring_root: str = None,
crypto_power: CryptoPower = None,
crypto_power_ups: List[CryptoPowerUp] = None,
provider_uri: str = None,
registry: BaseContractRegistry = None,
*args, **kwargs
) -> None:
"""
Base class for Nucypher protocol actors.
PowerUps
========
:param crypto_power: A CryptoPower object; if provided, this will be the character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new one will be made to consume all CryptoPowerUps.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
#
# Operating Mode
#
if federated_only:
if registry or provider_uri:
raise ValueError(f"Cannot init federated-only character with {registry or provider_uri}.")
self.federated_only = federated_only # type: bool
#
# Powers
#
# Derive powers from keyring
if keyring_root and keyring:
if keyring_root != keyring.keyring_root:
raise ValueError("Inconsistent keyring root directory path")
if keyring:
keyring_root, checksum_address = keyring.keyring_root, keyring.checksum_address
crypto_power_ups = list()
for power_up in self._default_crypto_powerups:
power = keyring.derive_crypto_power(power_class=power_up)
crypto_power_ups.append(power)
self.keyring_root = keyring_root
self.keyring = keyring
if crypto_power and crypto_power_ups:
raise ValueError("Pass crypto_power or crypto_power_ups (or neither), but not both.")
crypto_power_ups = crypto_power_ups or list() # type: list
if crypto_power:
self._crypto_power = crypto_power # type: CryptoPower
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(power_ups=self._default_crypto_powerups)
self._checksum_address = checksum_address
# Fleet and Blockchain Connection (Everyone)
if not domains:
domains = (CharacterConfiguration.DEFAULT_DOMAIN,)
#
# Self-Character
#
if is_me:
if not bool(federated_only) ^ bool(registry):
raise ValueError(f"Pass either federated only or registry for is_me Characters. \
Got '{federated_only}' and '{registry}'.")
self.treasure_maps = {} # type: dict
self.network_middleware = network_middleware or RestMiddleware()
#
# Signing Power
#
try:
signing_power = self._crypto_power.power_ups(SigningPower) # type: SigningPower
self._stamp = signing_power.get_signature_stamp() # type: SignatureStamp
except NoSigningPower:
self._stamp = NO_SIGNING_POWER
#
# Blockchain
#
self.provider_uri = provider_uri
if not self.federated_only:
self.registry = registry or InMemoryContractRegistry.from_latest_publication()
else:
self.registry = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
#
# Learner
#
Learner.__init__(self,
domains=domains,
network_middleware=self.network_middleware,
*args, **kwargs)
#
# Stranger-Character
#
else: # Feel like a stranger
if network_middleware is not None:
raise TypeError("Network middleware cannot be attached to a Stranger-Character.")
if registry is not None:
raise TypeError("Registry cannot be attached to stranger-Characters.")
self._stamp = StrangerStamp(self.public_keys(SigningPower))
self.network_middleware = STRANGER
#
# Decentralized
#
if not federated_only:
self._checksum_address = checksum_address # TODO: Check that this matches TransactingPower
#
# Federated
#
elif federated_only:
try:
self._set_checksum_address() # type: str
except NoSigningPower:
self._checksum_address = NO_BLOCKCHAIN_CONNECTION
if checksum_address:
# We'll take a checksum address, as long as it matches their singing key
if not checksum_address == self.checksum_address:
error = "Federated-only Characters derive their address from their Signing key; got {} instead."
raise self.SuspiciousActivity(error.format(checksum_address))
#
# Nicknames
#
try:
self.nickname, self.nickname_metadata = nickname_from_seed(self.checksum_address)
except SigningPower.not_found_error:
if self.federated_only:
self.nickname = self.nickname_metadata = NO_NICKNAME
else:
raise
#
# Fleet state
#
if is_me is True:
self.known_nodes.record_fleet_state()
#
# Character Control
#
self.controller = NO_CONTROL_PROTOCOL
def __init__(self,
domain: str = None,
known_node_class: object = None,
is_me: bool = True,
federated_only: bool = False,
checksum_address: str = NO_BLOCKCHAIN_CONNECTION.bool_value(False),
network_middleware: RestMiddleware = None,
keyring: NucypherKeyring = None,
keyring_root: str = None,
crypto_power: CryptoPower = None,
crypto_power_ups: List[CryptoPowerUp] = None,
provider_uri: str = None,
signer: Signer = None,
registry: BaseContractRegistry = None,
*args, **kwargs
) -> None:
"""
A participant in the cryptological drama (a screenplay, if you like) of NuCypher.
Characters can represent users, nodes, wallets, offline devices, or other objects of varying levels of abstraction.
The Named Characters use this class as a Base, and achieve their individuality from additional methods and PowerUps.
PowerUps
========
:param crypto_power: A CryptoPower object; if provided, this will be the character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new one will be made to consume all CryptoPowerUps.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
if provider_uri:
if not BlockchainInterfaceFactory.is_interface_initialized(provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri)
#
# Operating Mode
#
if hasattr(self, '_interface_class'): # TODO: have argument about meaning of 'lawful'
# and whether maybe only Lawful characters have an interface
self.interface = self._interface_class(character=self)
if is_me:
self._set_known_node_class(known_node_class, federated_only)
else:
# What an awful hack. The last convulsions of #466.
# TODO: Anything else.
with suppress(AttributeError):
federated_only = known_node_class._federated_only_instances
if federated_only:
if registry or provider_uri:
raise ValueError(f"Cannot init federated-only character with {registry or provider_uri}.")
self.federated_only: bool = federated_only
#
# Powers
#
# Derive powers from keyring
if keyring_root and keyring:
if keyring_root != keyring.keyring_root:
raise ValueError("Inconsistent keyring root directory path")
if keyring:
keyring_root, checksum_address = keyring.keyring_root, keyring.checksum_address
crypto_power_ups = list()
for power_up in self._default_crypto_powerups:
power = keyring.derive_crypto_power(power_class=power_up)
crypto_power_ups.append(power)
self.keyring_root = keyring_root
self.keyring = keyring
if crypto_power and crypto_power_ups:
raise ValueError("Pass crypto_power or crypto_power_ups (or neither), but not both.")
crypto_power_ups = crypto_power_ups or list() # type: list
if crypto_power:
self._crypto_power = crypto_power # type: CryptoPower
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(power_ups=self._default_crypto_powerups)
#
# Self-Character
#
if is_me:
#
# Signing Power
#
self.signer = signer
try:
signing_power = self._crypto_power.power_ups(SigningPower) # type: SigningPower
self._stamp = signing_power.get_signature_stamp() # type: SignatureStamp
except NoSigningPower:
self._stamp = NO_SIGNING_POWER
#
# Blockchain
#
self.provider_uri = provider_uri
if not self.federated_only:
self.registry = registry or InMemoryContractRegistry.from_latest_publication(network=domain) # See #1580
else:
self.registry = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
# REST
self.network_middleware = network_middleware or RestMiddleware(registry=self.registry)
#
# Learner
#
Learner.__init__(self,
domain=domain,
network_middleware=self.network_middleware,
node_class=known_node_class,
*args, **kwargs)
#
# Stranger-Character
#
else: # Feel like a stranger
if network_middleware is not None:
raise TypeError("Network middleware cannot be attached to a Stranger-Character.")
if registry is not None:
raise TypeError("Registry cannot be attached to stranger-Characters.")
verifying_key = self.public_keys(SigningPower)
self._stamp = StrangerStamp(verifying_key)
self.keyring_root = STRANGER
self.network_middleware = STRANGER
# TODO: Figure out when to do this.
try:
_transacting_power = self._crypto_power.power_ups(TransactingPower)
except NoTransactingPower:
self._checksum_address = checksum_address
else:
self._set_checksum_address(checksum_address)
#
# Nicknames
#
if self._checksum_address is NO_BLOCKCHAIN_CONNECTION and not self.federated_only and not is_me:
# Sometimes we don't care about the nickname. For example, if Alice is granting to Bob, she usually
# doesn't know or care about his wallet. Maybe this needs to change?
# Currently, if this is a stranger and there's no blockchain connection, we assign NO_NICKNAME:
self.nickname = NO_NICKNAME
else:
try:
# TODO: It's possible that this is NO_BLOCKCHAIN_CONNECTION.
if self.checksum_address is NO_BLOCKCHAIN_CONNECTION:
self.nickname = NO_NICKNAME
else:
# This can call _set_checksum_address.
self.nickname = Nickname.from_seed(self.checksum_address)
except SigningPower.not_found_error: # TODO: Handle NO_BLOCKCHAIN_CONNECTION more coherently - #1547
if self.federated_only:
self.nickname = NO_NICKNAME
else:
raise
#
# Fleet state
#
if is_me is True:
self.known_nodes.record_fleet_state()
#
# Character Control
#
self.controller = NO_CONTROL_PROTOCOL
def __init__(self,
attach_server=True,
crypto_power: CryptoPower = None,
crypto_power_ups=None,
is_me=True,
network_middleware=None,
config: "NucypherConfig" = None,
*args,
**kwargs):
"""
:param attach_server: Whether to attach a Server when this Character is
born.
:param crypto_power: A CryptoPower object; if provided, this will be the
character's CryptoPower.
:param crypto_power_ups: If crypto_power is not provided, a new
CryptoPower will be made and will consume all of the CryptoPowerUps
in this list.
If neither crypto_power nor crypto_power_ups are provided, we give this
Character all CryptoPowerUps listed in their _default_crypto_powerups
attribute.
:param is_me: Set this to True when you want this Character to represent
the owner of the configuration under which the program is being run.
A Character who is_me can do things that other Characters can't,
like run servers, sign messages, and decrypt messages which are
encrypted for them. Typically this will be True for exactly one
Character, but there are scenarios in which its imaginable to be
represented by zero Characters or by more than one Character.
"""
self.config = config if config is not None else NucypherConfig.get(
) # default
self.known_nodes = {}
self.log = getLogger("characters")
if crypto_power and crypto_power_ups:
raise ValueError(
"Pass crypto_power or crypto_power_ups (or neither), but not both."
)
if not crypto_power_ups:
crypto_power_ups = []
if crypto_power:
self._crypto_power = crypto_power
elif crypto_power_ups:
self._crypto_power = CryptoPower(power_ups=crypto_power_ups)
else:
self._crypto_power = CryptoPower(self._default_crypto_powerups)
if is_me:
self.network_middleware = network_middleware or NetworkyStuff()
try:
signing_power = self._crypto_power.power_ups(SigningPower)
self._stamp = signing_power.get_signature_stamp()
except NoSigningPower:
self._stamp = constants.NO_SIGNING_POWER
if attach_server:
self.attach_server()
else:
if network_middleware is not None:
raise TypeError(
"Can't attach network middleware to a Character who isn't me. What are you even trying to do?"
)
self._stamp = StrangerStamp(self.public_key(SigningPower))