def test_parse_get_manager_for_contract_response(self):
response = """
Disclaimer:
The Tezos network is a new blockchain technology.
Users are solely responsible for any risks associated
with usage of the Tezos network. Users should do their
own research to determine if Tezos is the appropriate
platform for their needs and should apply judgement and
care in their network interactions.
tz1PJnnddwa1P5jg5sChddigxfMccK8nwLiV (known as habanoz)
"""
clientManager = WalletClientManager(None, node_addr=None)
manager = clientManager.parse_get_manager_for_contract_response(response)
self.assertEqual('tz1PJnnddwa1P5jg5sChddigxfMccK8nwLiV', manager)
def test_parse_get_manager_for_contract_response(self):
response = """
Disclaimer:
The Dune network is a new blockchain technology.
Users are solely responsible for any risks associated
with usage of the Dune network. Users should do their
own research to determine if Dune is the appropriate
platform for their needs and should apply judgement and
care in their network interactions.
dn1KogjUiBYdkBGvUPdRhKrK2cssRqH7eX63 (known as habanoz)
"""
clientManager = WalletClientManager(None)
manager = clientManager.parse_get_manager_for_contract_response(
response)
self.assertEqual('dn1KogjUiBYdkBGvUPdRhKrK2cssRqH7eX63', manager)
def test_validate_no_founders_map(self):
data_no_founders = """
version : 1.0
baking_address : dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x
payment_address : dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x
owners_map : {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5}
service_fee : 4.5
"""
managers_map = {
'dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x':
'dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x'
}
contr_dict_by_alias = {}
addr_dict_by_pkh = {
"dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x": {
"pkh": "dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x",
"originated": False,
"alias": "main1",
"sk": True,
"manager": "dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x"
}
}
wallet_client_manager = WalletClientManager(
client_path=None,
addr_dict_by_pkh=addr_dict_by_pkh,
contr_dict_by_alias=contr_dict_by_alias,
managers=managers_map)
mirror_selector = DunScanMirrorSelector(network)
mirror_selector.initialize()
block_api = DunScanBlockApiImpl(network, mirror_selector)
cnf_prsr = BakingYamlConfParser(data_no_founders,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=mainnet_public_node_url,
block_api=block_api)
cnf_prsr.parse()
cnf_prsr.validate()
self.assertEqual(cnf_prsr.get_conf_obj_attr('baking_address'),
'dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address'),
'dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x')
self.assertEqual(cnf_prsr.get_conf_obj_attr('__payment_address_pkh'),
'dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x')
self.assertEqual(
cnf_prsr.get_conf_obj_attr('__payment_address_manager'),
'dn1VWnJRnF3vsa3tkYp3PqoCbV1eBRc5vJ2x')
self.assertEqual(cnf_prsr.get_conf_obj_attr('__payment_address_type'),
AddrType.DN)
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(0, cnf_prsr.get_conf_obj_attr('min_delegation_amt'))
def test_validate_pymnt_alias(self):
data_no_founders = """
version : 1.0
baking_address : tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
payment_address : ktPay
owners_map : {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5}
service_fee : 4.5
min_delegation_amt : 100
"""
managers_map = {
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj',
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj'
}
contr_dict_by_alias = {'ktPay': 'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj'}
addr_dict_by_pkh = {
"tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {
"pkh": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj",
"originated": False,
"alias": "ktPay",
"sk": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"
}
}
wallet_client_manager = WalletClientManager(
client_path=None,
addr_dict_by_pkh=addr_dict_by_pkh,
contr_dict_by_alias=contr_dict_by_alias,
managers=managers_map)
cnf_prsr = BakingYamlConfParser(data_no_founders,
wallet_client_manager)
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'),
'ktPay')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address_pkh'),
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address_manager'),
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address_type'),
AddrType.KTALS)
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('excluded_delegators_set'),
set())
self.assertEqual(100, cnf_prsr.get_conf_obj_attr('min_delegation_amt'))
self.assertEqual(cnf_prsr.get_conf_obj_attr('prcnt_scale'), None)
self.assertEqual(cnf_prsr.get_conf_obj_attr('pymnt_scale'), None)
def test_get_revelation():
wllt_clnt_mngr = WalletClientManager("~/tezos-alpha/tezos-client", "", "", "", True)
address_api = RpcBlockApiImpl({"NAME":"ALPHANET"}, wllt_clnt_mngr, "127.0.0.1:8732")
print(address_api.get_revelation("tz1N5cvoGZFNYWBp2NbCWhaRXuLQf6e1gZrv"))
print(address_api.get_revelation("KT1FXQjnbdqDdKNpjeM6o8PF1w8Rn2j8BmmG"))
print(address_api.get_revelation("tz1YVxe7FFisREKXWNxdrrwqvw3o2jeXzaNb"))
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}
service_fee : 4.5
"""
managers_map = {
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj'
}
contr_dict_by_alias = {}
addr_dict_by_pkh = {
"tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {
"pkh": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj",
"originated": False,
"alias": "main1",
"sk": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"
}
}
wallet_client_manager = WalletClientManager(
client_path=None,
node_addr=None,
addr_dict_by_pkh=addr_dict_by_pkh,
contr_dict_by_alias=contr_dict_by_alias,
managers=managers_map)
block_api = RpcBlockApiImpl(network, mainnet_public_node_url)
cnf_prsr = BakingYamlConfParser(data_no_founders,
wallet_client_manager,
provider_factory=None,
network_config=network,
node_url=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(0, cnf_prsr.get_conf_obj_attr('min_delegation_amt'))
def test_parse_list_known_addresses_response(self):
response = """
Disclaimer:
The Tezos network is a new blockchain technology.
Users are solely responsible for any risks associated
with usage of the Tezos network. Users should do their
own research to determine if Tezos is the appropriate
platform for their needs and should apply judgement and
care in their network interactions.
mainpay: tz1aZoFH2pd3V9UEq5psqVokVBYkt7YSi1ow
habanoz: tz1fyvFH2pd3V9UEq5psqVokVBYkt7rHTKio (unencrypted sk known)
mainnetme: tz1a5GGJeyqeQ4ihZqbiRVcvj5rY5kMAt3Xa (tcp sk known)
zeronetme: tz1MZ72sJEVen3Qgc7uWvqKhKFJW84bNGd6T (unencrypted sk not known)
baker: tz1XXXXXXXX (unix sk known)
"""
clientManager = WalletClientManager(None)
dict = clientManager.parse_list_known_addresses_response(response)
habanoz = dict['tz1fyvFH2pd3V9UEq5psqVokVBYkt7rHTKio']
self.assertEqual(habanoz['alias'], 'habanoz')
self.assertEqual(habanoz['sk'], True)
mainnetme = dict['tz1a5GGJeyqeQ4ihZqbiRVcvj5rY5kMAt3Xa']
self.assertEqual(mainnetme['alias'], 'mainnetme')
self.assertEqual(mainnetme['sk'], True)
zeronetme = dict['tz1MZ72sJEVen3Qgc7uWvqKhKFJW84bNGd6T']
self.assertEqual(zeronetme['alias'], 'zeronetme')
self.assertEqual(zeronetme['sk'], False)
mainpay = dict['tz1aZoFH2pd3V9UEq5psqVokVBYkt7YSi1ow']
self.assertEqual(mainpay['alias'], 'mainpay')
self.assertEqual(mainpay['sk'], False)
baker = dict['tz1XXXXXXXX']
self.assertEqual(baker['alias'], 'baker')
self.assertEqual(baker['sk'], True)
def test_parse_list_known_addresses_response(self):
response = """
Disclaimer:
The Dune network is a new blockchain technology.
Users are solely responsible for any risks associated
with usage of the Dune network. Users should do their
own research to determine if Dune is the appropriate
platform for their needs and should apply judgement and
care in their network interactions.
mainpay: tz1aZoFH2pd3V9UEq5psqVokVBYkt7YSi1ow
habanoz: dn1cUpC874bfrF1VDcFbuBwNZ951hdtQQgVg (unencrypted sk known)
mainnetme: dn1WaAD9jDpGmAFwxN2SVBkYo3NnuGR9Ep5G (tcp sk known)
zeronetme: dn1J3zyiNUUH98wvzeLEzXTKPCpkwaf7YYkb (unencrypted sk not known)
baker: tz1XXXXXXXX (unix sk known)
"""
clientManager = WalletClientManager(None)
dict = clientManager.parse_list_known_addresses_response(response)
habanoz = dict['dn1cUpC874bfrF1VDcFbuBwNZ951hdtQQgVg']
self.assertEqual(habanoz['alias'], 'habanoz')
self.assertEqual(habanoz['sk'], True)
mainnetme = dict['dn1WaAD9jDpGmAFwxN2SVBkYo3NnuGR9Ep5G']
self.assertEqual(mainnetme['alias'], 'mainnetme')
self.assertEqual(mainnetme['sk'], True)
zeronetme = dict['dn1J3zyiNUUH98wvzeLEzXTKPCpkwaf7YYkb']
self.assertEqual(zeronetme['alias'], 'zeronetme')
self.assertEqual(zeronetme['sk'], False)
mainpay = dict['tz1aZoFH2pd3V9UEq5psqVokVBYkt7YSi1ow']
self.assertEqual(mainpay['alias'], 'mainpay')
self.assertEqual(mainpay['sk'], False)
baker = dict['tz1XXXXXXXX']
self.assertEqual(baker['alias'], 'baker')
self.assertEqual(baker['sk'], True)
def test_get_revelation():
wllt_clnt_mngr = WalletClientManager("~/dune-alpha/dune-client", "", "",
"", True)
address_api = RpcBlockApiImpl({"NAME": "TESTNET"}, wllt_clnt_mngr,
"127.0.0.1:8732")
print(address_api.get_revelation("dn1JaWseLoDzubj4Qu1vaPi3brrfUcjdhMJU"))
print(address_api.get_revelation("KT1FXQjnbdqDdKNpjeM6o8PF1w8Rn2j8BmmG"))
print(address_api.get_revelation("dn1UzraxKVhVnKrmtuPMvZ5Tzta3rFfNHyqP"))
def test_parse_client_list_known_contracts_response(self):
response = """
Disclaimer:
The Tezos network is a new blockchain technology.
Users are solely responsible for any risks associated
with usage of the Tezos network. Users should do their
own research to determine if Tezos is the appropriate
platform for their needs and should apply judgement and
care in their network interactions.
newcontr: KT1XqEHigP5XumZy9i76QyVd6u93VD4HTqJK
habanoz: tz1fyvFH2pd3V9UEq5psqVokVBYkt7rHTKio
mainnetme: tz1a5GGJeyqeQ4ihZqbiRVcvj5rY5kMAt3Xa
"""
clientManager = WalletClientManager(None, node_addr=None)
dict = clientManager.parse_list_known_contracts_response(response)
self.assertTrue(dict['newcontr'] == 'KT1XqEHigP5XumZy9i76QyVd6u93VD4HTqJK')
self.assertTrue(dict['habanoz'] == 'tz1fyvFH2pd3V9UEq5psqVokVBYkt7rHTKio')
self.assertTrue(dict['mainnetme'] == 'tz1a5GGJeyqeQ4ihZqbiRVcvj5rY5kMAt3Xa')
def test_validate_scales(self):
data_fine = """
version : 1.0
baking_address : tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
payment_address : tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
founders_map : {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5}
owners_map : {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':0.5}
service_fee : 4.5
pymnt_scale : 3
prcnt_scale : 5
"""
managers = {
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj',
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj'
}
contr_dict_by_alias = {}
addr_dict_by_pkh = {
"tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {
"pkh": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj",
"originated": False,
"alias": "main1",
"sk": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"
}
}
wallet_client_manager = WalletClientManager(
client_path=None,
addr_dict_by_pkh=addr_dict_by_pkh,
contr_dict_by_alias=contr_dict_by_alias,
managers=managers)
cnf_prsr = BakingYamlConfParser(data_fine, wallet_client_manager)
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(0, cnf_prsr.get_conf_obj_attr('min_delegation_amt'))
self.assertEqual(cnf_prsr.get_conf_obj_attr('excluded_delegators_set'),
set())
self.assertEqual(cnf_prsr.get_conf_obj_attr('prcnt_scale'), 5)
self.assertEqual(cnf_prsr.get_conf_obj_attr('pymnt_scale'), 3)
def test_parse_client_list_known_contracts_response(self):
response = """
Disclaimer:
The Dune network is a new blockchain technology.
Users are solely responsible for any risks associated
with usage of the Dune network. Users should do their
own research to determine if Dune is the appropriate
platform for their needs and should apply judgement and
care in their network interactions.
newcontr: KT1XqEHigP5XumZy9i76QyVd6u93VD4HTqJK
habanoz: dn1cUpC874bfrF1VDcFbuBwNZ951hdtQQgVg
mainnetme: dn1WaAD9jDpGmAFwxN2SVBkYo3NnuGR9Ep5G
"""
clientManager = WalletClientManager(None)
dict = clientManager.parse_list_known_contracts_response(response)
self.assertTrue(
dict['newcontr'] == 'KT1XqEHigP5XumZy9i76QyVd6u93VD4HTqJK')
self.assertTrue(
dict['habanoz'] == 'dn1cUpC874bfrF1VDcFbuBwNZ951hdtQQgVg')
self.assertTrue(
dict['mainnetme'] == 'dn1WaAD9jDpGmAFwxN2SVBkYo3NnuGR9Ep5G')
def test_validate(self):
data_fine = """
version: 1.0
baking_address: tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
payment_address: tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
founders_map: {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5}
owners_map: {'KT2Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5,'KT3Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 0.5}
service_fee: 4.53
reactivate_zeroed: False
delegator_pays_ra_fee: True
"""
managers = {'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj',
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj': 'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj'}
contr_dict_by_alias = {}
addr_dict_by_pkh = {
"tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {"pkh": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj", "originated": False,
"alias": "main1", "sk": True, "revealed": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"},
"KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {"pkh": "KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj", "originated": True,
"alias": "kt1", "sk": True, "revealed": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"}
}
wallet_client_manager = WalletClientManager(client_path=None, node_addr=None,
addr_dict_by_pkh=addr_dict_by_pkh,
contr_dict_by_alias=contr_dict_by_alias,
managers=managers)
block_api = RpcBlockApiImpl(network, self.mainnet_public_node_url)
cnf_prsr = BakingYamlConfParser(data_fine, 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('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)
def main(args):
logger.info("TRD version {} is running in {} mode.".format(
version.version,
"daemon" if args.background_service else "interactive"))
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- Load master configuration file if it is present
master_config_file_path = os.path.join(config_dir, "master.yaml")
master_cfg = {}
if os.path.isfile(master_config_file_path):
logger.debug("Loading master configuration file {}".format(
master_config_file_path))
master_parser = YamlConfParser(
ConfigParser.load_file(master_config_file_path))
master_cfg = master_parser.parse()
else:
logger.debug("master configuration file not present.")
managers = None
contracts_by_alias = None
addresses_by_pkh = None
if 'managers' in master_cfg:
managers = master_cfg['managers']
if 'contracts_by_alias' in master_cfg:
contracts_by_alias = master_cfg['contracts_by_alias']
if 'addresses_by_pkh' in master_cfg:
addresses_by_pkh = master_cfg['addresses_by_pkh']
# 3- get client path
client_path = get_client_path(
[x.strip() for x in args.executable_dirs.split(',')], args.docker,
args.network, args.verbose)
logger.debug("Dune client path is {}".format(client_path))
# 4. get network config
config_client_manager = SimpleClientManager(client_path)
network_config_map = init_network_config(args.network,
config_client_manager,
args.node_addr)
network_config = network_config_map[args.network]
logger.debug("Network config {}".format(network_config))
# 5- load baking configuration file
config_file_path = get_baking_configuration_file(config_dir)
logger.info(
"Loading baking configuration file {}".format(config_file_path))
wllt_clnt_mngr = WalletClientManager(client_path,
contracts_by_alias,
addresses_by_pkh,
managers,
verbose=args.verbose)
provider_factory = ProviderFactory(args.reward_data_provider,
verbose=args.verbose)
parser = BakingYamlConfParser(ConfigParser.load_file(config_file_path),
wllt_clnt_mngr,
provider_factory,
network_config,
args.node_addr,
verbose=args.verbose)
parser.parse()
parser.validate()
parser.process()
cfg_dict = parser.get_conf_obj()
# dictionary to BakingConf object, for a bit of type safety
cfg = BakingConf(cfg_dict, master_cfg)
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))
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,
wllt_clnt_mngr=wllt_clnt_mngr,
node_url=args.node_addr,
provider_factory=provider_factory,
verbose=args.verbose)
p.start()
publish_stats = not args.do_not_publish_stats
for i in range(NB_CONSUMERS):
c = PaymentConsumer(
name='consumer' + str(i),
payments_dir=payments_root,
key_name=payment_address,
client_path=client_path,
payments_queue=payments_queue,
node_addr=args.node_addr,
wllt_clnt_mngr=wllt_clnt_mngr,
args=args,
verbose=args.verbose,
dry_run=dry_run,
delegator_pays_xfer_fee=cfg.get_delegator_pays_xfer_fee(),
dest_map=cfg.get_dest_map(),
network_config=network_config,
publish_stats=publish_stats)
time.sleep(1)
c.start()
logger.info("Application start completed")
logger.info(LINER)
try:
while life_cycle.is_running():
time.sleep(10)
except KeyboardInterrupt:
logger.info("Interrupted.")
life_cycle.stop()
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- Load master configuration file if it is present
master_config_file_path = os.path.join(config_dir, "master.yaml")
master_cfg = {}
if os.path.isfile(master_config_file_path):
logger.info("Loading master configuration file {}".format(
master_config_file_path))
master_parser = YamlConfParser(
ConfigParser.load_file(master_config_file_path))
master_cfg = master_parser.parse()
else:
logger.info("master configuration file not present.")
managers = None
contracts_by_alias = None
addresses_by_pkh = None
if 'managers' in master_cfg:
managers = master_cfg['managers']
if 'contracts_by_alias' in master_cfg:
contracts_by_alias = master_cfg['contracts_by_alias']
if 'addresses_by_pkh' in master_cfg:
addresses_by_pkh = master_cfg['addresses_by_pkh']
# 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")
# 4- get client path
network_config = network_config_map[args.network]
client_path = get_client_path(
[x.strip() for x in args.executable_dirs.split(',')], args.docker,
network_config, args.verbose)
logger.debug("Tezos client path is {}".format(client_path))
# 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)
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)
wllt_clnt_mngr = WalletClientManager(client_path, contracts_by_alias,
addresses_by_pkh, managers)
for i in range(NB_CONSUMERS):
c = PaymentConsumer(name='manual_payment_consumer',
payments_dir=payments_root,
key_name=args.paymentaddress,
client_path=client_path,
payments_queue=payments_queue,
node_addr=args.node_addr,
wllt_clnt_mngr=wllt_clnt_mngr,
verbose=args.verbose,
dry_run=dry_run,
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():
payment_items.append(
PaymentRecord.ManualInstance(file_name, key, value))
payments_queue.put(payment_items)
payments_queue.put([PaymentRecord.ExitInstance()])
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- Load master configuration file if it is present
master_config_file_path = os.path.join(config_dir, "master.yaml")
master_cfg = {}
if os.path.isfile(master_config_file_path):
logger.info("Loading master configuration file {}".format(
master_config_file_path))
master_parser = YamlConfParser(
ConfigParser.load_file(master_config_file_path))
master_cfg = master_parser.parse()
else:
logger.info("master configuration file not present.")
managers = None
contracts_by_alias = None
addresses_by_pkh = None
if 'managers' in master_cfg:
managers = master_cfg['managers']
if 'contracts_by_alias' in master_cfg:
contracts_by_alias = master_cfg['contracts_by_alias']
if 'addresses_by_pkh' in master_cfg:
addresses_by_pkh = master_cfg['addresses_by_pkh']
# 3- get client path
client_path = get_client_path(
[x.strip() for x in args.executable_dirs.split(',')], args.docker,
args.network, args.verbose)
logger.debug("Tezos client path is {}".format(client_path))
# 4. get network config
config_client_manager = SimpleClientManager(client_path, args.node_addr)
network_config_map = init_network_config(args.network,
config_client_manager,
args.node_addr)
network_config = network_config_map[args.network]
# 5- load baking configuration file
config_file_path = get_baking_configuration_file(config_dir)
logger.info(
"Loading baking configuration file {}".format(config_file_path))
wllt_clnt_mngr = WalletClientManager(client_path,
contracts_by_alias,
addresses_by_pkh,
managers,
verbose=args.verbose)
provider_factory = ProviderFactory(args.reward_data_provider,
verbose=args.verbose)
parser = BakingYamlConfParser(ConfigParser.load_file(config_file_path),
wllt_clnt_mngr,
provider_factory,
network_config,
args.node_addr,
verbose=args.verbose,
api_base_url=args.api_base_url)
parser.parse()
parser.validate()
parser.process()
cfg_dict = parser.get_conf_obj()
# dictionary to BakingConf object, for a bit of type safety
cfg = BakingConf(cfg_dict, master_cfg)
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_dir = os.path.expanduser(args.reports_base)
# 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, 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(False)
# 9- service fee calculator
srvc_fee_calc = ServiceFeeCalculator(cfg.get_full_supporters_set(),
cfg.get_specials_map(),
cfg.get_service_fee())
try:
p = PaymentProducer(name='producer',
initial_payment_cycle=None,
network_config=network_config,
payments_dir=payments_root,
calculations_dir=calculations_root,
run_mode=RunMode.ONETIME,
service_fee_calc=srvc_fee_calc,
release_override=0,
payment_offset=0,
baking_cfg=cfg,
life_cycle=life_cycle,
payments_queue=payments_queue,
dry_run=dry_run,
wllt_clnt_mngr=wllt_clnt_mngr,
node_url=args.node_addr,
provider_factory=provider_factory,
verbose=args.verbose,
api_base_url=args.api_base_url)
p.retry_failed_payments(args.retry_injected)
c = PaymentConsumer(
name='consumer_retry_failed',
payments_dir=payments_root,
key_name=payment_address,
client_path=client_path,
payments_queue=payments_queue,
node_addr=args.node_addr,
wllt_clnt_mngr=wllt_clnt_mngr,
verbose=args.verbose,
dry_run=dry_run,
delegator_pays_xfer_fee=cfg.get_delegator_pays_xfer_fee(),
network_config=network_config)
time.sleep(1)
c.start()
p.exit()
c.join()
logger.info("Application start completed")
logger.info(LINER)
sleep(5)
except KeyboardInterrupt:
logger.info("Interrupted.")
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- Load master configuration file if it is present
master_config_file_path = os.path.join(config_dir, "master.yaml")
master_cfg = {}
if os.path.isfile(master_config_file_path):
logger.debug("Loading master configuration file {}".format(
master_config_file_path))
master_parser = YamlConfParser(
ConfigParser.load_file(master_config_file_path))
master_cfg = master_parser.parse()
else:
logger.debug("master configuration file not present.")
managers = None
contracts_by_alias = None
addresses_by_pkh = None
if 'managers' in master_cfg:
managers = master_cfg['managers']
if 'contracts_by_alias' in master_cfg:
contracts_by_alias = master_cfg['contracts_by_alias']
if 'addresses_by_pkh' in master_cfg:
addresses_by_pkh = master_cfg['addresses_by_pkh']
# 3- get client path
client_path = get_client_path(
[x.strip() for x in args.executable_dirs.split(',')], args.docker,
args.network)
logger.debug("tezos-client path is {}".format(client_path))
# 4. get network config
config_client_manager = SimpleClientManager(client_path, args.node_addr)
network_config_map = init_network_config(args.network,
config_client_manager,
args.node_addr)
global network_config
network_config = network_config_map[args.network]
logger.debug("Network config {}".format(network_config))
global wllt_clnt_mngr
wllt_clnt_mngr = WalletClientManager(client_path, args.node_addr,
contracts_by_alias, addresses_by_pkh,
managers)
# hello state
command = input("{} >".format(messages['hello'])).strip()
start()
while not fsm.is_finished():
sleep(0.1)
command = input("{} >\n".format(messages[fsm.current])).strip()
callbacks[fsm.current](command)
pass
parser.validate()
parser.process()
cfg_dict = parser.get_conf_obj()
# dictionary to BakingConf object, for a bit of type safety
cfg = BakingConf(cfg_dict, master_cfg)
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=True, indent=4)
print("Configuration file is created at '{}'".format(config_file_path))
def test_validate_empty(self):
data_fine = """
version : 1.0
baking_address : tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
payment_address : KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj
service_fee : 4.5
founders_map : {}
owners_map : {}
specials_map : {}
supporters_set : {}
min_delegation_amt : 0
"""
managers = {
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj',
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj':
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj'
}
contr_dict_by_alias = {}
addr_dict_by_pkh = {
"tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {
"pkh": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj",
"originated": False,
"alias": "main1",
"sk": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"
},
"KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj": {
"pkh": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj",
"originated": True,
"alias": "kt1",
"sk": True,
"manager": "tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj"
}
}
wallet_client_manager = WalletClientManager(
client_path=None,
addr_dict_by_pkh=addr_dict_by_pkh,
contr_dict_by_alias=contr_dict_by_alias,
managers=managers)
cnf_prsr = BakingYamlConfParser(data_fine,
wallet_client_manager,
network_config=network)
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'),
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address_pkh'),
'KT1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address_manager'),
'tz1Z1tMai15JWUWeN2PKL9faXXVPMuWamzJj')
self.assertEqual(cnf_prsr.get_conf_obj_attr('payment_address_type'),
AddrType.KT)
self.assertEqual(0, cnf_prsr.get_conf_obj_attr('min_delegation_amt'))
self.assertEqual(cnf_prsr.get_conf_obj_attr('supporters_set'), set())