def test_simulate_single_operation():
default_fee = TZTX_FEE
network_config = {"BLOCK_TIME_IN_SEC": 60, "MINIMAL_BLOCK_DELAY": 30}
batch_payer = BatchPayer(
node_url="node_addr",
pymnt_addr="tz1234567890123456789012345678901234",
clnt_mngr=ClientManager(
node_endpoint=PUBLIC_NODE_URL[CURRENT_TESTNET],
signer_endpoint=PRIVATE_SIGNER_URL,
),
delegator_pays_ra_fee=True,
delegator_pays_xfer_fee=True,
network_config=network_config,
plugins_manager=MagicMock(),
dry_run=False,
)
batch_payer.base_counter = 0
reward_log = RewardLog(
address="KT1P3Y1mkGASzuJqLh7uGuQEvHatztGuQRgC",
type="D",
staking_balance=0,
current_balance=0,
)
reward_log.amount = 15577803
reward_log.skipped = False
simulation_status, simulation_results = batch_payer.simulate_single_operation(
reward_log, reward_log.amount, "hash", "unittest")
assert PaymentStatus.DONE == simulation_status
consumed_gas, tx_fee, storage = simulation_results
assert 150 == consumed_gas
assert 410 == default_fee + consumed_gas * MUTEZ_PER_GAS_UNIT
assert int == type(storage) # type of storage should be int
assert 24 == storage
def test_attempt_single_batch_tz(sign, request_url, request_url_post):
network_config = {"BLOCK_TIME_IN_SEC": 60, "MINIMAL_BLOCK_DELAY": 30}
batch_payer = BatchPayer(
node_url="node_addr",
pymnt_addr=TEST_TZ_ADDRESS,
clnt_mngr=ClientManager(
node_endpoint=PUBLIC_NODE_URL[CURRENT_TESTNET],
signer_endpoint=PRIVATE_SIGNER_URL,
),
delegator_pays_ra_fee=True,
delegator_pays_xfer_fee=True,
network_config=network_config,
plugins_manager=MagicMock(),
dry_run=False,
)
batch_payer.base_counter = 0
reward_log = RewardLog(
address=TEST_TZ_ADDRESS,
type="D",
staking_balance=80,
current_balance=100,
)
reward_log.adjusted_amount = 15577803
reward_log.skipped = False
opt_counter = OpCounter()
status, operation_hash, _ = batch_payer.attempt_single_batch([reward_log],
opt_counter,
dry_run=True)
assert status == PaymentStatus.DONE
assert operation_hash is None
assert reward_log.delegator_transaction_fee == TZTX_FEE
assert opt_counter.counter == 3209358
def test_validate_no_founders_map(self):
data_no_founders = """
version: 1.0
baking_address: tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
payment_address: tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
owners_map: {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5}
supporters_set: None
service_fee: 4.5
reactivate_zeroed: False
delegator_pays_ra_fee: True
rewards_type:
plugins:
enabled:
"""
wallet_client_manager = ClientManager('', '')
block_api = RpcBlockApiImpl(network, self.mainnet_public_node_url)
cnf_prsr = BakingYamlConfParser(data_no_founders,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=self.mainnet_public_node_url,
block_api=block_api)
cnf_prsr.parse()
cnf_prsr.validate()
self.assertEqual(cnf_prsr.get_conf_obj_attr('baking_address'),
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address'),
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('__payment_address_pkh'),
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(
cnf_prsr.get_conf_obj_attr('__payment_address_manager'),
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('__payment_address_type'),
AddrType.TZ)
self.assertEqual(cnf_prsr.get_conf_obj_attr('founders_map'), dict())
self.assertEqual(cnf_prsr.get_conf_obj_attr('specials_map'), dict())
self.assertEqual(cnf_prsr.get_conf_obj_attr('supporters_set'), set())
self.assertEqual(cnf_prsr.get_conf_obj_attr('min_delegation_amt'), 0)
self.assertEqual(cnf_prsr.get_conf_obj_attr('reactivate_zeroed'),
False)
self.assertEqual(cnf_prsr.get_conf_obj_attr('delegator_pays_ra_fee'),
True)
self.assertEqual(cnf_prsr.get_conf_obj_attr('rewards_type'),
RewardsType.ACTUAL)
plugins = cnf_prsr.get_conf_obj_attr('plugins')
self.assertIsInstance(plugins, dict)
self.assertIsNone(plugins['enabled'], None)
def test_disk_full_payment_producer(args, caplog):
# Issue: https://github.com/tezos-reward-distributor-organization/tezos-reward-distributor/issues/504
client_manager = ClientManager(args.node_endpoint, args.signer_endpoint)
network_config_map = init_network_config(args.network, client_manager)
factory = ProviderFactory(provider="prpc")
parser = BakingYamlConfParser(
baking_config, None, None, None, None, block_api=factory, api_base_url=None
)
parser.parse()
parser.process()
cfg_dict = parser.get_conf_obj()
baking_cfg = BakingConf(cfg_dict)
baking_dirs = BakingDirs(args, baking_cfg.get_baking_address())
srvc_fee_calc = ServiceFeeCalculator(
baking_cfg.get_full_supporters_set(),
baking_cfg.get_specials_map(),
baking_cfg.get_service_fee(),
)
payments_queue = queue.Queue(50)
plc = ProcessLifeCycle(None)
pp = PaymentProducer(
name="producer",
network_config=network_config_map[args.network],
payments_dir=baking_dirs.payments_root,
calculations_dir=baking_dirs.calculations_root,
run_mode=RunMode(args.run_mode),
service_fee_calc=srvc_fee_calc,
release_override=args.release_override,
payment_offset=args.payment_offset,
baking_cfg=baking_cfg,
life_cycle=plc,
payments_queue=payments_queue,
dry_run=args.dry_run,
client_manager=client_manager,
node_url=args.node_endpoint,
reward_data_provider=args.reward_data_provider,
node_url_public=args.node_addr_public,
api_base_url=args.api_base_url,
retry_injected=args.retry_injected,
initial_payment_cycle=args.initial_cycle,
)
assert disk_is_full()
try:
pp.daemon = True
pp.start()
finally:
pp.stop()
assert (
"Disk is becoming full. Only 0.50 Gb left from 10.00 Gb. Please clean up disk to continue saving logs and reports."
in caplog.text
)
def create_consumer(nw, payment_queue):
return PaymentConsumer("name",
TEST_REPORT_TEMP_DIR,
"tz1234567890123456789012345678901234",
payment_queue,
"node_addr",
ClientManager('', ''),
nw,
MagicMock(),
rewards_type='actual',
dry_run=False)
def main(args):
logger.info("Arguments Configuration = {}".format(
json.dumps(args.__dict__, indent=1)))
# 1. find where configuration is
config_dir = os.path.expanduser(args.config_dir)
# create configuration directory if it is not present
# so that user can easily put his configuration there
if config_dir and not os.path.exists(config_dir):
os.makedirs(config_dir)
# 2. get network config
global client_manager
client_manager = ClientManager(node_endpoint=args.node_endpoint,
signer_endpoint=args.signer_endpoint)
network_config_map = init_network_config(args.network, client_manager)
global network_config
network_config = network_config_map[args.network]
logger.debug("Network config {}".format(network_config))
# hello state
input("{} >".format(messages['hello'])).strip()
start()
# 3. loop while collecting information
while not fsm.is_finished():
sleep(0.1)
command = input("{} >\n".format(messages[fsm.current])).strip()
callbacks[fsm.current](command)
pass
# 4. parse and process config
parser.validate()
parser.process()
cfg_dict = parser.get_conf_obj()
# dictionary to BakingConf object, for a bit of type safety
cfg = BakingConf(cfg_dict)
config_file_path = os.path.join(os.path.abspath(config_dir),
cfg.get_baking_address() + '.yaml')
cfg_dict_plain = {
k: v
for k, v in cfg_dict.items() if not k.startswith('__')
}
with open(config_file_path, 'w') as outfile:
yaml.dump(cfg_dict_plain, outfile, default_flow_style=False, indent=4)
print(messages['noplugins'])
print("Configuration file is created at '{}'".format(config_file_path))
def create_consumer(nw, payment_queue):
return PaymentConsumer(
"name",
TEST_REPORT_TEMP_DIR,
"tz1234567890123456789012345678901234",
payment_queue,
"node_addr",
ClientManager("", ""),
nw,
MagicMock(),
rewards_type=RewardsType.ACTUAL,
dry_run=False,
)
def test_disk_full_payment_consumer(args, caplog):
# Issue: https://github.com/tezos-reward-distributor-organization/tezos-reward-distributor/issues/504
client_manager = ClientManager(args.node_endpoint, args.signer_endpoint)
network_config_map = init_network_config(args.network, client_manager)
factory = ProviderFactory(provider="prpc")
parser = BakingYamlConfParser(
baking_config, None, None, None, None, block_api=factory, api_base_url=None
)
parser.parse()
parser.process()
cfg_dict = parser.get_conf_obj()
baking_cfg = BakingConf(cfg_dict)
baking_dirs = BakingDirs(args, baking_cfg.get_baking_address())
payments_queue = queue.Queue(50)
plugins_manager = plugins.PluginManager(baking_cfg.get_plugins_conf(), args.dry_run)
pc = PaymentConsumer(
name="consumer0",
payments_dir=baking_dirs.payments_root,
key_name=baking_cfg.get_payment_address(),
payments_queue=payments_queue,
node_addr=args.node_endpoint,
client_manager=client_manager,
plugins_manager=plugins_manager,
rewards_type=baking_cfg.get_rewards_type(),
args=args,
dry_run=args.dry_run,
reactivate_zeroed=baking_cfg.get_reactivate_zeroed(),
delegator_pays_ra_fee=baking_cfg.get_delegator_pays_ra_fee(),
delegator_pays_xfer_fee=baking_cfg.get_delegator_pays_xfer_fee(),
dest_map=baking_cfg.get_dest_map(),
network_config=network_config_map[args.network],
publish_stats=not args.do_not_publish_stats,
)
assert disk_is_full()
try:
pc.daemon = True
pc.start()
finally:
pc.stop()
assert (
"Disk is becoming full. Only 0.30 Gb left from 11.00 Gb. Please clean up disk to continue saving logs and reports."
in caplog.text
)
def test_address_is_baker_address(block_api):
data_fine = """
version: 1.0
baking_address: {0}
""".format(Constants.STAKENOW_ADDRESS)
wallet_client_manager = ClientManager(node_endpoint, PRIVATE_SIGNER_URL)
cnf_prsr = BakingYamlConfParser(
data_fine,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=node_endpoint,
block_api=block_api,
)
cnf_prsr.parse()
assert cnf_prsr.validate_baking_address(cnf_prsr.conf_obj) is None
def test_invalid_baking_address(block_api):
data_fine = """
version: 1.0
baking_address: tz123
"""
wallet_client_manager = ClientManager(node_endpoint, PRIVATE_SIGNER_URL)
cnf_prsr = BakingYamlConfParser(
data_fine,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=node_endpoint,
block_api=block_api,
)
cnf_prsr.parse()
with pytest.raises(ConfigurationException,
match="Baking address length must be 36"):
cnf_prsr.validate_baking_address(cnf_prsr.conf_obj)
def test_address_is_not_baker_address(block_api):
data_fine = """
version: 1.0
baking_address: tz1N4UfQCahHkRShBanv9QP9TnmXNgCaqCyZ
"""
wallet_client_manager = ClientManager(node_endpoint, PRIVATE_SIGNER_URL)
cnf_prsr = BakingYamlConfParser(
data_fine,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=node_endpoint,
block_api=block_api,
)
cnf_prsr.parse()
with pytest.raises(
ConfigurationException,
match=
"Baking address tz1N4UfQCahHkRShBanv9QP9TnmXNgCaqCyZ is not enabled for delegation",
):
cnf_prsr.validate_baking_address(cnf_prsr.conf_obj)
def test_simulate_single_operation():
config = configparser.ConfigParser()
assert os.path.isfile(FEE_INI) is True
config.read(FEE_INI)
default_fee = int(config["KTTX"]["fee"])
network_config = {"BLOCK_TIME_IN_SEC": 64}
batch_payer = BatchPayer(
node_url="node_addr",
pymnt_addr="tz1234567890123456789012345678901234",
clnt_mngr=ClientManager(
node_endpoint="https://testnet-tezos.giganode.io:443",
signer_endpoint="http://127.0.0.1:6732",
),
delegator_pays_ra_fee=True,
delegator_pays_xfer_fee=True,
network_config=network_config,
plugins_manager=MagicMock(),
dry_run=False,
)
batch_payer.base_counter = 0
reward_log = RewardLog(
address="KT1P3Y1mkGASzuJqLh7uGuQEvHatztGuQRgC",
type="D",
staking_balance=0,
current_balance=0,
)
reward_log.amount = 15577803
reward_log.skipped = False
simulation_status, simulation_results = batch_payer.simulate_single_operation(
reward_log, reward_log.amount, "hash", "unittest")
assert PaymentStatus.DONE == simulation_status
consumed_gas, tx_fee, storage = simulation_results
assert 150 == consumed_gas
assert 589 == default_fee + consumed_gas * MUTEZ_PER_GAS_UNIT
assert int == type(storage) # type of storage should be int
assert 24 == storage
def main(args):
logger.info("TRD version {} is running in {} mode.".format(
VERSION, "daemon" if args.background_service else "interactive"))
logger.info("Arguments Configuration = {}".format(
json.dumps(args.__dict__, indent=1)))
publish_stats = not args.do_not_publish_stats
logger.info(
"Anonymous statistics {} be collected. See docs/statistics.rst for more information."
.format("will" if publish_stats else "will not"))
# 1- find where configuration is
config_dir = os.path.expanduser(args.config_dir)
# create configuration directory if it is not present
# so that user can easily put his configuration there
if config_dir and not os.path.exists(config_dir):
os.makedirs(config_dir)
# 4. get network config
client_manager = ClientManager(node_endpoint=args.node_endpoint,
signer_endpoint=args.signer_endpoint)
network_config_map = init_network_config(args.network, client_manager)
network_config = network_config_map[args.network]
logger.debug("Network config {}".format(network_config))
# Setup provider to fetch RPCs
provider_factory = ProviderFactory(args.reward_data_provider)
# 5- load and verify baking configuration file
config_file_path = None
try:
config_file_path = get_baking_configuration_file(config_dir)
logger.info(
"Loading baking configuration file {}".format(config_file_path))
parser = BakingYamlConfParser(
yaml_text=ConfigParser.load_file(config_file_path),
clnt_mngr=client_manager,
provider_factory=provider_factory,
network_config=network_config,
node_url=args.node_endpoint,
api_base_url=args.api_base_url)
parser.parse()
parser.validate()
parser.process()
# dictionary to BakingConf object, for a bit of type safety
cfg_dict = parser.get_conf_obj()
cfg = BakingConf(cfg_dict)
except ConfigurationException as e:
logger.info(
"Unable to parse '{}' config file.".format(config_file_path))
logger.info(e)
sys.exit(1)
logger.info("Baking Configuration {}".format(cfg))
baking_address = cfg.get_baking_address()
payment_address = cfg.get_payment_address()
logger.info(LINER)
logger.info("BAKING ADDRESS is {}".format(baking_address))
logger.info("PAYMENT ADDRESS is {}".format(payment_address))
logger.info(LINER)
# 6- is it a reports run
dry_run = args.dry_run_no_consumers or args.dry_run
if args.dry_run_no_consumers:
global NB_CONSUMERS
NB_CONSUMERS = 0
# 7- get reporting directories
reports_base = os.path.expanduser(args.reports_base)
# if in reports run mode, do not create consumers
# create reports in reports directory
if dry_run:
reports_base = os.path.expanduser("./reports")
reports_dir = os.path.join(reports_base, baking_address)
payments_root = get_payment_root(reports_dir, create=True)
calculations_root = get_calculations_root(reports_dir, create=True)
get_successful_payments_dir(payments_root, create=True)
get_failed_payments_dir(payments_root, create=True)
# 8- start the life cycle
life_cycle.start(not dry_run)
# 9- service fee calculator
srvc_fee_calc = ServiceFeeCalculator(cfg.get_full_supporters_set(),
cfg.get_specials_map(),
cfg.get_service_fee())
if args.initial_cycle is None:
recent = get_latest_report_file(payments_root)
# if payment logs exists set initial cycle to following cycle
# if payment logs does not exists, set initial cycle to 0, so that payment starts from last released rewards
args.initial_cycle = 0 if recent is None else int(recent) + 1
logger.info("initial_cycle set to {}".format(args.initial_cycle))
# 10- load plugins
plugins_manager = plugins.PluginManager(cfg.get_plugins_conf(), dry_run)
# 11- Start producer and consumer
p = PaymentProducer(name='producer',
initial_payment_cycle=args.initial_cycle,
network_config=network_config,
payments_dir=payments_root,
calculations_dir=calculations_root,
run_mode=RunMode(args.run_mode),
service_fee_calc=srvc_fee_calc,
release_override=args.release_override,
payment_offset=args.payment_offset,
baking_cfg=cfg,
life_cycle=life_cycle,
payments_queue=payments_queue,
dry_run=dry_run,
client_manager=client_manager,
node_url=args.node_endpoint,
provider_factory=provider_factory,
node_url_public=args.node_addr_public,
api_base_url=args.api_base_url,
retry_injected=args.retry_injected)
p.start()
for i in range(NB_CONSUMERS):
c = PaymentConsumer(
name='consumer' + str(i),
payments_dir=payments_root,
key_name=payment_address,
payments_queue=payments_queue,
node_addr=args.node_endpoint,
client_manager=client_manager,
plugins_manager=plugins_manager,
rewards_type=cfg.get_rewards_type(),
args=args,
dry_run=dry_run,
reactivate_zeroed=cfg.get_reactivate_zeroed(),
delegator_pays_ra_fee=cfg.get_delegator_pays_ra_fee(),
delegator_pays_xfer_fee=cfg.get_delegator_pays_xfer_fee(),
dest_map=cfg.get_dest_map(),
network_config=network_config,
publish_stats=publish_stats)
sleep(1)
c.start()
logger.info("Application start completed")
logger.info(LINER)
# Run forever
try:
while life_cycle.is_running():
sleep(10)
except KeyboardInterrupt:
logger.info("Interrupted.")
life_cycle.stop()
def test_batch_payer_total_payout_amount():
factory = ProviderFactory(provider="prpc")
parser = BakingYamlConfParser(
baking_config, None, None, None, None, block_api=factory, api_base_url=None
)
parser.parse()
parser.process()
cfg_dict = parser.get_conf_obj()
baking_cfg = BakingConf(cfg_dict)
srvc_fee_calc = ServiceFeeCalculator(
baking_cfg.get_full_supporters_set(),
baking_cfg.get_specials_map(),
baking_cfg.get_service_fee(),
)
rules_model = RulesModel(
baking_cfg.get_excluded_set_tob(),
baking_cfg.get_excluded_set_toe(),
baking_cfg.get_excluded_set_tof(),
baking_cfg.get_dest_map(),
)
payment_calc = PhasedPaymentCalculator(
baking_cfg.get_founders_map(),
baking_cfg.get_owners_map(),
srvc_fee_calc,
int(baking_cfg.get_min_delegation_amount() * MUTEZ_PER_TEZ),
rules_model,
)
rewardApi = factory.newRewardApi(
default_network_config_map[CURRENT_TESTNET], baking_cfg.get_baking_address(), ""
)
# Simulate logic in payment_producer
reward_logs = []
attempts = 0
exiting = False
while not exiting and attempts < 2:
attempts += 1
# Reward data
# Fetch cycle 51 of granadanet for tz1gtHbmBF3TSebsgJfJPvUB2e9x8EDeNm6V
reward_model = rewardApi.get_rewards_for_cycle_map(
PAYOUT_CYCLE, RewardsType.ACTUAL
)
# Calculate rewards - payment_producer.py
reward_model.computed_reward_amount = reward_model.total_reward_amount
reward_logs, total_amount = payment_calc.calculate(reward_model)
# Check total reward amount matches sums of records
# diff of 1 expected due to floating point arithmetic
assert (
total_amount - sum([rl.adjusted_amount for rl in reward_logs if rl.payable])
<= 1
)
exiting = True
# Merge payments to same address
phaseMerge = CalculatePhaseMerge()
reward_logs = phaseMerge.calculate(reward_logs)
# Handle remapping of payment to alternate address
phaseMapping = CalculatePhaseMapping()
reward_logs = phaseMapping.calculate(reward_logs, baking_cfg.get_dest_map())
# Filter zero-balance addresses based on config
phaseZeroBalance = CalculatePhaseZeroBalance()
reward_logs = phaseZeroBalance.calculate(
reward_logs, baking_cfg.get_reactivate_zeroed()
)
# Filter out non-payable items
reward_logs = [payment_item for payment_item in reward_logs if payment_item.payable]
reward_logs.sort(key=cmp_to_key(cmp_by_type_balance))
batch_payer = BatchPayer(
node_url=node_endpoint,
pymnt_addr="tz1N4UfQCahHkRShBanv9QP9TnmXNgCaqCyZ",
clnt_mngr=ClientManager(node_endpoint, PRIVATE_SIGNER_URL),
delegator_pays_ra_fee=True,
delegator_pays_xfer_fee=True,
network_config=network,
plugins_manager=PluginManager(baking_cfg.get_plugins_conf(), dry_run=True),
dry_run=True,
)
# Do the payment
(
_,
total_attempts,
total_payout_amount,
number_future_payable_cycles,
) = batch_payer.pay(reward_logs, dry_run=True)
# Payment does not have status done, paid or injected thus the total payout amount is zero
assert total_payout_amount == 0
assert number_future_payable_cycles == 2
assert total_attempts == 3
# Check the adjusted amount
assert reward_logs[0].adjusted_amount == 40418486
assert reward_logs[1].adjusted_amount == 10581272
assert reward_logs[2].adjusted_amount == 109732835
assert reward_logs[3].adjusted_amount == 48362127
assert reward_logs[4].adjusted_amount == 29116310
def test_batch_payer_total_payout_amount():
factory = ProviderFactory(provider="prpc")
parser = BakingYamlConfParser(baking_config,
None,
None,
None,
None,
block_api=factory,
api_base_url=None)
parser.parse()
parser.process()
cfg_dict = parser.get_conf_obj()
baking_cfg = BakingConf(cfg_dict)
srvc_fee_calc = ServiceFeeCalculator(
baking_cfg.get_full_supporters_set(),
baking_cfg.get_specials_map(),
baking_cfg.get_service_fee(),
)
rules_model = RulesModel(
baking_cfg.get_excluded_set_tob(),
baking_cfg.get_excluded_set_toe(),
baking_cfg.get_excluded_set_tof(),
baking_cfg.get_dest_map(),
)
payment_calc = PhasedPaymentCalculator(
baking_cfg.get_founders_map(),
baking_cfg.get_owners_map(),
srvc_fee_calc,
baking_cfg.get_min_delegation_amount() * MUTEZ,
rules_model,
)
rewardApi = factory.newRewardApi(
default_network_config_map[CURRENT_TESTNET],
baking_cfg.get_baking_address(), "")
# Simulate logic in payment_producer
reward_logs = []
attempts = 0
exiting = False
while not exiting and attempts < 2:
attempts += 1
# Reward data
# Fetch cycle 51 of granadanet for tz1gtHbmBF3TSebsgJfJPvUB2e9x8EDeNm6V
reward_model = rewardApi.get_rewards_for_cycle_map(
PAYOUT_CYCLE, RewardsType.ACTUAL)
# Calculate rewards - payment_producer.py
reward_model.computed_reward_amount = reward_model.total_reward_amount
reward_logs, total_amount = payment_calc.calculate(reward_model)
# Check total reward amount matches sums of records
assert total_amount == sum(
[rl.amount for rl in reward_logs if rl.payable])
exiting = True
# Merge payments to same address
phaseMerge = CalculatePhaseMerge()
reward_logs = phaseMerge.calculate(reward_logs)
# Handle remapping of payment to alternate address
phaseMapping = CalculatePhaseMapping()
reward_logs = phaseMapping.calculate(reward_logs,
baking_cfg.get_dest_map())
# Filter zero-balance addresses based on config
phaseZeroBalance = CalculatePhaseZeroBalance()
reward_logs = phaseZeroBalance.calculate(
reward_logs, baking_cfg.get_reactivate_zeroed())
# Filter out non-payable items
reward_logs = [
payment_item for payment_item in reward_logs if payment_item.payable
]
reward_logs.sort(key=cmp_to_key(cmp_by_type_balance))
batch_payer = BatchPayer(
node_url=node_endpoint,
pymnt_addr="tz1gtHbmBF3TSebsgJfJPvUB2e9x8EDeNm6V",
clnt_mngr=ClientManager(node_endpoint, PRIVATE_SIGNER_URL),
delegator_pays_ra_fee=True,
delegator_pays_xfer_fee=True,
network_config=network,
plugins_manager=PluginManager(baking_cfg.get_plugins_conf(),
dry_run=True),
dry_run=True,
)
# Fix the endpoint auto port assignment because
# https://mainnet-tezos.giganode.io:8732 cannot be reached
batch_payer.clnt_mngr.node_endpoint = node_endpoint
# Do the payment
(
payment_logs,
total_attempts,
total_payout_amount,
number_future_payable_cycles,
) = batch_payer.pay(reward_logs, dry_run=True)
assert total_attempts == 3
assert total_payout_amount == 238211030
assert (PAYMENT_ADDRESS_BALANCE //
total_payout_amount) - 1 == number_future_payable_cycles
def main(args):
logger.info("Arguments Configuration = {}".format(
json.dumps(args.__dict__, indent=1)))
# 1- find where configuration is
config_dir = os.path.expanduser(args.config_dir)
# create configuration directory if it is not present
# so that user can easily put his configuration there
if config_dir and not os.path.exists(config_dir):
os.makedirs(config_dir)
# 3- load payments file
payments_file = os.path.expanduser(args.payments_file)
if not os.path.isfile(payments_file):
raise Exception(
"payments_file ({}) does not exist.".format(payments_file))
with open(payments_file, 'r') as file:
payment_lines = file.readlines()
payments_dict = {}
for line in payment_lines:
pkh, amt = line.split(":")
pkh = pkh.strip()
amt = float(amt.strip())
payments_dict[pkh] = amt
if not payments_dict:
raise Exception("No payments to process")
# 6- is it a reports run
dry_run = args.dry_run
# 7- get reporting directories
reports_dir = os.path.expanduser(args.reports_dir)
# if in reports run mode, do not create consumers
# create reports in reports directory
if dry_run:
reports_dir = os.path.expanduser("./reports")
reports_dir = os.path.join(reports_dir, "manual")
payments_root = get_payment_root(reports_dir, create=True)
get_successful_payments_dir(payments_root, create=True)
get_failed_payments_dir(payments_root, create=True)
client_manager = ClientManager(node_endpoint=args.node_endpoint,
signer_endpoint=args.signer_endpoint)
for i in range(NB_CONSUMERS):
c = PaymentConsumer(name='manual_payment_consumer',
payments_dir=payments_root,
key_name=args.paymentaddress,
payments_queue=payments_queue,
node_addr=args.node_endpoint,
client_manager=client_manager,
dry_run=dry_run,
reactivate_zeroed=False,
delegator_pays_ra_fee=False,
delegator_pays_xfer_fee=False)
time.sleep(1)
c.start()
base_name_no_ext = os.path.basename(payments_file)
base_name_no_ext = os.path.splitext(base_name_no_ext)[0]
now = datetime.now()
now_str = now.strftime("%Y%m%d%H%M%S")
file_name = base_name_no_ext + "_" + now_str
payment_items = []
for key, value in payments_dict.items():
pi = RewardLog.ExternalInstance(file_name, key, value)
pi.payment = pi.payment * MUTEZ
payment_items.append(pi)
logger.info(
"Reward created for cycle %s address %s amount %f fee %f tz type %s",
pi.cycle, pi.address, pi.payment, pi.fee, pi.type)
payments_queue.put(PaymentBatch(None, 0, payment_items))
payments_queue.put(PaymentBatch(None, 0, [RewardLog.ExitInstance()]))
def main(args):
logger.info("Arguments Configuration = {}".format(
json.dumps(args.__dict__, indent=1)))
# 1. find where configuration is
config_dir = os.path.join(
os.path.expanduser(os.path.normpath(args.base_directory)), CONFIG_DIR,
"")
# create configuration directory if it is not present
# so that user can easily put his configuration there
if config_dir and not os.path.exists(config_dir):
os.makedirs(config_dir)
# 2. get network config
global client_manager
client_manager = ClientManager(node_endpoint=args.node_endpoint,
signer_endpoint=args.signer_endpoint)
network_config_map = init_network_config(args.network, client_manager)
global network_config
network_config = network_config_map[args.network]
logger.debug("Network config {}".format(network_config))
# hello state
input("{} >".format(messages["hello"])).strip()
start()
# 3. loop while collecting information
while not fsm.is_finished():
sleep(0.1)
command = input("{} >\n".format(messages[fsm.current])).strip()
callbacks[fsm.current](command)
# 4. parse and process config
parser.validate()
parser.process()
cfg_dict = parser.get_conf_obj()
# dictionary to BakingConf object, for a bit of type safety
cfg = BakingConf(cfg_dict)
config_file_path = os.path.join(os.path.abspath(config_dir),
cfg.get_baking_address() + ".yaml")
cfg_dict_plain = {
k: v
for k, v in cfg_dict.items() if not k.startswith("__")
}
try:
with open(config_file_path, "w") as outfile:
yaml.dump(cfg_dict_plain,
outfile,
default_flow_style=False,
indent=4)
except Exception as e:
import errno
print("Exception during write operation invoked: {}".format(e))
if e.errno == errno.ENOSPC:
print("Not enough space on device!")
exit()
print(messages["noplugins"])
print("Configuration file is created at '{}'".format(config_file_path))
def test_validate_no_founders_map(self):
data_no_founders = """
version: 1.0
baking_address: tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194
payment_address: tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194
owners_map: {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5}
supporters_set: None
service_fee: 4.5
reactivate_zeroed: False
delegator_pays_ra_fee: True
rewards_type:
plugins:
enabled:
"""
wallet_client_manager = ClientManager(self.mainnet_public_node_url,
self.signer_endpoint)
block_api = RpcBlockApiImpl(network, self.mainnet_public_node_url)
cnf_prsr = BakingYamlConfParser(
data_no_founders,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=self.mainnet_public_node_url,
block_api=block_api,
)
cnf_prsr.parse()
cnf_prsr.validate()
self.assertEqual(
cnf_prsr.get_conf_obj_attr("baking_address"),
"tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194",
)
self.assertEqual(
cnf_prsr.get_conf_obj_attr("payment_address"),
"tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194",
)
self.assertEqual(
cnf_prsr.get_conf_obj_attr("__payment_address_pkh"),
"tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194",
)
self.assertEqual(
cnf_prsr.get_conf_obj_attr("__payment_address_manager"),
"tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194",
)
self.assertEqual(cnf_prsr.get_conf_obj_attr("__payment_address_type"),
AddrType.TZ)
self.assertEqual(cnf_prsr.get_conf_obj_attr("founders_map"), dict())
self.assertEqual(cnf_prsr.get_conf_obj_attr("specials_map"), dict())
self.assertEqual(cnf_prsr.get_conf_obj_attr("supporters_set"), set())
self.assertEqual(cnf_prsr.get_conf_obj_attr("min_delegation_amt"), 0)
self.assertEqual(cnf_prsr.get_conf_obj_attr("reactivate_zeroed"),
False)
self.assertEqual(cnf_prsr.get_conf_obj_attr("delegator_pays_ra_fee"),
True)
self.assertEqual(cnf_prsr.get_conf_obj_attr("rewards_type"),
RewardsType.ACTUAL)
plugins = cnf_prsr.get_conf_obj_attr("plugins")
self.assertIsInstance(plugins, dict)
self.assertIsNone(plugins["enabled"], None)
def main(args):
logger.info(
"Arguments Configuration = {}".format(json.dumps(args.__dict__, indent=1))
)
# Load payments file
payments_file = os.path.expanduser(os.path.normpath(args.payments_file))
if not os.path.isfile(payments_file):
raise Exception("payments_file ({}) does not exist.".format(payments_file))
with open(payments_file, "r") as file:
payment_lines = file.readlines()
payments_dict = {}
for line in payment_lines:
pkh, amt = line.split(":")
pkh = pkh.strip()
amt = float(amt.strip())
payments_dict[pkh] = amt
if not payments_dict:
raise Exception("No payments to process")
# Check if dry-run
dry_run = args.dry_run
# Get reporting directories
reports_dir = os.path.expanduser(os.path.normpath(args.base_directory))
# Check the disk size at the reports dir location
if disk_is_full(reports_dir):
raise Exception(
"Disk is full at {}. Please free space to continue saving reports.".format(
reports_dir
)
)
# if in reports run mode, do not create consumers
# create reports in reports directory
if dry_run:
reports_dir = os.path.join(reports_dir, SIMULATIONS_DIR, "")
else:
reports_dir = os.path.join(reports_dir, REPORTS_DIR, "")
reports_dir = os.path.join(reports_dir, "manual", "")
payments_root = get_payment_root(reports_dir, create=True)
get_successful_payments_dir(payments_root, create=True)
get_failed_payments_dir(payments_root, create=True)
client_manager = ClientManager(
node_endpoint=args.node_endpoint, signer_endpoint=args.signer_endpoint
)
for i in range(NB_CONSUMERS):
c = PaymentConsumer(
name="manual_payment_consumer",
payments_dir=payments_root,
key_name=args.paymentaddress,
payments_queue=payments_queue,
node_addr=args.node_endpoint,
client_manager=client_manager,
dry_run=dry_run,
reactivate_zeroed=False,
delegator_pays_ra_fee=False,
delegator_pays_xfer_fee=False,
)
time.sleep(1)
c.start()
base_name_no_ext = os.path.basename(payments_file)
base_name_no_ext = os.path.splitext(base_name_no_ext)[0]
now = datetime.now()
now_str = now.strftime("%Y%m%d%H%M%S")
file_name = base_name_no_ext + "_" + now_str
payment_items = []
for key, value in payments_dict.items():
pi = RewardLog.ExternalInstance(file_name, key, value)
pi.payment = pi.payment * MUTEZ
payment_items.append(pi)
logger.info(
"Reward created for cycle %s address %s amount %f fee %f tz type %s",
pi.cycle,
pi.address,
pi.payment,
pi.fee,
pi.type,
)
payments_queue.put(PaymentBatch(None, 0, payment_items))
payments_queue.put(PaymentBatch(None, 0, [RewardLog.ExitInstance()]))
def do_build_node_client(self, e):
self.__node_client = ClientManager(
self.args.node_endpoint, self.args.signer_endpoint
)