def get_current_ethereum_price():
api = 'https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD,JPY,EUR?1eef1b3afe86c87ccb9b43f6a7ed8c4483fc5076e99b0f8cecfcae04f054ec75'
response = requests.get(api)
if response.status_code == 200:
data = common.parse_dictionary(response.content.decode('UTF-8'))
price = data.get('USD')
return price
else:
return ('error in parsing eth price')
def node_peers():
uri = '/eth/v1alpha1/node/peers'
url = base_url+uri
response = requests.get(url)
if response.status_code == 200:
data = response.content.decode('UTF-8')
return common.parse_dictionary(data)
else:
return {}
def get_validator_queue():
try:
uri = '/eth/v1alpha1/validators/queue'
url = base_url+uri
response = requests.get(url)
if response.status_code == 200:
data = response.content.decode('UTF-8')
data = common.parse_dictionary(data)
queue = data.get('activationPublicKeys')
return_data = {
'public_keys' : queue,
'count' : len(queue)
}
return common.send_sucess_msg(return_data)
else:
return common.send_error_msg()
except Exception as e :
error = common.get_error_traceback(sys,e)
print (error)
return common.send_error_msg()
def get_vol_data(args):
time = args.get("time", "")
url = 'https://api.coingecko.com/api/v3/coins/ethereum/market_chart?vs_currency=usd&days=' + time
response = requests.get(url)
if response.status_code == 200:
data = response.content.decode('UTF-8')
data = common.parse_dictionary(data)
total_volumes = data['total_volumes']
count = len(total_volumes)
usdPrice = []
marketcapValue = []
dateTime = []
marketVolume = []
for x in range(count):
timestamp = total_volumes[x][0]
usdvalue = data['prices'][x][1]
capvalue = data['market_caps'][x][1]
volume = data['total_volumes'][x][1]
dt_object = datetime.fromtimestamp(timestamp / 1000)
t = dt_object.strftime('%a,%b %d %Y,%H:%M')
dateTime.append(t)
usdPrice.append(usdvalue)
marketcapValue.append(capvalue)
marketVolume.append(volume)
return_data = {
'dateTime': dateTime,
'volumeUsd': marketVolume,
'marketCapValue': marketcapValue,
'prices': usdPrice
}
return common.send_sucess_msg(return_data)
else:
return common.send_error_msg()
def get_attestion_by_slot(args):
try:
'''
'''
uri = '/eth/v1alpha1/beacon/blocks'
url = base_url+uri
response = http.request(
'GET',
url,
fields={
'slot' : args.get('slot')
}
)
if response.status == 200:
slot_data = response.data.decode('UTF-8')
slot_data = common.parse_dictionary(slot_data)
block_container = slot_data.get('blockContainers')
return_list = []
for single_block_data in block_container:
return_data = {
}
block_data = single_block_data.get('block')
block_detail = block_data.get('block')
return_data['slot'] = block_detail.get('slot')
block_body = block_detail.get('body')
attestians_data = block_body.get('attestations')
return_data['attestations_count'] = len(attestians_data)
attestian_list = []
for single_attestation in attestians_data:
single_attestians_return_data = {
}
single_attestians_return_data['aggregationBits'] = single_attestation.get('aggregationBits')
single_attestians_return_data['signature'] = common.decode_public_key(single_attestation.get('signature'))
single_attestians_data = single_attestation.get('data')
single_attestians_return_data['beaconBlockRoot'] = common.decode_public_key(single_attestians_data.get('beaconBlockRoot'))
single_attestians_return_data['committeeIndex'] = single_attestians_data.get('committeeIndex')
single_attestians_return_data['source_epoch'] = single_attestians_data.get('source').get('epoch')
single_attestians_return_data['source_epoch_root'] = common.decode_public_key(single_attestians_data.get('source').get('root'))
single_attestians_return_data['target_epoch'] = single_attestians_data.get('target').get('epoch')
single_attestians_return_data['target_epoch_root'] = common.decode_public_key(single_attestians_data.get('target').get('root'))
attestian_list.append(single_attestians_return_data)
return_data['attestian_detail'] = attestian_list
return common.send_sucess_msg({'data': return_data})
else:
return common.send_error_msg()
except Exception as e:
error = common.get_error_traceback(sys,e)
print (error)
return common.send_error_msg()
def get_slot_data(slot):
try:
'''
retrives block by slot
A slot is a chance for a block to be added to the Beacon Chain and shards.
'''
uri = '/eth/v1alpha1/beacon/blocks'
url = base_url+uri
response = http.request(
'GET',
url,
fields={
'slot' : slot
}
)
if response.status == 200:
slot_data = response.data.decode('UTF-8')
slot_data = common.parse_dictionary(slot_data)
block_container = slot_data.get('blockContainers')
slot_time = time_calculator.get_slot_time(slot)
if len(block_container) == 0 :
epoch = get_epoch_by_slot(slot)
return_data = [{
'status' : 'skipped',
'slot' : slot,
'epoch' : epoch,
'time' : slot_time
}]
return return_data
return_list = []
for single_block_data in block_container:
return_data = {
'status' : 'proposed',
'time' : slot_time
}
return_data['block_root'] = common.decode_public_key(single_block_data.get('blockRoot'))
block_data = single_block_data.get('block')
return_data['signature'] = common.decode_public_key(block_data.get('signature'))
block_detail = block_data.get('block')
return_data['parent_root'] = common.decode_public_key(block_detail.get('parentRoot'))
return_data['proposer'] = block_detail.get('proposerIndex')
return_data['slot'] = block_detail.get('slot')
return_data['state_root'] = common.decode_public_key(block_detail.get('stateRoot'))
block_body = block_detail.get('body')
return_data['graffiti'] = {
'utf_8' : common.decode_bytes_utf8(block_body.get('graffiti')),
'hex' : common.decode_public_key(block_body.get('graffiti'))
}
return_data['randao_reveal'] = common.decode_public_key(block_body.get('randaoReveal'))
return_data['deposits'] = len(block_body.get('deposits'))
return_data['voluntaryExits'] = len(block_body.get('voluntaryExits'))
return_data['slashing'] = {
'attester' : len(block_body.get('attesterSlashings')),
'proposer' : len(block_body.get('proposerSlashings'))
}
eth1_encoded_data = block_body.get('eth1Data')
return_data['eth1_data'] = {
'block_hash' : common.decode_public_key(eth1_encoded_data.get('blockHash')),
'deposit_count' : eth1_encoded_data.get('depositCount'),
'deposit_root' : common.decode_public_key(eth1_encoded_data.get('depositRoot'))
}
return_data['attestations_count'] = len(block_body.get('attestations'))
epoch = get_epoch_by_slot(slot)
return_data['epoch'] = epoch
return_list.append(return_data)
return return_list
else:
return False
except Exception as e:
error = common.get_error_traceback(sys,e)
print (error)
return False
def get_validators_detail_by_public_key(pubkeyHex):
'''
Validator info by Publick Key
'''
try:
uri = '/eth/v1alpha1/validator/status'
url = base_url+uri
pubkeyB64 = str(common.encode_pubic_key(pubkeyHex[2::]).decode('utf-8'))
validators = http.request(
'GET',
url,
fields={
'publicKey' : pubkeyB64
}
)
if validators.status == 200:
status_data = validators.data.decode('UTF-8')
status_data = common.parse_dictionary(status_data)
return_data = {
'status' : status_data.get('status'),
'activationEpoch' : status_data.get('activationEpoch')
# 'eth1_DepositBlockNumber' : status_data.get('eth1DepositBlockNumber')
}
uri = '/eth/v1alpha1/validators/balances'
url = base_url+uri
response = http.request(
'GET',
url,
fields={
'publicKeys' : pubkeyB64
}
)
if response.status == 200:
balance_data = response.data.decode('UTF-8')
epoch = common.parse_dictionary(balance_data).get('epoch')
balance_data = common.parse_dictionary(balance_data).get('balances')
balance_data = balance_data[0]
balance = int(balance_data.get('balance'))/1000000000
deposits_Received = int(balance_data.get('balance'))/1000000000
deposits_Received = str(round(deposits_Received, 0)) +" ETH"
index = balance_data.get('index')
uri = '/eth/v1alpha1/validator'
url = base_url+uri
validators = http.request(
'GET',
url,
fields={
'index' : index
}
)
if validators.status == 200:
validators = json.loads(validators.data.decode('UTF-8'))
additional_data = {
'publicKey' : common.decode_public_key(validators.get('publicKey')),
'effectiveBalance' : str(int(validators.get('effectiveBalance'))/1000000000) + " ETH",
'slashed' : validators.get('slashed'),
'eligibilityEpoch' : validators.get('activationEligibilityEpoch'),
'withdrawalCredentials' : validators.get('withdrawalCredentials'),
'withdrawableEpoch' : validators.get('withdrawableEpoch')
}
return_data['currentBalance'] = balance
return_data['depositsReceived'] = deposits_Received
return_data['index'] = index
return_data['epoh'] = epoch
return_data['totalIncome'] = round(balance%32,5)
return common.send_sucess_msg(return_data, ** additional_data)
else:
return common.send_error_msg()
except Exception as e:
error = common.get_error_traceback(sys,e)
print (error)
return common.send_error_msg()