from time import sleep
from requests import ReadTimeout, ConnectTimeout
from Constants import MUTEZ, RunMode
from api.provider_factory import ProviderFactory
from calc.phased_payment_calculator import PhasedPaymentCalculator
from exception.api_provider import ApiProviderException
from log_config import main_logger, get_verbose_log_helper
from model.reward_log import RewardLog
from model.rules_model import RulesModel
from pay.double_payment_check import check_past_payment
from pay.payment_batch import PaymentBatch
from pay.payment_producer_abc import PaymentProducerABC
from pay.retry_producer import RetryProducer
from util.dir_utils import get_calculation_report_file, get_latest_report_file
logger = main_logger.getChild("payment_producer")
BOOTSTRAP_SLEEP = 8
class PaymentProducer(threading.Thread, PaymentProducerABC):
def __init__(self,
name,
initial_payment_cycle,
network_config,
payments_dir,
calculations_dir,
run_mode,
service_fee_calc,
release_override,
payment_offset,
TYPE_FOUNDER,
TYPE_OWNER,
TYPE_DELEGATOR,
)
from pay.batch_payer import BatchPayer
from util.disk_is_full import disk_is_full
from stats.stats_publisher import stats_publisher
from util.csv_payment_file_parser import CsvPaymentFileParser
from util.csv_calculation_file_parser import CsvCalculationFileParser
from util.dir_utils import (
get_payment_report_file_path,
get_calculation_report_file_path,
get_busy_file,
)
logger = main_logger.getChild("payment_consumer")
def count_and_log_failed(payment_logs):
nb_paid = nb_failed = nb_injected = 0
for pymnt_itm in payment_logs:
if pymnt_itm.paid == PaymentStatus.PAID:
nb_paid += 1
elif pymnt_itm.paid == PaymentStatus.FAIL:
nb_failed += 1
elif pymnt_itm.paid == PaymentStatus.INJECTED:
nb_injected += 1
return nb_paid, nb_failed, nb_injected
TOF,
TOB,
TOE,
EXCLUDED_DELEGATORS_SET_TOB,
EXCLUDED_DELEGATORS_SET_TOE,
EXCLUDED_DELEGATORS_SET_TOF,
DEST_MAP,
PLUGINS_CONF,
DEXTER,
CONTRACTS_SET,
REWARDS_TYPE,
)
from util.address_validator import AddressValidator
from util.fee_validator import FeeValidator
logger = main_logger.getChild("config_parser")
PKH_LENGHT = 36
class BakingYamlConfParser(YamlConfParser):
def __init__(
self,
yaml_text,
clnt_mngr,
provider_factory,
network_config,
node_url,
block_api=None,
api_base_url=None,
) -> None:
import requests
from api.block_api import BlockApi
from exception.api_provider import ApiProviderException
from log_config import main_logger
logger = main_logger.getChild("rpc_block_api")
COMM_HEAD = "{}/chains/main/blocks/head"
COMM_REVELATION = "{}/chains/main/blocks/head/context/contracts/{}/manager_key"
class RpcBlockApiImpl(BlockApi):
def __init__(self, nw, node_url):
super(RpcBlockApiImpl, self).__init__(nw)
self.node_url = node_url
logger.debug("RpcBlockApiImpl - node_url {}".format(self.node_url))
def get_current_level(self, verbose=False):
try:
response = requests.get(COMM_HEAD.format(self.node_url), timeout=5)
head = response.json()
current_level = int(head["metadata"]["level"]["level"])
return current_level
except requests.exceptions.RequestException as e:
message = "[RpcBlockApiImpl] - Unable to fetch /head: {:s}".format(
str(e))
logger.error(message)
raise ApiProviderException(message)
def get_revelation(self, pkh, verbose=False):
try:
from time import sleep
import requests
from http import HTTPStatus
from api.reward_api import RewardApi
from exception.api_provider import ApiProviderException
from log_config import main_logger, verbose_logger
from model.reward_provider_model import RewardProviderModel
from Dexter import dexter_utils as dxtz
from Constants import MAX_SEQUENT_CALLS
logger = main_logger.getChild("rpc_reward_api")
# RPC constants
COMM_HEAD = "{}/chains/main/blocks/head"
COMM_DELEGATES = "{}/chains/main/blocks/{}/context/delegates/{}"
COMM_BLOCK = "{}/chains/main/blocks/{}"
COMM_BLOCK_METADATA = "{}/chains/main/blocks/{}/metadata"
COMM_BLOCK_OPERATIONS = "{}/chains/main/blocks/{}/operations"
COMM_SNAPSHOT = COMM_BLOCK + "/context/raw/json/cycle/{}/roll_snapshot"
COMM_DELEGATE_BALANCE = "{}/chains/main/blocks/{}/context/contracts/{}/balance"
COMM_CONTRACT_STORAGE = "{}/chains/main/blocks/{}/context/contracts/{}/storage"
COMM_BIGMAP_QUERY = "{}/chains/main/blocks/{}/context/big_maps/{}/{}"
COMM_BAKING_RIGHTS = (
"{}/chains/main/blocks/{}/helpers/baking_rights?cycle={}&delegate={}"
)
COMM_ENDORSING_RIGHTS = (
"{}/chains/main/blocks/{}/helpers/endorsing_rights?cycle={}&delegate={}"
)
COMM_FROZEN_BALANCE = (
import functools
from calc.calculate_phase0 import CalculatePhase0
from calc.calculate_phase1 import CalculatePhase1
from calc.calculate_phase2 import CalculatePhase2
from calc.calculate_phase3 import CalculatePhase3
from calc.calculate_phase4 import CalculatePhase4
from calc.calculate_phase_final import CalculatePhaseFinal
from model.reward_log import (
TYPE_FOUNDERS_PARENT,
TYPE_OWNERS_PARENT,
cmp_by_type_balance,
)
from log_config import main_logger
logger = main_logger.getChild("phased_calculator")
MINOR_DIFF = 10
MINOR_RATIO_DIFF = 1e-6
class PhasedPaymentCalculator:
"""
-- Phase0 : Provider Phase
-- Phase1 : Total Rewards Phase
-- Phase2 : Ratios Phase
-- Phase3 : Founders Phase
-- Phase4 : Split Phase
-- Phase5 : Mapping Phase
-- Phase6 : Merge Phase --
-- Phase Last : Payment Phase
from tzkt.tzkt_api import TzKTApi, TzKTApiError
from api.block_api import BlockApi
from log_config import main_logger
logger = main_logger.getChild("tzkt_block_api")
class TzKTBlockApiImpl(BlockApi):
def __init__(self, nw, base_url=None):
super(TzKTBlockApiImpl, self).__init__(nw)
if base_url is None:
self.api = TzKTApi.from_network(nw["NAME"])
else:
self.api = TzKTApi.from_url(base_url)
def get_current_cycle_and_level(self) -> (int, int):
"""
Get head cycle and level
:returns: 0
"""
head = self.api.get_head()
if not head.get("synced"):
raise TzKTApiError("Not synced")
current_cycle = int(head["cycle"])
current_level = int(head["level"])
return (current_cycle, current_level)
def get_revelation(self, pkh, verbose=False):
account = self.api.get_account_by_address(pkh)
