def connect_blockchain(self, emitter, debug):
try:
eth_node = None
if self.geth:
eth_node = get_provider_process()
# Note: For test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=self.provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=self.provider_uri,
provider_process=eth_node,
poa=self.poa,
light=self.light,
sync=False,
emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=self.provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
return blockchain
except Exception as e:
if debug:
raise
click.secho(str(e), bold=True, fg='red')
raise click.Abort
def get_registry(self, emitter, debug):
try:
eth_node = None
if self.geth:
eth_node = get_provider_process()
# Note: For test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=self.provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=self.provider_uri,
provider_process=eth_node,
poa=self.poa,
light=self.light,
sync=False,
emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=self.provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
except Exception as e:
if debug:
raise
click.secho(str(e), bold=True, fg='red')
raise click.Abort
if self.registry_filepath:
registry = LocalContractRegistry(filepath=self.registry_filepath)
else:
registry = InMemoryContractRegistry.from_latest_publication(
network=self.network)
return registry
def _get_staking_agent(click_config, emitter, geth, poa, provider_uri,
registry_filepath):
try:
ETH_NODE = None
if geth:
ETH_NODE = get_provider_process()
# Note: For test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=provider_uri,
provider_process=ETH_NODE,
poa=poa,
sync=False,
show_sync_progress=False)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
except Exception as e:
if click_config.debug:
raise
click.secho(str(e), bold=True, fg='red')
raise click.Abort
if registry_filepath:
registry = LocalContractRegistry(filepath=registry_filepath)
else:
registry = InMemoryContractRegistry.from_latest_publication()
staking_agent = ContractAgency.get_agent(StakingEscrowAgent,
registry=registry)
return staking_agent
def _get_registry(provider_uri, registry_filepath):
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri)
if registry_filepath:
registry = LocalContractRegistry.from_latest_publication()
else:
registry = InMemoryContractRegistry.from_latest_publication()
return registry
def crawl(
general_config,
teacher_uri,
registry_filepath,
min_stake,
network,
learn_on_launch,
provider_uri,
influx_host,
influx_port,
http_port,
dry_run,
eager,
poa,
):
"""
Gather NuCypher network information.
"""
# Banner
emitter = general_config.emitter
emitter.clear()
emitter.banner(MONITOR_BANNER.format(CRAWLER))
# Setup
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
poa=poa)
registry = _get_registry(registry_filepath, network)
middleware = RestMiddleware()
# Teacher Ursula
sage_node = None
if teacher_uri:
sage_node = Ursula.from_teacher_uri(
teacher_uri=teacher_uri,
min_stake=0, # TODO: Where to get this?
federated_only=False, # always False
network_middleware=middleware,
registry=registry)
crawler = Crawler(domain=network if network else None,
network_middleware=middleware,
known_nodes=[sage_node] if teacher_uri else None,
registry=registry,
start_learning_now=eager,
learn_on_same_thread=learn_on_launch,
influx_host=influx_host,
influx_port=influx_port)
emitter.message(f"Network: {network.capitalize()}", color='blue')
emitter.message(f"InfluxDB: {influx_host}:{influx_port}", color='blue')
emitter.message(f"Provider: {provider_uri}", color='blue')
emitter.message(f"Refresh Rate: {crawler._refresh_rate}s", color='blue')
message = f"Running Nucypher Crawler JSON endpoint at http://localhost:{http_port}/stats"
emitter.message(message, color='green', bold=True)
if not dry_run:
crawler.start(eager=eager)
reactor.run()
def select_client_account(emitter,
provider_uri: str,
prompt: str = None,
default: int = 0,
registry=None,
show_balances: bool = True,
network: str = None) -> str:
"""
Note: Setting show_balances to True, causes an eager contract and blockchain connection.
"""
if not provider_uri:
raise ValueError(
"Provider URI must be provided to select a wallet account.")
# Lazy connect the blockchain interface
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=provider_uri, emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=provider_uri)
# Lazy connect to contracts
token_agent = None
if show_balances:
if not registry:
registry = InMemoryContractRegistry.from_latest_publication(
network)
token_agent = NucypherTokenAgent(registry=registry)
# Real wallet accounts
enumerated_accounts = dict(enumerate(blockchain.client.accounts))
if len(enumerated_accounts) < 1:
emitter.echo("No ETH accounts were found.", color='red', bold=True)
raise click.Abort()
# Display account info
header = f'| # | Account ---------------------------------- | Balance -----' \
f'\n================================================================='
emitter.echo(header)
for index, account in enumerated_accounts.items():
message = f"| {index} | {account} "
if show_balances:
message += f" | {NU.from_nunits(token_agent.get_balance(address=account))}"
emitter.echo(message)
# Prompt the user for selection, and return
prompt = prompt or "Select Account"
account_range = click.IntRange(min=0, max=len(enumerated_accounts) - 1)
choice = click.prompt(prompt, type=account_range, default=default)
chosen_account = enumerated_accounts[choice]
emitter.echo(f"Selected {choice}:{chosen_account}", color='blue')
return chosen_account
def connect_web3_provider(provider_uri: str) -> None:
"""
Convenience function for connecting to an ethereum provider now.
This may be used to optimize the startup time of some applications by
establishing the connection eagarly.
"""
from nucypher.blockchain.eth.interfaces import BlockchainInterfaceFactory
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=provider_uri)
interface = BlockchainInterfaceFactory.get_interface(
provider_uri=provider_uri)
interface.connect()
def __init__(self,
domain: str = None,
registry: BaseContractRegistry = None,
controller: bool = True,
federated_only: bool = False,
node_class: object = Ursula,
eth_provider_uri: str = None,
execution_timeout: int = DEFAULT_EXECUTION_TIMEOUT,
*args,
**kwargs):
self.federated_only = federated_only
if not self.federated_only:
if not eth_provider_uri:
raise ValueError(
'ETH Provider URI is required for decentralized Porter.')
if not BlockchainInterfaceFactory.is_interface_initialized(
eth_provider_uri=eth_provider_uri):
BlockchainInterfaceFactory.initialize_interface(
eth_provider_uri=eth_provider_uri)
self.registry = registry or InMemoryContractRegistry.from_latest_publication(
network=domain)
self.application_agent = ContractAgency.get_agent(
PREApplicationAgent, registry=self.registry)
else:
self.registry = NO_BLOCKCHAIN_CONNECTION.bool_value(False)
node_class.set_federated_mode(federated_only)
super().__init__(save_metadata=True,
domain=domain,
node_class=node_class,
*args,
**kwargs)
self.log = Logger(self.__class__.__name__)
self.execution_timeout = execution_timeout
# Controller Interface
self.interface = self._interface_class(porter=self)
self.controller = NO_CONTROL_PROTOCOL
if controller:
# TODO need to understand this better - only made it analogous to what was done for characters
self.make_cli_controller()
self.log.info(self.BANNER)
def connect_to_blockchain(emitter: StdoutEmitter,
provider_uri: str,
debug: bool = False,
light: bool = False
) -> BlockchainInterface:
try:
# Note: Conditional for test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
light=light,
emitter=emitter)
emitter.echo(message=CONNECTING_TO_BLOCKCHAIN)
blockchain = BlockchainInterfaceFactory.get_interface(provider_uri=provider_uri)
return blockchain
except Exception as e:
if debug:
raise
emitter.echo(str(e), bold=True, color='red')
raise click.Abort
def connect_blockchain(self, emitter, debug):
# TODO: Move to common method shared with the rest of the CLI
try:
# Note: For test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=self.provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=self.provider_uri,
poa=self.poa,
light=self.light,
emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=self.provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
return blockchain
except Exception as e:
if debug:
raise
click.secho(str(e), bold=True, fg='red')
raise click.Abort
def connect_to_blockchain(provider_uri,
emitter,
debug: bool = False,
light: bool = False) -> BlockchainInterface:
try:
# Note: Conditional for test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=provider_uri,
light=light,
sync=False,
emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
return blockchain
except Exception as e:
if debug:
raise
emitter.echo(str(e), bold=True, color='red')
raise click.Abort
def connect(self, networkURL, second_provider, third_provider, ipfs_provider):
BlockchainInterfaceFactory.initialize_interface(provider_uri=self.provider_uri)
self.ipfs_gateway_api = ipfshttpclient.connect(ipfs_provider)
self.ursula = Ursula.from_seed_and_stake_info(
seed_uri=networkURL,
federated_only=True,
minimum_stake=0
)
self.ursula2 = Ursula.from_teacher_uri(
teacher_uri=networkURL,
federated_only=True,
min_stake=0
)
self.ursula3 = Ursula.from_teacher_uri(
teacher_uri=networkURL,
federated_only=True,
min_stake=0
)
return True
def __init__(
self,
# Base
emitter=None,
config_root: Optional[Path] = None,
filepath: Optional[Path] = None,
# Mode
dev_mode: bool = False,
federated_only: bool = False,
# Identity
checksum_address: str = None,
crypto_power: CryptoPower = None,
# Keystore
keystore: Keystore = None,
keystore_path: Optional[Path] = None,
# Learner
learn_on_same_thread: bool = False,
abort_on_learning_error: bool = False,
start_learning_now: bool = True,
# Network
controller_port: int = None,
domain: str = DEFAULT_DOMAIN,
network_middleware: RestMiddleware = None,
lonely: bool = False,
# Node Storage
known_nodes: set = None,
node_storage: NodeStorage = None,
reload_metadata: bool = True,
save_metadata: bool = True,
# Blockchain
poa: bool = None,
light: bool = False,
provider_uri: str = None,
gas_strategy: Union[Callable, str] = DEFAULT_GAS_STRATEGY,
max_gas_price: Optional[int] = None,
signer_uri: str = None,
# Registry
registry: BaseContractRegistry = None,
registry_filepath: Optional[Path] = None,
# Deployed Workers
worker_data: dict = None):
self.log = Logger(self.__class__.__name__)
# This constant is used to signal that a path can be generated if one is not provided.
UNINITIALIZED_CONFIGURATION.bool_value(False)
# Identity
# NOTE: NodeConfigurations can only be used with Self-Characters
self.is_me = True
self.checksum_address = checksum_address
# Keystore
self.crypto_power = crypto_power
if keystore_path and not keystore:
keystore = Keystore(keystore_path=keystore_path)
self.__keystore = self.__keystore = keystore or NO_KEYSTORE_ATTACHED.bool_value(
False)
self.keystore_dir = Path(
keystore.keystore_path
).parent if keystore else UNINITIALIZED_CONFIGURATION
# Contract Registry
if registry and registry_filepath:
if registry.filepath != registry_filepath:
error = f"Inconsistent registry filepaths for '{registry.filepath.absolute()}'" \
f" and '{registry_filepath.absolute()}'."
raise ValueError(error)
else:
self.log.warn(
f"Registry and registry filepath were both passed.")
self.registry = registry or NO_BLOCKCHAIN_CONNECTION.bool_value(False)
self.registry_filepath = registry_filepath or UNINITIALIZED_CONFIGURATION
# Blockchain
self.poa = poa
self.is_light = light
self.provider_uri = provider_uri or NO_BLOCKCHAIN_CONNECTION
self.signer_uri = signer_uri or None
# Learner
self.federated_only = federated_only
self.domain = domain
self.learn_on_same_thread = learn_on_same_thread
self.abort_on_learning_error = abort_on_learning_error
self.start_learning_now = start_learning_now
self.save_metadata = save_metadata
self.reload_metadata = reload_metadata
self.known_nodes = known_nodes or set() # handpicked
self.lonely = lonely
# Configuration
self.__dev_mode = dev_mode
self.config_file_location = filepath or UNINITIALIZED_CONFIGURATION
self.config_root = UNINITIALIZED_CONFIGURATION
# Deployed Workers
self.worker_data = worker_data
#
# Federated vs. Blockchain arguments consistency
#
#
# Federated
#
if self.federated_only:
# Check for incompatible values
blockchain_args = {
'filepath': registry_filepath,
'poa': poa,
'provider_uri': provider_uri,
'gas_strategy': gas_strategy,
'max_gas_price': max_gas_price
}
if any(blockchain_args.values()):
bad_args = ", ".join(f"{arg}={val}"
for arg, val in blockchain_args.items()
if val)
self.log.warn(
f"Arguments {bad_args} are incompatible with federated_only. "
f"Overridden with a sane default.")
# Clear decentralized attributes to ensure consistency with a
# federated configuration.
self.poa = False
self.is_light = False
self.provider_uri = None
self.registry_filepath = None
self.gas_strategy = None
self.max_gas_price = None
#
# Decentralized
#
else:
self.gas_strategy = gas_strategy
self.max_gas_price = max_gas_price # gwei
is_initialized = BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=self.provider_uri)
if not is_initialized and provider_uri:
BlockchainInterfaceFactory.initialize_interface(
provider_uri=self.provider_uri,
poa=self.poa,
light=self.is_light,
emitter=emitter,
gas_strategy=self.gas_strategy,
max_gas_price=self.max_gas_price)
else:
self.log.warn(
f"Using existing blockchain interface connection ({self.provider_uri})."
)
if not self.registry:
# TODO: These two code blocks are untested.
if not self.registry_filepath: # TODO: Registry URI (goerli://speedynet.json) :-)
self.log.info(f"Fetching latest registry from source.")
self.registry = InMemoryContractRegistry.from_latest_publication(
network=self.domain)
else:
self.registry = LocalContractRegistry(
filepath=self.registry_filepath)
self.log.info(f"Using local registry ({self.registry}).")
self.testnet = self.domain != NetworksInventory.MAINNET
self.signer = Signer.from_signer_uri(self.signer_uri,
testnet=self.testnet)
if dev_mode:
self.__temp_dir = UNINITIALIZED_CONFIGURATION
self._setup_node_storage()
self.initialize(password=DEVELOPMENT_CONFIGURATION)
else:
self.__temp_dir = LIVE_CONFIGURATION
self.config_root = config_root or self.DEFAULT_CONFIG_ROOT
self._cache_runtime_filepaths()
self._setup_node_storage(node_storage=node_storage)
# Network
self.controller_port = controller_port or self.DEFAULT_CONTROLLER_PORT
self.network_middleware = network_middleware or self.DEFAULT_NETWORK_MIDDLEWARE(
registry=self.registry)
super().__init__(filepath=self.config_file_location,
config_root=self.config_root)
def select_client_account(emitter,
provider_uri: str = None,
signer_uri: str = None,
wallet: Wallet = None,
prompt: str = None,
default: int = 0,
registry=None,
show_eth_balance: bool = False,
show_nu_balance: bool = False,
show_staking: bool = False,
network: str = None,
poa: bool = None) -> str:
"""
Note: Showing ETH and/or NU balances, causes an eager blockchain connection.
"""
# We use Wallet internally as an account management abstraction
if not wallet:
if not provider_uri and not signer_uri:
raise ValueError(
"At least a provider URI or signer URI is necessary to select an account"
)
# Lazy connect the blockchain interface
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=provider_uri, poa=poa, emitter=emitter)
signer = Signer.from_signer_uri(signer_uri) if signer_uri else None
wallet = Wallet(provider_uri=provider_uri, signer=signer)
elif provider_uri or signer_uri:
raise ValueError(
"If you input a wallet, don't pass a provider URI or signer URI too"
)
# Display accounts info
if show_nu_balance or show_staking: # Lazy registry fetching
if not registry:
registry = InMemoryContractRegistry.from_latest_publication(
network=network)
wallet_accounts = wallet.accounts
enumerated_accounts = dict(enumerate(wallet_accounts))
if len(enumerated_accounts) < 1:
emitter.echo("No ETH accounts were found.", color='red', bold=True)
raise click.Abort()
# Display account info
headers = ['Account']
if show_staking:
headers.append('Staking')
if show_eth_balance:
headers.append('ETH')
if show_nu_balance:
headers.append('NU')
rows = list()
for index, account in enumerated_accounts.items():
row = [account]
if show_staking:
staker = Staker(is_me=True,
checksum_address=account,
registry=registry)
staker.stakes.refresh()
is_staking = 'Yes' if bool(staker.stakes) else 'No'
row.append(is_staking)
if show_eth_balance:
ether_balance = Web3.fromWei(wallet.eth_balance(account), 'ether')
row.append(f'{ether_balance} ETH')
if show_nu_balance:
token_balance = NU.from_nunits(
wallet.token_balance(account, registry))
row.append(token_balance)
rows.append(row)
emitter.echo(tabulate(rows, headers=headers, showindex='always'))
# Prompt the user for selection, and return
prompt = prompt or "Select index of account"
account_range = click.IntRange(min=0, max=len(enumerated_accounts) - 1)
choice = click.prompt(prompt, type=account_range, default=default)
chosen_account = enumerated_accounts[choice]
emitter.echo(f"Selected {choice}: {chosen_account}", color='blue')
return chosen_account
try:
provider_uri = sys.argv[2]
except IndexError:
provider_uri = os.getenv(NUCYPHER_ENVVAR_PROVIDER_URI)
if not provider_uri:
emitter.message("You have to pass a provider URI", color='red')
sys.exit(-1)
try:
network = sys.argv[1]
except IndexError:
network = "ibex"
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
light=False,
sync=False,
emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(
provider_uri=provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
registry = InMemoryContractRegistry.from_latest_publication(network=network)
emitter.echo(f"NOTICE: Connecting to {network} network", color='yellow')
staking_agent = ContractAgency.get_agent(
agent_class=StakingEscrowAgent,
registry=registry) # type: StakingEscrowAgent
def select_client_account(emitter,
provider_uri: str = None,
signer: Signer = None,
signer_uri: str = None,
wallet: Wallet = None,
prompt: str = None,
default: int = 0,
registry=None,
show_eth_balance: bool = False,
show_nu_balance: bool = False,
show_staking: bool = False,
network: str = None,
poa: bool = None) -> str:
"""
Interactively select an ethereum wallet account from a table of nucypher account metadata.
Note: Showing ETH and/or NU balances, causes an eager blockchain connection.
"""
if wallet and (provider_uri or signer_uri or signer):
raise ValueError(
"If a wallet is provided, don't provide a signer, provider URI, or signer URI."
)
# We use Wallet internally as an account management abstraction
if not wallet:
if signer and signer_uri:
raise ValueError('Pass either signer or signer_uri but not both.')
if not provider_uri and not signer_uri:
raise ValueError(
"At least a provider URI or signer URI is necessary to select an account"
)
if provider_uri:
# Lazy connect the blockchain interface
if not BlockchainInterfaceFactory.is_interface_initialized(
provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(
provider_uri=provider_uri, poa=poa, emitter=emitter)
if signer_uri:
testnet = network != NetworksInventory.MAINNET
signer = Signer.from_signer_uri(signer_uri, testnet=testnet)
wallet = Wallet(provider_uri=provider_uri, signer=signer)
# Display accounts info
if show_nu_balance or show_staking: # Lazy registry fetching
if not registry:
if not network:
raise ValueError("Pass network name or registry; Got neither.")
registry = InMemoryContractRegistry.from_latest_publication(
network=network)
wallet_accounts = wallet.accounts
enumerated_accounts = dict(enumerate(wallet_accounts))
if len(enumerated_accounts) < 1:
emitter.echo(NO_ETH_ACCOUNTS, color='red', bold=True)
raise click.Abort()
# Display account info
headers = ['Account']
if show_staking:
headers.append('Staking')
if show_eth_balance:
headers.append('ETH')
if show_nu_balance:
headers.append('NU')
rows = list()
for index, account in enumerated_accounts.items():
row = [account]
if show_staking:
staker = Staker(is_me=True,
checksum_address=account,
registry=registry)
staker.refresh_stakes()
is_staking = 'Yes' if bool(staker.stakes) else 'No'
row.append(is_staking)
if show_eth_balance:
ether_balance = Web3.fromWei(wallet.eth_balance(account), 'ether')
row.append(f'{ether_balance} ETH')
if show_nu_balance:
token_balance = NU.from_nunits(
wallet.token_balance(account, registry))
row.append(token_balance)
rows.append(row)
emitter.echo(tabulate(rows, headers=headers, showindex='always'))
# Prompt the user for selection, and return
prompt = prompt or GENERIC_SELECT_ACCOUNT
account_range = click.IntRange(min=0, max=len(enumerated_accounts) - 1)
choice = click.prompt(prompt, type=account_range, default=default)
chosen_account = enumerated_accounts[choice]
emitter.echo(SELECTED_ACCOUNT.format(choice=choice,
chosen_account=chosen_account),
color='blue')
return chosen_account
def status(click_config, action, provider_uri, sync, geth, poa, periods, staking_address, registry_filepath):
"""
Echo a snapshot of live NuCypher Network metadata.
\b
Actions
-------------------------------------------------
network Overall information of the NuCypher Network
stakers Show relevant information about stakers
locked-tokens Display a graph of evolution of locked tokens
"""
emitter = click_config.emitter
click.clear()
emitter.banner(NU_BANNER)
#
# Connect to Blockchain
#
try:
ETH_NODE = None
if geth:
ETH_NODE = get_provider_process()
# Note: For test compatibility.
if not BlockchainInterfaceFactory.is_interface_initialized(provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
provider_process=ETH_NODE,
poa=poa,
sync=False,
show_sync_progress=False)
blockchain = BlockchainInterfaceFactory.get_interface(provider_uri=provider_uri)
emitter.echo(message="Reading Latest Chaindata...")
blockchain.connect()
except Exception as e:
if click_config.debug:
raise
click.secho(str(e), bold=True, fg='red')
raise click.Abort
if registry_filepath:
registry = LocalContractRegistry(filepath=registry_filepath)
else:
registry = InMemoryContractRegistry.from_latest_publication()
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=registry)
if action == 'network':
paint_contract_status(registry, emitter=emitter)
return # Exit
elif action == 'stakers':
stakers = [staking_address] if staking_address else staking_agent.get_stakers()
paint_stakers(emitter=emitter, stakers=stakers, agent=staking_agent)
return # Exit
elif action == 'locked-tokens':
paint_locked_tokens_status(emitter=emitter, agent=staking_agent, periods=periods)
return # Exit
else:
ctx = click.get_current_context()
raise click.UsageError(message=f"Unknown action '{action}'.", ctx=ctx)
def __init__(self,
# Base
config_root: str = None,
filepath: str = None,
# Mode
dev_mode: bool = False,
federated_only: bool = False,
# Identity
checksum_address: str = None,
crypto_power: CryptoPower = None,
# Keyring
keyring: NucypherKeyring = None,
keyring_root: str = None,
# Learner
learn_on_same_thread: bool = False,
abort_on_learning_error: bool = False,
start_learning_now: bool = True,
# Network
controller_port: int = None,
domains: Set[str] = None, # TODO: Mapping between learning domains and "registry" domains - #1580
interface_signature: Signature = None,
network_middleware: RestMiddleware = None,
# Node Storage
known_nodes: set = None,
node_storage: NodeStorage = None,
reload_metadata: bool = True,
save_metadata: bool = True,
# Blockchain
poa: bool = False,
light: bool = False,
sync: bool = False,
provider_uri: str = None,
provider_process=None,
gas_strategy: Union[Callable, str] = DEFAULT_GAS_STRATEGY,
# Registry
registry: BaseContractRegistry = None,
registry_filepath: str = None,
emitter=None,
):
self.log = Logger(self.__class__.__name__)
UNINITIALIZED_CONFIGURATION.bool_value(False)
# Identity
# NOTE: NodeConfigurations can only be used with Self-Characters
self.is_me = True
self.checksum_address = checksum_address
# Network
self.controller_port = controller_port or self.DEFAULT_CONTROLLER_PORT
self.network_middleware = network_middleware or self.DEFAULT_NETWORK_MIDDLEWARE()
self.interface_signature = interface_signature
# Keyring
self.crypto_power = crypto_power
self.keyring = keyring or NO_KEYRING_ATTACHED
self.keyring_root = keyring_root or UNINITIALIZED_CONFIGURATION
# Contract Registry
if registry and registry_filepath:
if registry.filepath != registry_filepath:
error = f"Inconsistent registry filepaths for '{registry.filepath}' and '{registry_filepath}'."
raise ValueError(error)
else:
self.log.warn(f"Registry and registry filepath were both passed.")
self.registry = registry or NO_BLOCKCHAIN_CONNECTION.bool_value(False)
self.registry_filepath = registry_filepath or UNINITIALIZED_CONFIGURATION
# Blockchain
self.poa = poa
self.is_light = light
self.provider_uri = provider_uri or NO_BLOCKCHAIN_CONNECTION
self.provider_process = provider_process or NO_BLOCKCHAIN_CONNECTION
# Learner
self.federated_only = federated_only
self.domains = domains or {self.DEFAULT_DOMAIN}
self.learn_on_same_thread = learn_on_same_thread
self.abort_on_learning_error = abort_on_learning_error
self.start_learning_now = start_learning_now
self.save_metadata = save_metadata
self.reload_metadata = reload_metadata
self.known_nodes = known_nodes or set() # handpicked
# Configuration
self.__dev_mode = dev_mode
self.config_file_location = filepath or UNINITIALIZED_CONFIGURATION
self.config_root = UNINITIALIZED_CONFIGURATION
#
# Federated vs. Blockchain arguments consistency
#
#
# Federated
#
if self.federated_only:
# Check for incompatible values
blockchain_args = {'filepath': registry_filepath,
'poa': poa,
'provider_process': provider_process,
'provider_uri': provider_uri,
'gas_strategy': gas_strategy}
if any(blockchain_args.values()):
bad_args = (f"{arg}={val}" for arg, val in blockchain_args.items() if val)
self.log.warn(f"Arguments {bad_args} are incompatible with federated_only. "
f"Overridden with a sane default.")
# Clear decentralized attributes to ensure consistency with a
# federated configuration.
self.poa = False
self.is_light = False
self.provider_uri = None
self.provider_process = None
self.registry_filepath = None
self.gas_strategy = None
#
# Decentralized
#
else:
self.gas_strategy = gas_strategy
is_initialized = BlockchainInterfaceFactory.is_interface_initialized(provider_uri=self.provider_uri)
if not is_initialized and provider_uri:
BlockchainInterfaceFactory.initialize_interface(provider_uri=self.provider_uri,
poa=self.poa,
light=self.is_light,
provider_process=self.provider_process,
sync=sync,
emitter=emitter,
gas_strategy=gas_strategy)
else:
self.log.warn(f"Using existing blockchain interface connection ({self.provider_uri}).")
if not self.registry:
# TODO: These two code blocks are untested.
if not self.registry_filepath: # TODO: Registry URI (goerli://speedynet.json) :-)
self.log.info(f"Fetching latest registry from source.")
self.registry = InMemoryContractRegistry.from_latest_publication(network=list(self.domains)[0]) # TODO: #1580
else:
self.registry = LocalContractRegistry(filepath=self.registry_filepath)
self.log.info(f"Using local registry ({self.registry}).")
if dev_mode:
self.__temp_dir = UNINITIALIZED_CONFIGURATION
self.__setup_node_storage()
self.initialize(password=DEVELOPMENT_CONFIGURATION)
else:
self.__temp_dir = LIVE_CONFIGURATION
self.config_root = config_root or self.DEFAULT_CONFIG_ROOT
self._cache_runtime_filepaths()
self.__setup_node_storage(node_storage=node_storage)
super().__init__(filepath=self.config_file_location, config_root=self.config_root)
def select_client_account(emitter,
eth_provider_uri: str = None,
signer: Signer = None,
signer_uri: str = None,
prompt: str = None,
default: int = 0,
registry: BaseContractRegistry = None,
show_eth_balance: bool = False,
show_nu_balance: bool = False,
show_staking: bool = False,
network: str = None,
poa: bool = None) -> str:
"""
Interactively select an ethereum wallet account from a table of nucypher account metadata.
Note: Showing ETH and/or NU balances, causes an eager blockchain connection.
"""
if signer and signer_uri:
raise ValueError('Pass either signer or signer_uri but not both.')
if not any((eth_provider_uri, signer_uri, signer)):
raise ValueError(
"At least a provider URI, signer URI or signer must be provided to select an account"
)
if eth_provider_uri:
# Connect to the blockchain in order to select an account
if not BlockchainInterfaceFactory.is_interface_initialized(
eth_provider_uri=eth_provider_uri):
BlockchainInterfaceFactory.initialize_interface(
eth_provider_uri=eth_provider_uri, poa=poa, emitter=emitter)
if not signer_uri:
signer_uri = eth_provider_uri
blockchain = BlockchainInterfaceFactory.get_interface(
eth_provider_uri=eth_provider_uri)
if signer_uri and not signer:
testnet = network != NetworksInventory.MAINNET
signer = Signer.from_signer_uri(signer_uri, testnet=testnet)
# Display accounts info
if show_nu_balance or show_staking: # Lazy registry fetching
if not registry:
if not network:
raise ValueError("Pass network name or registry; Got neither.")
registry = InMemoryContractRegistry.from_latest_publication(
network=network)
enumerated_accounts = dict(enumerate(signer.accounts))
if len(enumerated_accounts) < 1:
emitter.echo(NO_ETH_ACCOUNTS, color='red', bold=True)
raise click.Abort()
elif len(enumerated_accounts) == 1:
# There are no choices if there is only one available address.
return enumerated_accounts[0]
# Display account info
headers = ['Account']
if show_staking:
headers.append('Staking')
if show_eth_balance:
headers.append('ETH')
if show_nu_balance:
headers.append('NU')
rows = list()
for index, account in enumerated_accounts.items():
row = [account]
if show_staking:
staker = Staker(domain=network,
checksum_address=account,
registry=registry)
staker.refresh_stakes()
is_staking = 'Yes' if bool(staker.stakes) else 'No'
row.append(is_staking)
if show_eth_balance:
ether_balance = Web3.fromWei(
blockchain.client.get_balance(account), 'ether')
row.append(f'{ether_balance} ETH')
if show_nu_balance:
token_agent = ContractAgency.get_agent(NucypherTokenAgent,
registry=registry)
token_balance = NU.from_units(
token_agent.get_balance(account, registry))
row.append(token_balance)
rows.append(row)
emitter.echo(tabulate(rows, headers=headers, showindex='always'))
# Prompt the user for selection, and return
prompt = prompt or GENERIC_SELECT_ACCOUNT
account_range = click.IntRange(min=0, max=len(enumerated_accounts) - 1)
choice = click.prompt(prompt, type=account_range, default=default)
chosen_account = enumerated_accounts[choice]
emitter.echo(SELECTED_ACCOUNT.format(choice=choice,
chosen_account=chosen_account),
color='blue')
return chosen_account
def select_client_account(emitter,
provider_uri: str,
prompt: str = None,
default: int = 0,
registry=None,
show_balances: bool = True,
show_staking: bool = False,
network: str = None,
poa: bool = False
) -> str:
"""
Note: Setting show_balances to True, causes an eager contract and blockchain connection.
"""
# TODO: Break show_balances into show_eth_balance and show_token_balance
if not provider_uri:
raise ValueError("Provider URI must be provided to select a wallet account.")
# Lazy connect the blockchain interface
if not BlockchainInterfaceFactory.is_interface_initialized(provider_uri=provider_uri):
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri, poa=poa, emitter=emitter)
blockchain = BlockchainInterfaceFactory.get_interface(provider_uri=provider_uri)
# Lazy connect to contracts
token_agent = None
if show_balances or show_staking:
if not registry:
registry = InMemoryContractRegistry.from_latest_publication(network=network)
token_agent = NucypherTokenAgent(registry=registry)
# Real wallet accounts
enumerated_accounts = dict(enumerate(blockchain.client.accounts))
if len(enumerated_accounts) < 1:
emitter.echo("No ETH accounts were found.", color='red', bold=True)
raise click.Abort()
# Display account info
headers = ['Account']
if show_staking:
headers.append('Staking')
if show_balances:
headers.extend(('', ''))
rows = list()
for index, account in enumerated_accounts.items():
row = [account]
if show_staking:
staker = Staker(is_me=True, checksum_address=account, registry=registry)
staker.stakes.refresh()
is_staking = 'Yes' if bool(staker.stakes) else 'No'
row.append(is_staking)
if show_balances:
token_balance = NU.from_nunits(token_agent.get_balance(address=account))
ether_balance = Web3.fromWei(blockchain.client.get_balance(account=account), 'ether')
row.extend((token_balance, f'{ether_balance} ETH'))
rows.append(row)
emitter.echo(tabulate(rows, headers=headers, showindex='always'))
# Prompt the user for selection, and return
prompt = prompt or "Select index of account"
account_range = click.IntRange(min=0, max=len(enumerated_accounts)-1)
choice = click.prompt(prompt, type=account_range, default=default)
chosen_account = enumerated_accounts[choice]
emitter.echo(f"Selected {choice}: {chosen_account}", color='blue')
return chosen_account
def dashboard(
general_config,
host,
http_port,
registry_filepath,
certificate_filepath,
tls_key_filepath,
provider_uri,
network,
influx_host,
influx_port,
crawler_host,
crawler_port,
dry_run,
poa,
):
"""
Run UI dashboard of NuCypher network.
"""
# Banner
emitter = general_config.emitter
emitter.clear()
emitter.banner(MONITOR_BANNER.format(DASHBOARD))
# Setup
BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri,
poa=poa)
registry = _get_registry(registry_filepath, network)
#
# WSGI Service
#
if not influx_host:
influx_host = crawler_host
rest_app = Flask("monitor-dashboard")
if general_config.debug:
os.environ['FLASK_ENV'] = 'development'
Dashboard(flask_server=rest_app,
route_url='/',
registry=registry,
network=network,
influx_host=influx_host,
influx_port=influx_port,
crawler_host=crawler_host,
crawler_port=crawler_port)
#
# Server
#
deployer = _get_deployer(rest_app=rest_app,
host=host,
port=http_port,
certificate_filepath=certificate_filepath,
tls_key_filepath=tls_key_filepath)
# Pre-Launch Info
emitter.message(f"Network: {network.capitalize()}", color='blue')
emitter.message(f"Crawler: {crawler_host}:{crawler_port}", color='blue')
emitter.message(f"InfluxDB: {influx_host}:{influx_port}", color='blue')
emitter.message(f"Provider: {provider_uri}", color='blue')
if not dry_run:
emitter.message(
f"Running Monitor Dashboard - https://{host}:{http_port}",
color='green',
bold=True)
try:
deployer.run() # <--- Blocking
finally:
click.secho("Shutting Down")
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
from nucypher.blockchain.eth.interfaces import BlockchainInterfaceFactory
BlockchainInterfaceFactory.initialize_interface(
provider_uri='https://rinkeby.infura.io/v3/3dc8b2e3489c4260904f45a4e74a56dc'
)
from nucypher.characters.lawful import Bob, Ursula, Enrico, Alice
import random
from umbral import config, keys, signing, pre
from umbral.curve import SECP256K1
config.set_default_curve(SECP256K1)
print('aslkjdsals')
# **************************************************************************
rachit_private_key = keys.UmbralPrivateKey.gen_key()
rachit_public_key = rachit_private_key.get_pubkey()
rachit_signing_key = keys.UmbralPrivateKey.gen_key()
rachit_verifying_key = rachit_signing_key.get_pubkey()
rachit_signer = signing.Signer(private_key=rachit_signing_key)
Apoorv_private_key = keys.UmbralPrivateKey.gen_key()
Apoorv_public_key = Apoorv_private_key.get_pubkey()
# **************************************************************************
plaintext = b'Hackathon!'
ciphertext, capsule = pre.encrypt(rachit_public_key, plaintext)
cleartext = pre.decrypt(ciphertext=ciphertext,
capsule=capsule,