def __init__(self,
is_me: bool,
individual_allocation: IndividualAllocationRegistry = None,
*args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.log = Logger("staker")
self.is_me = is_me
self.__worker_address = None
# Blockchain
self.policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=self.registry) # type: PolicyManagerAgent
self.staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=self.registry) # type: StakingEscrowAgent
self.economics = TokenEconomicsFactory.get_economics(registry=self.registry)
# Staking via contract
self.individual_allocation = individual_allocation
if self.individual_allocation:
self.beneficiary_address = individual_allocation.beneficiary_address
self.checksum_address = individual_allocation.contract_address
self.preallocation_escrow_agent = PreallocationEscrowAgent(registry=self.registry,
allocation_registry=self.individual_allocation,
beneficiary=self.beneficiary_address)
else:
self.beneficiary_address = None
self.preallocation_escrow_agent = None
# Check stakes
self.stakes = StakeList(registry=self.registry, checksum_address=self.checksum_address)
class Worker(NucypherTokenActor):
"""
Ursula baseclass for blockchain operations, practically carrying a pickaxe.
"""
class WorkerError(NucypherTokenActor.ActorError):
pass
class DetachedWorker(WorkerError):
"""Raised when the Worker is not bonded to a Staker in the StakingEscrow contract."""
def __init__(self,
is_me: bool,
work_tracker: WorkTracker = None,
worker_address: str = None,
start_working_now: bool = True,
check_active_worker: bool = True,
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.log = Logger("worker")
self.__worker_address = worker_address
self.is_me = is_me
# Agency
self.staking_agent = ContractAgency.get_agent(StakingEscrowAgent,
registry=self.registry)
# Stakes
self.__start_time = WORKER_NOT_RUNNING
self.__uptime_period = WORKER_NOT_RUNNING
# Workers cannot be started without being assigned a stake first.
if is_me:
self.stakes = StakeList(registry=self.registry,
checksum_address=self.checksum_address)
self.stakes.refresh()
if check_active_worker and not len(self.stakes):
raise self.DetachedWorker(
f"{self.__worker_address} is not bonded to {self.checksum_address}."
)
self.work_tracker = work_tracker or WorkTracker(worker=self)
if start_working_now:
self.work_tracker.start(act_now=False)
@property
def last_active_period(self) -> int:
period = self.staking_agent.get_last_active_period(
staker_address=self.checksum_address)
return period
@only_me
@save_receipt
def confirm_activity(self) -> str:
"""For each period that the worker confirms activity, the staker is rewarded"""
receipt = self.staking_agent.confirm_activity(
worker_address=self.__worker_address)
return receipt
def __init__(self,
is_me: bool,
work_tracker: WorkTracker = None,
worker_address: str = None,
start_working_now: bool = True,
check_active_worker: bool = True,
*args, **kwargs):
super().__init__(*args, **kwargs)
self.log = Logger("worker")
self.__worker_address = worker_address
self.is_me = is_me
# Agency
self.staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=self.registry)
# Stakes
self.__start_time = WORKER_NOT_RUNNING
self.__uptime_period = WORKER_NOT_RUNNING
# Workers cannot be started without being assigned a stake first.
if is_me:
self.stakes = StakeList(registry=self.registry, checksum_address=self.checksum_address)
self.stakes.refresh()
if check_active_worker and not len(self.stakes):
raise self.DetachedWorker(f"{self.__worker_address} is not bonded to {self.checksum_address}.")
self.work_tracker = work_tracker or WorkTracker(worker=self)
if start_working_now:
self.work_tracker.start(act_now=False)
def _learn_about_nodes_contract_info(self):
agent = self.staking_agent
block_time = agent.blockchain.client.w3.eth.getBlock('latest').timestamp # precision in seconds
current_period = agent.get_current_period()
nodes_dict = self.known_nodes.abridged_nodes_dict()
self.log.info(f'Processing {len(nodes_dict)} nodes at '
f'{MayaDT(epoch=block_time)} | Period {current_period}')
data = []
for staker_address in nodes_dict:
worker = agent.get_worker_from_staker(staker_address)
stake = agent.owned_tokens(staker_address)
staked_nu_tokens = float(NU.from_nunits(stake).to_tokens())
locked_nu_tokens = float(NU.from_nunits(agent.get_locked_tokens(
staker_address=staker_address)).to_tokens())
economics = TokenEconomicsFactory.get_economics(registry=self.registry)
stakes = StakeList(checksum_address=staker_address, registry=self.registry)
stakes.refresh()
# store dates as floats for comparison purposes
start_date = datetime_at_period(stakes.initial_period,
seconds_per_period=economics.seconds_per_period).datetime().timestamp()
end_date = datetime_at_period(stakes.terminal_period,
seconds_per_period=economics.seconds_per_period).datetime().timestamp()
last_confirmed_period = agent.get_last_active_period(staker_address)
# TODO: do we need to worry about how much information is in memory if number of nodes is
# large i.e. should I check for size of data and write within loop if too big
data.append(self.BLOCKCHAIN_DB_LINE_PROTOCOL.format(
measurement=self.BLOCKCHAIN_DB_MEASUREMENT,
staker_address=staker_address,
worker_address=worker,
start_date=start_date,
end_date=end_date,
stake=staked_nu_tokens,
locked_stake=locked_nu_tokens,
current_period=current_period,
last_confirmed_period=last_confirmed_period,
timestamp=block_time
))
if not self._blockchain_db_client.write_points(data,
database=self.BLOCKCHAIN_DB_NAME,
time_precision='s',
batch_size=10000,
protocol='line'):
# TODO: what do we do here
self.log.warn(f'Unable to write to database {self.BLOCKCHAIN_DB_NAME} at '
f'{MayaDT(epoch=block_time)} | Period {current_period}')
def __init__(self, is_me: bool, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.log = Logger("staker")
self.is_me = is_me
self.__worker_address = None
# Blockchain
self.policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=self.registry)
self.staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=self.registry)
self.economics = TokenEconomicsFactory.get_economics(registry=self.registry)
self.stakes = StakeList(registry=self.registry, checksum_address=self.checksum_address)
def prolong(general_config, transacting_staker_options, config_file, force, lock_periods, index):
"""Prolong an existing stake's duration."""
# Setup
emitter = _setup_emitter(general_config)
STAKEHOLDER = transacting_staker_options.create_character(emitter, config_file)
action_period = STAKEHOLDER.staking_agent.get_current_period()
blockchain = transacting_staker_options.get_blockchain()
economics = STAKEHOLDER.economics
# Handle account selection
client_account, staking_address = handle_client_account_for_staking(
emitter=emitter,
stakeholder=STAKEHOLDER,
staking_address=transacting_staker_options.staker_options.staking_address,
individual_allocation=STAKEHOLDER.individual_allocation,
force=force)
# Handle stake update and selection
if transacting_staker_options.staker_options.staking_address and index is not None: # 0 is valid.
STAKEHOLDER.stakes = StakeList(registry=STAKEHOLDER.registry,
checksum_address=transacting_staker_options.staker_options.staking_address)
STAKEHOLDER.stakes.refresh()
current_stake = STAKEHOLDER.stakes[index]
else:
current_stake = select_stake(stakeholder=STAKEHOLDER, emitter=emitter)
#
# Prolong
#
# Interactive
if not lock_periods:
max_extension = MAX_UINT16 - current_stake.final_locked_period
# +1 because current period excluded
min_extension = economics.minimum_locked_periods - current_stake.periods_remaining + 1
if min_extension < 1:
min_extension = 1
duration_extension_range = click.IntRange(min=min_extension, max=max_extension, clamp=False)
lock_periods = click.prompt(f"Enter number of periods to extend ({min_extension}-{max_extension})",
type=duration_extension_range)
if not force:
click.confirm(f"Publish stake extension of {lock_periods} period(s) to the blockchain?", abort=True)
password = transacting_staker_options.get_password(blockchain, client_account)
# Non-interactive: Consistency check to prevent the above agreement from going stale.
last_second_current_period = STAKEHOLDER.staking_agent.get_current_period()
if action_period != last_second_current_period:
emitter.echo("Current period advanced before transaction was broadcasted. Please try again.", red='red')
raise click.Abort
# Authenticate and Execute
STAKEHOLDER.assimilate(checksum_address=current_stake.staker_address, password=password)
receipt = STAKEHOLDER.prolong_stake(stake_index=current_stake.index, additional_periods=lock_periods)
# Report
emitter.echo('Successfully Prolonged Stake', color='green', verbosity=1)
paint_receipt_summary(emitter=emitter, receipt=receipt, chain_name=blockchain.client.chain_name)
painting.paint_stakes(emitter=emitter, stakeholder=STAKEHOLDER)
return # Exit
def test_collect_rewards_integration(click_runner,
testerchain,
agency_local_registry,
stakeholder_configuration_file_location,
blockchain_alice,
blockchain_bob,
random_policy_label,
beneficiary,
preallocation_escrow_agent,
mock_allocation_registry,
manual_worker,
token_economics,
mock_transacting_power_activation,
stake_value,
policy_value,
policy_rate):
# Disable re-staking
restake_args = ('stake', 'restake',
'--disable',
'--config-file', stakeholder_configuration_file_location,
'--allocation-filepath', MOCK_INDIVIDUAL_ALLOCATION_FILEPATH,
'--force')
result = click_runner.invoke(nucypher_cli,
restake_args,
input=INSECURE_DEVELOPMENT_PASSWORD,
catch_exceptions=False)
assert result.exit_code == 0
half_stake_time = token_economics.minimum_locked_periods // 2 # Test setup
logger = Logger("Test-CLI") # Enter the Teacher's Logger, and
current_period = 0 # State the initial period for incrementing
staker_address = preallocation_escrow_agent.principal_contract.address
worker_address = manual_worker
# The staker is staking.
stakes = StakeList(registry=agency_local_registry, checksum_address=staker_address)
stakes.refresh()
assert stakes
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=agency_local_registry)
assert worker_address == staking_agent.get_worker_from_staker(staker_address=staker_address)
ursula_port = select_test_port()
ursula = Ursula(is_me=True,
checksum_address=staker_address,
worker_address=worker_address,
registry=agency_local_registry,
rest_host='127.0.0.1',
rest_port=ursula_port,
start_working_now=False,
network_middleware=MockRestMiddleware())
MOCK_KNOWN_URSULAS_CACHE[ursula_port] = ursula
assert ursula.worker_address == worker_address
assert ursula.checksum_address == staker_address
mock_transacting_power_activation(account=worker_address, password=INSECURE_DEVELOPMENT_PASSWORD)
# Confirm for half the first stake duration
for _ in range(half_stake_time):
logger.debug(f">>>>>>>>>>> TEST PERIOD {current_period} <<<<<<<<<<<<<<<<")
ursula.confirm_activity()
testerchain.time_travel(periods=1)
current_period += 1
# Alice creates a policy and grants Bob access
blockchain_alice.selection_buffer = 1
M, N = 1, 1
days = 3
now = testerchain.w3.eth.getBlock(block_identifier='latest').timestamp
expiration = maya.MayaDT(now).add(days=days-1)
blockchain_policy = blockchain_alice.grant(bob=blockchain_bob,
label=random_policy_label,
m=M, n=N,
value=policy_value,
expiration=expiration,
handpicked_ursulas={ursula})
# Ensure that the handpicked Ursula was selected for the policy
arrangement = list(blockchain_policy._accepted_arrangements)[0]
assert arrangement.ursula == ursula
# Bob learns about the new staker and joins the policy
blockchain_bob.start_learning_loop()
blockchain_bob.remember_node(node=ursula)
blockchain_bob.join_policy(random_policy_label, bytes(blockchain_alice.stamp))
# Enrico Encrypts (of course)
enrico = Enrico(policy_encrypting_key=blockchain_policy.public_key,
network_middleware=MockRestMiddleware())
verifying_key = blockchain_alice.stamp.as_umbral_pubkey()
for index in range(half_stake_time - 5):
logger.debug(f">>>>>>>>>>> TEST PERIOD {current_period} <<<<<<<<<<<<<<<<")
ursula.confirm_activity()
# Encrypt
random_data = os.urandom(random.randrange(20, 100))
message_kit, signature = enrico.encrypt_message(message=random_data)
# Decrypt
cleartexts = blockchain_bob.retrieve(message_kit,
enrico=enrico,
alice_verifying_key=verifying_key,
label=random_policy_label)
assert random_data == cleartexts[0]
# Ursula Staying online and the clock advancing
testerchain.time_travel(periods=1)
current_period += 1
# Finish the passage of time
for _ in range(5 - 1): # minus 1 because the first period was already confirmed in test_ursula_run
logger.debug(f">>>>>>>>>>> TEST PERIOD {current_period} <<<<<<<<<<<<<<<<")
ursula.confirm_activity()
current_period += 1
testerchain.time_travel(periods=1)
#
# WHERES THE MONEY URSULA?? - Collecting Rewards
#
balance = testerchain.client.get_balance(beneficiary)
# Rewards will be unlocked after the
# final confirmed period has passed (+1).
logger.debug(f">>>>>>>>>>> TEST PERIOD {current_period} <<<<<<<<<<<<<<<<")
testerchain.time_travel(periods=1)
current_period += 1
logger.debug(f">>>>>>>>>>> TEST PERIOD {current_period} <<<<<<<<<<<<<<<<")
# Since we are mocking the blockchain connection, manually consume the transacting power of the Beneficiary.
mock_transacting_power_activation(account=beneficiary, password=INSECURE_DEVELOPMENT_PASSWORD)
# Collect Policy Reward
collection_args = ('stake', 'collect-reward',
'--config-file', stakeholder_configuration_file_location,
'--policy-reward',
'--no-staking-reward',
'--withdraw-address', beneficiary,
'--allocation-filepath', MOCK_INDIVIDUAL_ALLOCATION_FILEPATH,
'--force')
result = click_runner.invoke(nucypher_cli,
collection_args,
input=INSECURE_DEVELOPMENT_PASSWORD,
catch_exceptions=False)
assert result.exit_code == 0
# Policy Reward
collected_policy_reward = testerchain.client.get_balance(beneficiary)
assert collected_policy_reward > balance
#
# Collect Staking Reward
#
token_agent = ContractAgency.get_agent(agent_class=NucypherTokenAgent, registry=agency_local_registry)
balance_before_collecting = token_agent.get_balance(address=staker_address)
collection_args = ('stake', 'collect-reward',
'--config-file', stakeholder_configuration_file_location,
'--no-policy-reward',
'--staking-reward',
'--allocation-filepath', MOCK_INDIVIDUAL_ALLOCATION_FILEPATH,
'--force')
result = click_runner.invoke(nucypher_cli,
collection_args,
input=INSECURE_DEVELOPMENT_PASSWORD,
catch_exceptions=False)
assert result.exit_code == 0
# The beneficiary has withdrawn her staking rewards, which are now in the staking contract
assert token_agent.get_balance(address=staker_address) >= balance_before_collecting
def divide(general_config, transacting_staker_options, config_file, force,
value, lock_periods, index):
"""
Create a new stake from part of an existing one.
"""
# Setup
emitter = _setup_emitter(general_config)
STAKEHOLDER = transacting_staker_options.create_character(
emitter, config_file)
blockchain = transacting_staker_options.get_blockchain()
economics = STAKEHOLDER.economics
action_period = STAKEHOLDER.staking_agent.get_current_period()
client_account, staking_address = handle_client_account_for_staking(
emitter=emitter,
stakeholder=STAKEHOLDER,
staking_address=transacting_staker_options.staker_options.
staking_address,
individual_allocation=STAKEHOLDER.individual_allocation,
force=force)
# Dynamic click types (Economics)
min_locked = economics.minimum_allowed_locked
stake_value_range = click.FloatRange(
min=NU.from_nunits(min_locked).to_tokens(), clamp=False)
if transacting_staker_options.staker_options.staking_address and index is not None: # 0 is valid.
STAKEHOLDER.stakes = StakeList(
registry=STAKEHOLDER.registry,
checksum_address=transacting_staker_options.staker_options.
staking_address)
STAKEHOLDER.stakes.refresh()
current_stake = STAKEHOLDER.stakes[index]
else:
current_stake = select_stake(stakeholder=STAKEHOLDER,
emitter=emitter,
divisible=True,
staker_address=client_account)
#
# Stage Stake
#
# Value
if not value:
min_allowed_locked = NU.from_nunits(
STAKEHOLDER.economics.minimum_allowed_locked)
max_divide_value = max(min_allowed_locked,
current_stake.value - min_allowed_locked)
value = click.prompt(
f"Enter target value ({min_allowed_locked} - {str(max_divide_value)})",
type=stake_value_range)
value = NU(value, 'NU')
# Duration
if not lock_periods:
max_extension = MAX_UINT16 - current_stake.final_locked_period
divide_extension_range = click.IntRange(min=1,
max=max_extension,
clamp=False)
extension = click.prompt(f"Enter number of periods to extend",
type=divide_extension_range)
else:
extension = lock_periods
if not force:
issue_stake_suggestions(lock_periods=extension, value=value)
painting.paint_staged_stake_division(emitter=emitter,
stakeholder=STAKEHOLDER,
original_stake=current_stake,
target_value=value,
extension=extension)
click.confirm("Publish stake division to the blockchain?", abort=True)
# Authenticate
password = transacting_staker_options.get_password(blockchain,
client_account)
# Consistency check to prevent the above agreement from going stale.
last_second_current_period = STAKEHOLDER.staking_agent.get_current_period()
if action_period != last_second_current_period:
emitter.echo(
"Current period advanced before stake division was broadcasted. Please try again.",
red='red')
raise click.Abort
# Execute
STAKEHOLDER.assimilate(checksum_address=current_stake.staker_address,
password=password)
modified_stake, new_stake = STAKEHOLDER.divide_stake(
stake_index=current_stake.index,
target_value=value,
additional_periods=extension)
emitter.echo('Successfully divided stake', color='green', verbosity=1)
paint_receipt_summary(emitter=emitter,
receipt=new_stake.receipt,
chain_name=blockchain.client.chain_name)
# Show the resulting stake list
painting.paint_stakes(emitter=emitter, stakeholder=STAKEHOLDER)
def prolong(general_config, transacting_staker_options, config_file, force,
lock_periods, index):
"""Prolong an existing stake's duration."""
# Setup
emitter = setup_emitter(general_config)
STAKEHOLDER = transacting_staker_options.create_character(
emitter, config_file)
action_period = STAKEHOLDER.staking_agent.get_current_period()
blockchain = transacting_staker_options.get_blockchain()
economics = STAKEHOLDER.economics
# Handle account selection
client_account, staking_address = select_client_account_for_staking(
emitter=emitter,
stakeholder=STAKEHOLDER,
staking_address=transacting_staker_options.staker_options.
staking_address,
individual_allocation=STAKEHOLDER.individual_allocation,
force=force)
# Handle stake update and selection
if transacting_staker_options.staker_options.staking_address and index is not None: # 0 is valid.
STAKEHOLDER.stakes = StakeList(
registry=STAKEHOLDER.registry,
checksum_address=transacting_staker_options.staker_options.
staking_address)
STAKEHOLDER.stakes.refresh()
current_stake = STAKEHOLDER.stakes[index]
else:
current_stake = select_stake(stakeholder=STAKEHOLDER, emitter=emitter)
#
# Prolong
#
# Interactive
if not lock_periods:
max_extension = MAX_UINT16 - current_stake.final_locked_period
# +1 because current period excluded
min_extension = economics.minimum_locked_periods - current_stake.periods_remaining + 1
if min_extension < 1:
min_extension = 1
duration_extension_range = click.IntRange(min=min_extension,
max=max_extension,
clamp=False)
lock_periods = click.prompt(PROMPT_PROLONG_VALUE.format(
minimum=min_extension, maximum=max_extension),
type=duration_extension_range)
if not force:
click.confirm(CONFIRM_PROLONG.format(lock_periods=lock_periods),
abort=True)
password = transacting_staker_options.get_password(blockchain,
client_account)
# Non-interactive: Consistency check to prevent the above agreement from going stale.
last_second_current_period = STAKEHOLDER.staking_agent.get_current_period()
if action_period != last_second_current_period:
emitter.echo(PERIOD_ADVANCED_WARNING, red='red')
raise click.Abort
# Authenticate and Execute
STAKEHOLDER.assimilate(checksum_address=current_stake.staker_address,
password=password)
receipt = STAKEHOLDER.prolong_stake(stake_index=current_stake.index,
additional_periods=lock_periods)
# Report
emitter.echo(SUCCESSFUL_STAKE_PROLONG, color='green', verbosity=1)
paint_receipt_summary(emitter=emitter,
receipt=receipt,
chain_name=blockchain.client.chain_name)
paint_stakes(emitter=emitter, stakeholder=STAKEHOLDER)
def divide(general_config, transacting_staker_options, config_file, force,
value, lock_periods, index):
"""Create a new stake from part of an existing one."""
# Setup
emitter = setup_emitter(general_config)
STAKEHOLDER = transacting_staker_options.create_character(
emitter, config_file)
blockchain = transacting_staker_options.get_blockchain()
economics = STAKEHOLDER.economics
action_period = STAKEHOLDER.staking_agent.get_current_period()
client_account, staking_address = select_client_account_for_staking(
emitter=emitter,
stakeholder=STAKEHOLDER,
staking_address=transacting_staker_options.staker_options.
staking_address,
individual_allocation=STAKEHOLDER.individual_allocation,
force=force)
# Dynamic click types (Economics)
min_locked = economics.minimum_allowed_locked
stake_value_range = click.FloatRange(
min=NU.from_nunits(min_locked).to_tokens(), clamp=False)
if transacting_staker_options.staker_options.staking_address and index is not None: # 0 is valid.
STAKEHOLDER.stakes = StakeList(
registry=STAKEHOLDER.registry,
checksum_address=transacting_staker_options.staker_options.
staking_address)
STAKEHOLDER.stakes.refresh()
current_stake = STAKEHOLDER.stakes[index]
else:
current_stake = select_stake(stakeholder=STAKEHOLDER,
emitter=emitter,
divisible=True,
staker_address=client_account)
#
# Stage Stake
#
# Value
if not value:
min_allowed_locked = NU.from_nunits(
STAKEHOLDER.economics.minimum_allowed_locked)
max_divide_value = max(min_allowed_locked,
current_stake.value - min_allowed_locked)
prompt = PROMPT_STAKE_DIVIDE_VALUE.format(
minimm=min_allowed_locked, maximum=str(max_divide_value))
value = click.prompt(prompt, type=stake_value_range)
value = NU(value, 'NU')
# Duration
if not lock_periods:
max_extension = MAX_UINT16 - current_stake.final_locked_period
divide_extension_range = click.IntRange(min=1,
max=max_extension,
clamp=False)
extension = click.prompt(PROMPT_STAKE_EXTEND_VALUE,
type=divide_extension_range)
else:
extension = lock_periods
if not force:
confirm_large_stake(lock_periods=extension, value=value)
paint_staged_stake_division(emitter=emitter,
stakeholder=STAKEHOLDER,
original_stake=current_stake,
target_value=value,
extension=extension)
click.confirm(CONFIRM_BROADCAST_STAKE_DIVIDE, abort=True)
# Authenticate
password = transacting_staker_options.get_password(blockchain,
client_account)
# Consistency check to prevent the above agreement from going stale.
last_second_current_period = STAKEHOLDER.staking_agent.get_current_period()
if action_period != last_second_current_period:
emitter.echo(PERIOD_ADVANCED_WARNING, red='red')
raise click.Abort
# Execute
STAKEHOLDER.assimilate(checksum_address=current_stake.staker_address,
password=password)
modified_stake, new_stake = STAKEHOLDER.divide_stake(
stake_index=current_stake.index,
target_value=value,
additional_periods=extension)
emitter.echo(SUCCESSFUL_STAKE_DIVIDE, color='green', verbosity=1)
paint_receipt_summary(emitter=emitter,
receipt=new_stake.receipt,
chain_name=blockchain.client.chain_name)
# Show the resulting stake list
paint_stakes(emitter=emitter, stakeholder=STAKEHOLDER)
class Staker(NucypherTokenActor):
"""
Baseclass for staking-related operations on the blockchain.
"""
class StakerError(NucypherTokenActor.ActorError):
pass
class InsufficientTokens(StakerError):
pass
def __init__(self,
is_me: bool,
individual_allocation: IndividualAllocationRegistry = None,
*args,
**kwargs) -> None:
super().__init__(*args, **kwargs)
self.log = Logger("staker")
self.is_me = is_me
self.__worker_address = None
# Blockchain
self.policy_agent = ContractAgency.get_agent(
PolicyManagerAgent,
registry=self.registry) # type: PolicyManagerAgent
self.staking_agent = ContractAgency.get_agent(
StakingEscrowAgent,
registry=self.registry) # type: StakingEscrowAgent
self.economics = TokenEconomicsFactory.get_economics(
registry=self.registry)
# Staking via contract
self.individual_allocation = individual_allocation
if self.individual_allocation:
self.beneficiary_address = individual_allocation.beneficiary_address
self.checksum_address = individual_allocation.contract_address
self.preallocation_escrow_agent = PreallocationEscrowAgent(
registry=self.registry,
allocation_registry=self.individual_allocation,
beneficiary=self.beneficiary_address)
else:
self.beneficiary_address = None
self.preallocation_escrow_agent = None
# Check stakes
self.stakes = StakeList(registry=self.registry,
checksum_address=self.checksum_address)
@property
def is_contract(self) -> bool:
return self.preallocation_escrow_agent is not None
def to_dict(self) -> dict:
stake_info = [stake.to_stake_info() for stake in self.stakes]
worker_address = self.worker_address or BlockchainInterface.NULL_ADDRESS
staker_funds = {
'ETH': int(self.eth_balance),
'NU': int(self.token_balance)
}
staker_payload = {
'staker': self.checksum_address,
'balances': staker_funds,
'worker': worker_address,
'stakes': stake_info
}
return staker_payload
# TODO: This is unused. Why? Should we remove it?
@classmethod
def from_dict(cls, staker_payload: dict) -> 'Staker':
staker = Staker(is_me=True,
checksum_address=staker_payload['checksum_address'])
return staker
@property
def is_staking(self) -> bool:
"""Checks if this Staker currently has active stakes / locked tokens."""
self.stakes.refresh()
return bool(self.stakes)
def locked_tokens(self, periods: int = 0) -> NU:
"""Returns the amount of tokens this staker has locked for a given duration in periods."""
self.stakes.refresh()
raw_value = self.staking_agent.get_locked_tokens(
staker_address=self.checksum_address, periods=periods)
value = NU.from_nunits(raw_value)
return value
@property
def current_stake(self) -> NU:
"""
The total number of staked tokens, i.e., tokens locked in the current period.
"""
return self.locked_tokens(periods=0)
@only_me
def divide_stake(self,
stake_index: int,
target_value: NU,
additional_periods: int = None,
expiration: maya.MayaDT = None) -> tuple:
# Calculate duration in periods
if additional_periods and expiration:
raise ValueError(
"Pass the number of lock periods or an expiration MayaDT; not both."
)
# Update staking cache element
stakes = self.stakes
# Select stake to divide from local cache
try:
current_stake = stakes[stake_index]
except KeyError:
if len(stakes):
message = f"Cannot divide stake - No stake exists with index {stake_index}."
else:
message = "Cannot divide stake - There are no active stakes."
raise Stake.StakingError(message)
# Calculate stake duration in periods
if expiration:
additional_periods = datetime_to_period(
datetime=expiration,
seconds_per_period=self.economics.seconds_per_period
) - current_stake.final_locked_period
if additional_periods <= 0:
raise Stake.StakingError(
f"New expiration {expiration} must be at least 1 period from the "
f"current stake's end period ({current_stake.final_locked_period})."
)
# Do it already!
modified_stake, new_stake = current_stake.divide(
target_value=target_value, additional_periods=additional_periods)
# Update staking cache element
self.stakes.refresh()
return modified_stake, new_stake
@only_me
def initialize_stake(self,
amount: NU,
lock_periods: int = None,
expiration: maya.MayaDT = None,
entire_balance: bool = False) -> Stake:
"""Create a new stake."""
# Duration
if lock_periods and expiration:
raise ValueError(
"Pass the number of lock periods or an expiration MayaDT; not both."
)
if expiration:
lock_periods = calculate_period_duration(
future_time=expiration,
seconds_per_period=self.economics.seconds_per_period)
# Value
if entire_balance and amount:
raise ValueError("Specify an amount or entire balance, not both")
if entire_balance:
amount = self.token_balance
if not self.token_balance >= amount:
raise self.InsufficientTokens(
f"Insufficient token balance ({self.token_agent}) "
f"for new stake initialization of {amount}")
# Ensure the new stake will not exceed the staking limit
if (self.current_stake +
amount) > self.economics.maximum_allowed_locked:
raise Stake.StakingError(
f"Cannot initialize stake - "
f"Maximum stake value exceeded for {self.checksum_address} "
f"with a target value of {amount}.")
# Write to blockchain
new_stake = Stake.initialize_stake(staker=self,
amount=amount,
lock_periods=lock_periods)
# Update staking cache element
self.stakes.refresh()
return new_stake
def deposit(self, amount: int, lock_periods: int) -> Tuple[str, str]:
"""Public facing method for token locking."""
if self.is_contract:
approve_receipt = self.token_agent.approve_transfer(
amount=amount,
target_address=self.staking_agent.contract_address,
sender_address=self.beneficiary_address)
deposit_receipt = self.preallocation_escrow_agent.deposit_as_staker(
amount=amount, lock_periods=lock_periods)
else:
approve_receipt = self.token_agent.approve_transfer(
amount=amount,
target_address=self.staking_agent.contract_address,
sender_address=self.checksum_address)
deposit_receipt = self.staking_agent.deposit_tokens(
amount=amount,
lock_periods=lock_periods,
sender_address=self.checksum_address)
return approve_receipt, deposit_receipt
@property
def is_restaking(self) -> bool:
restaking = self.staking_agent.is_restaking(
staker_address=self.checksum_address)
return restaking
@only_me
@save_receipt
def _set_restaking_value(self, value: bool) -> dict:
if self.is_contract:
receipt = self.preallocation_escrow_agent.set_restaking(
value=value)
else:
receipt = self.staking_agent.set_restaking(
staker_address=self.checksum_address, value=value)
return receipt
def enable_restaking(self) -> dict:
receipt = self._set_restaking_value(value=True)
return receipt
@only_me
@save_receipt
def enable_restaking_lock(self, release_period: int):
current_period = self.staking_agent.get_current_period()
if release_period < current_period:
raise ValueError(
f"Release period for re-staking lock must be in the future. "
f"Current period is {current_period}, got '{release_period}'.")
if self.is_contract:
receipt = self.preallocation_escrow_agent.lock_restaking(
release_period=release_period)
else:
receipt = self.staking_agent.lock_restaking(
staker_address=self.checksum_address,
release_period=release_period)
return receipt
@property
def restaking_lock_enabled(self) -> bool:
status = self.staking_agent.is_restaking_locked(
staker_address=self.checksum_address)
return status
def disable_restaking(self) -> dict:
receipt = self._set_restaking_value(value=False)
return receipt
#
# Bonding with Worker
#
@only_me
@save_receipt
@validate_checksum_address
def set_worker(self, worker_address: str) -> str:
if self.is_contract:
receipt = self.preallocation_escrow_agent.set_worker(
worker_address=worker_address)
else:
receipt = self.staking_agent.set_worker(
staker_address=self.checksum_address,
worker_address=worker_address)
self.__worker_address = worker_address
return receipt
@property
def worker_address(self) -> str:
if self.__worker_address:
# TODO: This is broken for StakeHolder with different stakers - See #1358
return self.__worker_address
else:
worker_address = self.staking_agent.get_worker_from_staker(
staker_address=self.checksum_address)
self.__worker_address = worker_address
if self.__worker_address == BlockchainInterface.NULL_ADDRESS:
return NO_WORKER_ASSIGNED.bool_value(False)
return self.__worker_address
@only_me
@save_receipt
def detach_worker(self) -> str:
if self.is_contract:
receipt = self.preallocation_escrow_agent.release_worker()
else:
receipt = self.staking_agent.release_worker(
staker_address=self.checksum_address)
self.__worker_address = BlockchainInterface.NULL_ADDRESS
return receipt
#
# Reward and Collection
#
@only_me
@save_receipt
def mint(self) -> Tuple[str, str]:
"""Computes and transfers tokens to the staker's account"""
if self.is_contract:
receipt = self.preallocation_escrow_agent.mint()
else:
receipt = self.staking_agent.mint(
staker_address=self.checksum_address)
return receipt
def calculate_staking_reward(self) -> int:
staking_reward = self.staking_agent.calculate_staking_reward(
staker_address=self.checksum_address)
return staking_reward
def calculate_policy_reward(self) -> int:
policy_reward = self.policy_agent.get_reward_amount(
staker_address=self.checksum_address)
return policy_reward
@only_me
@save_receipt
@validate_checksum_address
def collect_policy_reward(self, collector_address=None) -> dict:
"""Collect rewarded ETH."""
withdraw_address = collector_address or self.checksum_address
if self.is_contract:
receipt = self.preallocation_escrow_agent.collect_policy_reward(
collector_address=withdraw_address)
else:
receipt = self.policy_agent.collect_policy_reward(
collector_address=withdraw_address,
staker_address=self.checksum_address)
return receipt
@only_me
@save_receipt
def collect_staking_reward(self) -> str:
"""Withdraw tokens rewarded for staking."""
if self.is_contract:
reward_amount = self.calculate_staking_reward()
self.log.debug(
f"Withdrawing staking reward ({NU.from_nunits(reward_amount)}) to {self.checksum_address}"
)
receipt = self.preallocation_escrow_agent.withdraw_as_staker(
value=reward_amount)
else:
receipt = self.staking_agent.collect_staking_reward(
staker_address=self.checksum_address)
return receipt
@only_me
@save_receipt
def withdraw(self, amount: NU) -> str:
"""Withdraw tokens (assuming they're unlocked)"""
if self.is_contract:
receipt = self.preallocation_escrow_agent.withdraw_as_staker(
value=int(amount))
else:
receipt = self.staking_agent.withdraw(
staker_address=self.checksum_address, amount=int(amount))
return receipt
class Staker(NucypherTokenActor):
"""
Baseclass for staking-related operations on the blockchain.
"""
class StakerError(NucypherTokenActor.ActorError):
pass
class InsufficientTokens(StakerError):
pass
def __init__(self, is_me: bool, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.log = Logger("staker")
self.is_me = is_me
self.__worker_address = None
# Blockchain
self.policy_agent = ContractAgency.get_agent(PolicyManagerAgent,
registry=self.registry)
self.staking_agent = ContractAgency.get_agent(StakingEscrowAgent,
registry=self.registry)
self.economics = TokenEconomicsFactory.get_economics(
registry=self.registry)
self.stakes = StakeList(registry=self.registry,
checksum_address=self.checksum_address)
def to_dict(self) -> dict:
stake_info = [stake.to_stake_info() for stake in self.stakes]
worker_address = self.worker_address or BlockchainInterface.NULL_ADDRESS
staker_funds = {
'ETH': int(self.eth_balance),
'NU': int(self.token_balance)
}
staker_payload = {
'staker': self.checksum_address,
'balances': staker_funds,
'worker': worker_address,
'stakes': stake_info
}
return staker_payload
@classmethod
def from_dict(cls, staker_payload: dict) -> 'Staker':
staker = Staker(is_me=True,
checksum_address=staker_payload['checksum_address'])
return staker
@property
def is_staking(self) -> bool:
"""Checks if this Staker currently has active stakes / locked tokens."""
self.stakes.refresh()
return bool(self.stakes)
def locked_tokens(self, periods: int = 0) -> NU:
"""Returns the amount of tokens this staker has locked for a given duration in periods."""
self.stakes.refresh()
raw_value = self.staking_agent.get_locked_tokens(
staker_address=self.checksum_address, periods=periods)
value = NU.from_nunits(raw_value)
return value
@property
def current_stake(self) -> NU:
"""
The total number of staked tokens, either locked or unlocked in the current period.
"""
stake = self.staking_agent.owned_tokens(
staker_address=self.checksum_address)
nu_stake = NU.from_nunits(stake)
return nu_stake
@only_me
def divide_stake(self,
stake_index: int,
target_value: NU,
additional_periods: int = None,
expiration: maya.MayaDT = None) -> tuple:
# Calculate duration in periods
if additional_periods and expiration:
raise ValueError(
"Pass the number of lock periods or an expiration MayaDT; not both."
)
# Update staking cache element
stakes = self.stakes
# Select stake to divide from local cache
try:
current_stake = stakes[stake_index]
except KeyError:
if len(stakes):
message = f"Cannot divide stake - No stake exists with index {stake_index}."
else:
message = "Cannot divide stake - There are no active stakes."
raise Stake.StakingError(message)
# Calculate stake duration in periods
if expiration:
additional_periods = datetime_to_period(
datetime=expiration) - current_stake.final_locked_period
if additional_periods <= 0:
raise Stake.StakingError(
f"New expiration {expiration} must be at least 1 period from the "
f"current stake's end period ({current_stake.final_locked_period})."
)
# Do it already!
modified_stake, new_stake = current_stake.divide(
target_value=target_value, additional_periods=additional_periods)
# Update staking cache element
self.stakes.refresh()
return modified_stake, new_stake
@only_me
def initialize_stake(self,
amount: NU,
lock_periods: int = None,
expiration: maya.MayaDT = None,
entire_balance: bool = False) -> Stake:
"""Create a new stake."""
# Duration
if lock_periods and expiration:
raise ValueError(
"Pass the number of lock periods or an expiration MayaDT; not both."
)
if expiration:
lock_periods = calculate_period_duration(future_time=expiration)
# Value
if entire_balance and amount:
raise ValueError("Specify an amount or entire balance, not both")
if entire_balance:
amount = self.token_balance
if not self.token_balance >= amount:
raise self.InsufficientTokens(
f"Insufficient token balance ({self.token_agent}) "
f"for new stake initialization of {amount}")
# Ensure the new stake will not exceed the staking limit
if (self.current_stake +
amount) > self.economics.maximum_allowed_locked:
raise Stake.StakingError(
f"Cannot initialize stake - "
f"Maximum stake value exceeded for {self.checksum_address} "
f"with a target value of {amount}.")
# Write to blockchain
new_stake = Stake.initialize_stake(staker=self,
amount=amount,
lock_periods=lock_periods)
# Update staking cache element
self.stakes.refresh()
return new_stake
#
# Reward and Collection
#
@only_me
@save_receipt
def set_worker(self, worker_address: str) -> str:
# TODO: Set a Worker for this staker, not just in StakingEscrow
receipt = self.staking_agent.set_worker(
staker_address=self.checksum_address,
worker_address=worker_address)
self.__worker_address = worker_address
return receipt
@property
def worker_address(self) -> str:
if self.__worker_address:
return self.__worker_address
else:
worker_address = self.staking_agent.get_worker_from_staker(
staker_address=self.checksum_address)
self.__worker_address = worker_address
if self.__worker_address == BlockchainInterface.NULL_ADDRESS:
return NO_WORKER_ASSIGNED.bool_value(False)
return self.__worker_address
@only_me
@save_receipt
def mint(self) -> Tuple[str, str]:
"""Computes and transfers tokens to the staker's account"""
receipt = self.staking_agent.mint(staker_address=self.checksum_address)
return receipt
def calculate_reward(self) -> int:
staking_reward = self.staking_agent.calculate_staking_reward(
staker_address=self.checksum_address)
return staking_reward
@only_me
@save_receipt
def collect_policy_reward(self, collector_address=None) -> dict:
"""Collect rewarded ETH."""
withdraw_address = collector_address or self.checksum_address
receipt = self.policy_agent.collect_policy_reward(
collector_address=withdraw_address,
staker_address=self.checksum_address)
return receipt
@only_me
@save_receipt
def collect_staking_reward(self) -> str:
"""Withdraw tokens rewarded for staking."""
receipt = self.staking_agent.collect_staking_reward(
staker_address=self.checksum_address)
return receipt
@only_me
@save_receipt
def withdraw(self, amount: NU) -> str:
"""Withdraw tokens (assuming they're unlocked)"""
receipt = self.staking_agent.withdraw(
staker_address=self.checksum_address, amount=int(amount))
return receipt
def divide(
click_config,
# Stake Options
poa,
light,
registry_filepath,
config_file,
provider_uri,
staking_address,
hw_wallet,
beneficiary_address,
allocation_filepath,
# Other
force,
value,
lock_periods,
index):
"""
Create a new stake from part of an existing one.
"""
### Setup ###
emitter = _setup_emitter(click_config)
STAKEHOLDER, blockchain = _create_stakeholder(
config_file,
provider_uri,
poa,
light,
registry_filepath,
staking_address,
beneficiary_address=beneficiary_address,
allocation_filepath=allocation_filepath)
#############
client_account, staking_address = handle_client_account_for_staking(
emitter=emitter,
stakeholder=STAKEHOLDER,
staking_address=staking_address,
individual_allocation=STAKEHOLDER.individual_allocation,
force=force)
economics = STAKEHOLDER.economics
# Dynamic click types (Economics)
min_locked = economics.minimum_allowed_locked
stake_value_range = click.FloatRange(
min=NU.from_nunits(min_locked).to_tokens(), clamp=False)
stake_extension_range = click.IntRange(
min=1, max=economics.maximum_allowed_locked, clamp=False)
if staking_address and index is not None: # 0 is valid.
STAKEHOLDER.stakes = StakeList(registry=STAKEHOLDER.registry,
checksum_address=staking_address)
STAKEHOLDER.stakes.refresh()
current_stake = STAKEHOLDER.stakes[index]
else:
current_stake = select_stake(stakeholder=STAKEHOLDER, emitter=emitter)
#
# Stage Stake
#
# Value
if not value:
value = click.prompt(
f"Enter target value (must be less than or equal to {str(current_stake.value)})",
type=stake_value_range)
value = NU(value, 'NU')
# Duration
if not lock_periods:
extension = click.prompt("Enter number of periods to extend",
type=stake_extension_range)
else:
extension = lock_periods
if not force:
painting.paint_staged_stake_division(emitter=emitter,
stakeholder=STAKEHOLDER,
original_stake=current_stake,
target_value=value,
extension=extension)
click.confirm("Is this correct?", abort=True)
# Execute
password = None
if not hw_wallet and not blockchain.client.is_local:
password = get_client_password(
checksum_address=current_stake.staker_address)
STAKEHOLDER.assimilate(checksum_address=current_stake.staker_address,
password=password)
modified_stake, new_stake = STAKEHOLDER.divide_stake(
stake_index=current_stake.index,
target_value=value,
additional_periods=extension)
emitter.echo('Successfully divided stake', color='green', verbosity=1)
paint_receipt_summary(emitter=emitter,
receipt=new_stake.receipt,
chain_name=blockchain.client.chain_name)
# Show the resulting stake list
painting.paint_stakes(emitter=emitter, stakes=STAKEHOLDER.stakes)
def _learn_about_nodes(self, threaded: bool = True):
if threaded:
if self.__collecting_nodes:
self.log.debug(
"Skipping Round - Nodes collection thread is already running"
)
return
return reactor.callInThread(self._learn_about_nodes,
threaded=False)
self.__collecting_nodes = True
agent = self.staking_agent
known_nodes = list(self.known_nodes)
block_time = agent.blockchain.client.w3.eth.getBlock(
'latest').timestamp # precision in seconds
current_period = agent.get_current_period()
log = f'Processing {len(known_nodes)} nodes at {MayaDT(epoch=block_time)} | Period {current_period}'
self.log.info(log)
data = list()
for node in known_nodes:
staker_address = node.checksum_address
worker = agent.get_worker_from_staker(staker_address)
stake = agent.owned_tokens(staker_address)
staked_nu_tokens = float(NU.from_nunits(stake).to_tokens())
locked_nu_tokens = float(
NU.from_nunits(
agent.get_locked_tokens(
staker_address=staker_address)).to_tokens())
economics = EconomicsFactory.get_economics(registry=self.registry)
stakes = StakeList(checksum_address=staker_address,
registry=self.registry)
stakes.refresh()
if stakes.initial_period is NOT_STAKING:
continue # TODO: Skip this measurement for now
start_date = datetime_at_period(
stakes.initial_period,
seconds_per_period=economics.seconds_per_period)
start_date = start_date.datetime().timestamp()
end_date = datetime_at_period(
stakes.terminal_period,
seconds_per_period=economics.seconds_per_period)
end_date = end_date.datetime().timestamp()
last_confirmed_period = agent.get_last_active_period(
staker_address)
num_work_orders = 0 # len(node.work_orders()) # TODO: Only works for is_me with datastore attached
# TODO: do we need to worry about how much information is in memory if number of nodes is
# large i.e. should I check for size of data and write within loop if too big
data.append(
self.NODE_LINE_PROTOCOL.format(
measurement=self.NODE_MEASUREMENT,
staker_address=staker_address,
worker_address=worker,
start_date=start_date,
end_date=end_date,
stake=staked_nu_tokens,
locked_stake=locked_nu_tokens,
current_period=current_period,
last_confirmed_period=last_confirmed_period,
timestamp=block_time,
work_orders=num_work_orders))
success = self._influx_client.write_points(
data,
database=self.INFLUX_DB_NAME,
time_precision='s',
batch_size=10000,
protocol='line')
self.__collecting_nodes = False
if not success:
# TODO: What do we do here - Event hook for alerting?
self.log.warn(
f'Unable to write node information to database {self.INFLUX_DB_NAME} at '
f'{MayaDT(epoch=block_time)} | Period {current_period}')
