def get_file(self) -> str:
ce = Cleos(url=eos_endpoint)
dir_l = self.get_dir()
if dir_l == {}:
return ''
if self.file_name in dir_l.keys():
head_block = dir_l[self.file_name]
print(head_block)
out = {}
n_block = head_block
r_data = ''
while n_block != 0:
actions = ce.get_actions(self.account, pos=n_block, offset=0)
if 'actions' in actions.keys():
out = actions['actions']
for s in out:
memo_l = (s['action_trace']['act']['data']['memo'])
memo_d = json.loads(memo_l)
r_data = memo_d['data'] + r_data
n_block = memo_d['next_block']
print('next_block is: ', n_block)
#print(r_data)
dec_data = self.__decode_str(r_data)
#print(dec_data)
fb = open(f'{self.path}/{self.file_name}', 'wb')
fb.write(dec_data)
fb.close()
else:
return ''
def __get_last_actions(self, depth: int):
out = {}
ce = Cleos(url=eos_endpoint)
actions = ce.get_actions(self.account, pos=-1, offset=-depth)
if 'actions' in actions.keys():
out = actions['actions']
memos = []
for s in out:
receiver = s['action_trace']['receipt']['receiver']
data = s['action_trace']['act']['data']
if s['action_trace']['act']['name'] == 'transfer' \
and receiver == self.account \
and 'to' in data.keys() \
and data['to'] == self.account \
and 'from' in data.keys() \
and 'quantity' in data.keys() \
and (data['quantity'].find('EOS') != -1 or data['quantity'].find('KNYGA') != -1):
data['recv_sequence'] = s['action_trace']['receipt'][
'recv_sequence']
data['account'] = s['action_trace']['act']['account']
block_n = s['account_action_seq']
data['block_num'] = block_n
data['glob_num'] = s['block_num']
memos.append(data)
memos.reverse()
return memos
def __send_block(self, memo: str):
ce = Cleos(url=eos_endpoint)
arguments = {
"from": self.sender_account, # sender
"to": self.account, # receiver
"quantity": '0.0001 EOS', # In Token
"memo": memo,
}
payload = {
"account":
'eosio.token',
"name":
'transfer',
"authorization": [{
"actor": self.sender_account,
"permission": 'active',
}],
}
# Converting payload to binary
data = ce.abi_json_to_bin(payload['account'], payload['name'],
arguments)
# Inserting payload binary form as "data" field in original payload
payload['data'] = data['binargs']
# final transaction formed
trx = {"actions": [payload]}
import datetime as dt
trx['expiration'] = str(
(dt.datetime.utcnow() +
dt.timedelta(seconds=60)).replace(tzinfo=pytz.UTC))
key = eospy.keys.EOSKey(self.sender_privat_key)
resp = ce.push_transaction(trx, key, broadcast=True)
if ('transaction_id' in resp.keys()):
return resp
else:
return ''
def send_tokens(token, account_to, quantity, memo):
contract_accounts = {'EOS': 'eosio.token', 'KNYGA': 'knygarium111'}
ce = Cleos(url=eos_endpoint)
arguments = {
"from": bartender_account, # sender
"to": account_to, # receiver
"quantity": str(quantity) + ' ' + token, # In Token
"memo": memo,
}
payload = {
"account": contract_accounts[token],
"name": 'transfer',
"authorization": [{
"actor": bartender_account,
"permission": 'active',
}],
}
# Converting payload to binary
data = ce.abi_json_to_bin(payload['account'], payload['name'], arguments)
# Inserting payload binary form as "data" field in original payload
payload['data'] = data['binargs']
# final transaction formed
trx = {"actions": [payload]}
import datetime as dt
trx['expiration'] = str(
(dt.datetime.utcnow() +
dt.timedelta(seconds=60)).replace(tzinfo=pytz.UTC))
key = eospy.keys.EOSKey(active_privat_key)
resp = ce.push_transaction(trx, key, broadcast=True)
return 'transaction_id' in resp.keys()
def get_user(ecosys_key, key):
cleos = Cleos(url='https://chain.wax.io')
ecosystems = cleos.get_table(code=CONTRACT_ACCOUNT,
scope=CONTRACT_SCOPE,
table=ECOSYSTEMS_TABLE,
lower_bound=ecosys_key,
upper_bound=ecosys_key,
limit=1,
timeout=30)
ecosystem = ecosystems.get('rows', [])[0]
user = ecosystem.get('users')[int(key)]
# Get all of this User's granted Achievements
achievements = []
grants_categories = user.bycategory
for (category_id, achievements_list) in grants_categories.iteritems():
userachievements = achievements_list.userachievements
for userachievement in userachievements:
achievements.append((ecosystem.get('categories')[category_id].get(
'achievements')[userachievement.get('achievement_id')],
userachievement.get('timestamp')))
return render_template('user.html',
ecosystem=ecosystem,
achievements=achievements)
def get_EOS_balance(account):
ce = Cleos(url=eos_endpoint)
EOS_balance_list = ce.get_currency_balance(account)
if EOS_balance_list:
EOS_balance = float(EOS_balance_list[0].split(' ')[0])
else:
EOS_balance = 0
return EOS_balance
def get_last(self):
out = {}
ce = Cleos(url=eos_endpoint)
# actions = ce.get_actions(self.account, pos=-1, offset=-depth)
actions = ce.get_actions(self.account, pos=6940, offset=1)
print(actions)
if 'actions' in actions.keys():
out = actions['actions']
def __init__(self, config):
self.config = config
self.cleos = Cleos(url=config.eosurl)
self.nodes = {}
self.pull_metagraph()
self.attributions = [(config.identity, 1.0)]
# TODO(shibshib) this should be our own key. NOT EOSMAIN.
self.eoskey = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"
def check_account_accessability(account_name):
ce = Cleos(url='https://jungle2.cryptolions.io:443')
try:
response = ce.get_account(account_name)
if response:
return False
except requests.exceptions.HTTPError:
return True
def index():
cleos = Cleos(url='https://chain.wax.io')
ecosystems = cleos.get_table(code=CONTRACT_ACCOUNT,
scope=CONTRACT_SCOPE,
table=ECOSYSTEMS_TABLE,
limit=100,
timeout=30)
return render_template('index.html', ecosystems=ecosystems.get('rows', []))
def get_KNYGA_balance(account):
ce = Cleos(url=eos_endpoint)
KNYGA_balance_list = ce.get_currency_balance(account,
code='knygarium111',
symbol='KNYGA')
if KNYGA_balance_list:
KNYGA_balance = float(KNYGA_balance_list[0].split(' ')[0])
else:
KNYGA_balance = 0
return KNYGA_balance
def get_EOS_balance(account):
ce = Cleos(url=eos_endpoint)
try:
EOS_balance_list = ce.get_currency_balance(account)
EOS_balance = float(EOS_balance_list[0].split(' ')[0])
except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError,
requests.exceptions.ReadTimeout, json.decoder.JSONDecodeError):
print("Can't get EOS balance")
EOS_balance = float(0)
return EOS_balance
def get_ecosystem():
cleos = Cleos(url=settings.WAX_URL)
ecosystems = cleos.get_table(code=settings.WAX_CONTRACT,
scope=settings.WAX_CONTRACT,
table='ecosystems',
lower_bound=settings.WAXBADGES_ECOSYSTEM_ID,
upper_bound=settings.WAXBADGES_ECOSYSTEM_ID,
limit=1,
timeout=30)
return ecosystems.get('rows', [])[0]
def bpinfos():
logger = reactive_log('getBPs')
url_index = test_net_is_working(BOS_URLS)
logger.info('BOS Node [' + str(url_index) + '] is working:' +
BOS_URLS[url_index])
ce = Cleos(url=BOS_URLS[url_index])
result = json.dumps({'producer': ce.get_producers()['rows']})
resp = flask.Response(result)
resp.headers['Access-Control-Allow-Origin'] = '*'
return resp
def get_KNYGA_balance(account):
ce = Cleos(url=eos_endpoint)
try:
KNYGA_balance_list = ce.get_currency_balance(account,
code='knygarium111',
symbol='KNYGA')
KNYGA_balance = float(KNYGA_balance_list[0].split(' ')[0])
except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError,
requests.exceptions.ReadTimeout, json.decoder.JSONDecodeError):
print("Can't get KNYGA balance")
KNYGA_balance = float(0)
return KNYGA_balance
def test_net_is_working(urls):
url_index = -1
for i in (0, len(urls) - 1):
ce = Cleos(url=urls[i])
try:
info = ce.get_info()
# print(info)
if info != None:
url_index = i
break
except Exception as err:
print(err)
return url_index
def createTestAccounts():
ce = Cleos(url='http://127.0.0.1:8888')
# use a string or EOSKey for push_transaction
key = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"
# use EOSKey:
# import eospy.keys
# key = eospy.keys.EOSKey('5HuaTWKeGzZhqyzuzFAjjFjPnnnjdgcp562oBSS8Wv1qgDSkR2W')
resp = ce.create_account('eosio', key, 'testtesttest', 'EOS5YMv2UBcuiExv1C8fZjjnE4evofRdBh5Nrt8TYz44G7KC5tZNq', 'EOS5YMv2UBcuiExv1C8fZjjnE4evofRdBh5Nrt8TYz44G7KC5tZNq', permission='active', transfer=False, broadcast=True)
print('------------------------------------------------')
print(resp)
print('------------------------------------------------')
def get_ecosystem(key):
cleos = Cleos(url='https://chain.wax.io')
ecosystems = cleos.get_table(code=CONTRACT_ACCOUNT,
scope=CONTRACT_SCOPE,
table=ECOSYSTEMS_TABLE,
lower_bound=key,
upper_bound=key,
limit=1,
timeout=30)
ecosystem = ecosystems.get('rows', [])[0]
print(ecosystem)
return render_template('ecosys.html', ecosystem=ecosystem)
def send_tokens(token, account_to, quantity, memo):
# contract_accounts = {'EOS': 'eosio.token', 'KNYGA': 'knygarium111'}
contract_accounts = {
'TNT': 'eosio.token',
'EOS': 'eosio.token',
'KNYGA': 'knygarium111'
}
ce = Cleos(url=eos_endpoint)
quantity_str = str(quantity)
qs_start = quantity_str[:quantity_str.find('.')]
qs_end = quantity_str[quantity_str.find('.'):]
needs_0 = 5 - len(qs_end)
if needs_0 < 0:
qs_end = qs_end[:5]
n = 0
while n < needs_0:
n += 1
qs_end = qs_end + '0'
quantity_str = qs_start + qs_end
arguments = {
"from": bartender_account, # sender
"to": account_to, # receiver
"quantity": quantity_str + ' ' + token, # In Token
"memo": memo,
}
payload = {
"account": contract_accounts[token],
"name": 'transfer',
"authorization": [{
"actor": bartender_account,
"permission": 'active',
}],
}
# Converting payload to binary
data = ce.abi_json_to_bin(payload['account'], payload['name'], arguments)
# Inserting payload binary form as "data" field in original payload
payload['data'] = data['binargs']
# final transaction formed
trx = {"actions": [payload]}
import datetime as dt
trx['expiration'] = str(
(dt.datetime.utcnow() +
dt.timedelta(seconds=60)).replace(tzinfo=pytz.UTC))
key = eospy.keys.EOSKey(active_privat_key)
resp = ce.push_transaction(trx, key, broadcast=True)
if ('transaction_id' in resp.keys()):
return float(quantity_str)
else:
return 0
def send_tokens(self, account_to: str, amount: float, token: str,
memo: str):
ce = Cleos(url=self._api_endpoint)
quantity_str = str(float(amount))
qs_start = quantity_str[:quantity_str.find('.')]
qs_end = quantity_str[quantity_str.find('.'):]
needs_0 = 5 - len(qs_end)
if needs_0 < 0:
qs_end = qs_end[:5]
n = 0
while n < needs_0:
n += 1
qs_end = qs_end + '0'
quantity_str = qs_start + qs_end
arguments = {
"from": self._account, # sender
"to": account_to, # receiver
"quantity": quantity_str + ' ' + token, # In Token
"memo": memo,
}
payload = {
"account": self._currencies[token],
"name": 'transfer',
"authorization": [{
"actor": self._account,
"permission": 'active',
}],
}
data = ce.abi_json_to_bin(payload['account'], payload['name'],
arguments)
# Inserting payload binary form as "data" field in original payload
payload['data'] = data['binargs']
# final transaction formed
trx = {"actions": [payload]}
import datetime as dt
trx['expiration'] = str(
(dt.datetime.utcnow() +
dt.timedelta(seconds=60)).replace(tzinfo=pytz.UTC))
key = eospy.keys.EOSKey(self._active_privat_key)
resp = ce.push_transaction(trx, key, broadcast=True)
if 'transaction_id' in resp.keys():
print(
f'{quantity_str} {token} sent to {account_to} with memo: {memo}'
)
return float(quantity_str)
else:
print(f'error sending {quantity_str} {token} to {account_to}')
return 0
def find_user(ecosys_key, userid):
cleos = Cleos(url='https://chain.wax.io')
ecosystems = cleos.get_table(code=CONTRACT_ACCOUNT,
scope=CONTRACT_SCOPE,
table=ECOSYSTEMS_TABLE,
lower_bound=ecosys_key,
upper_bound=ecosys_key,
limit=1,
timeout=30)
ecosystem = ecosystems.get('rows', [])[0]
for (key, user) in enumerate(ecosystem.users):
if user.userid == userid:
return key
return None
def eos(self) -> Cleos:
"""Returns an instance of Cleos and caches it in the attribute _eos after creation"""
if not self._eos:
log.debug(
f'Creating Cleos instance using EOS API node: {self.url}')
self._eos = Cleos(url=self.url)
return self._eos
def replace_eos(self, **conn) -> Cleos:
"""
Destroy the EOS :class:`.Cleos` instance at :py:attr:`._eos` and re-create it with the modified
connection settings ``conn``
Also returns the EOS instance for convenience.
Only need to specify settings you want to override.
Example::
>>> eos = self.replace_eos(host='example.com', port=80, ssl=False)
>>> eos.get_account('someguy123')
:param conn: Connection settings. Keys: endpoint, ssl, host, port, username, password
:return Cleos eos: A :class:`.Cleos` instance with the modified connection settings.
"""
del self._telos
url = self._make_url(**conn)
log.debug('Replacing Cleos instance with new Telos API node: %s', url)
self.current_rpc = url
self._telos = Cleos(url=url)
return self._telos
def create_eos_acc(account_name, activekey, ownerkey):
ce = Cleos(url='https://jungle2.cryptolions.io:443')
key = config.EOS_PRIVATE_KEY
response = ce.create_account(config.CREATOR,
key,
account_name,
activekey,
ownerkey,
stake_net='0.1000 EOS',
stake_cpu='0.1000 EOS',
ramkb=4,
permission='active',
transfer=True,
broadcast=True)
return response['transaction_id']
def eos(self) -> Cleos:
"""Returns an instance of Cleos and caches it in the attribute :py:attr:`._telos` after creation"""
if not self._telos:
log.debug(
f'Creating Cleos instance using Telos API node: {self.url}')
self.current_rpc = self.url
self._telos = Cleos(url=self.url)
return self._telos
def eos(self) -> Cleos:
"""Returns an instance of Cleos and caches it in the attribute _eos after creation"""
if not self._eos:
log.debug(
f'Creating Cleos instance using {self.chain.upper()} API node: {self.url}'
)
self.current_rpc = self.url
self._eos = Cleos(url=self.url)
return self._eos
def get_achievement(ecosys_key, cat_key, key):
cleos = Cleos(url='https://chain.wax.io')
ecosystems = cleos.get_table(code=CONTRACT_ACCOUNT,
scope=CONTRACT_SCOPE,
table=ECOSYSTEMS_TABLE,
lower_bound=ecosys_key,
upper_bound=ecosys_key,
limit=1,
timeout=30)
ecosystem = ecosystems.get('rows', [])[0]
achievement = ecosystem.get('categories')[int(cat_key)].get(
'achievements')[int(key)]
achievement['key'] = int(key)
if achievement['maxquantity'] == 0:
achievement['num_available'] = 'unlimited'
achievement['maxquantity'] = 'unlimited'
else:
achievement['num_available'] = achievement['maxquantity'] - len(
achievement.get('usergrants', []))
users = []
for usergrant in achievement.get('usergrants'):
user = ecosystem.get('users')[usergrant.get('user_id')]
if not user.get('avatarurl').startswith('http'):
user['avatarurl'] = ecosystem.get('baseasseturl') + "/" + user.get(
'avatarurl')
user['user_id'] = usergrant.get('user_id')
print(user)
users.append({
"user":
user,
"timestamp":
datetime.utcfromtimestamp(usergrant.get('timestamp')),
})
return render_template('ach.html',
ecosystem=ecosystem,
category_id=cat_key,
achievement=achievement,
usergrants=users)
def create_eos_account(request):
account_name = request.data['account_name']
owner_key = request.data['owner_key']
active_key = request.data['active_key']
ce = Cleos(url='https://jungle2.cryptolions.io:443')
resp = ce.create_account('eosio',
PRIVATE_KEY,
account_name,
owner_key,
active_key,
stake_net='1.0000 EOS',
stake_cpu='1.0000 EOS',
ramkb=8,
permission='active',
transfer=False,
broadcast=True)
return Response('ok')
def refund(action, amount, memo):
ce = Cleos(url=eos_endpoint)
quantity_str = str(amount)
qs_start = quantity_str[:quantity_str.find('.')]
qs_end = quantity_str[quantity_str.find('.'):]
needs_0 = 5 - len(qs_end)
if needs_0 < 0:
qs_end = qs_end[:5]
n = 0
while n < needs_0:
n += 1
qs_end = qs_end + '0'
quantity_str = qs_start + qs_end
arguments = {
"from": action['to'], # sender
"to": action['from'], # receiver
"quantity":
quantity_str + ' ' + action['quantity'].split(' ')[1], # In Token
"memo": memo,
}
payload = {
"account": action['account'],
"name": 'transfer',
"authorization": [{
"actor": bartender_account,
"permission": 'active',
}],
}
# Converting payload to binary
data = ce.abi_json_to_bin(payload['account'], payload['name'], arguments)
# Inserting payload binary form as "data" field in original payload
payload['data'] = data['binargs']
# final transaction formed
trx = {"actions": [payload]}
import datetime as dt
trx['expiration'] = str(
(dt.datetime.utcnow() +
dt.timedelta(seconds=60)).replace(tzinfo=pytz.UTC))
key = eospy.keys.EOSKey(active_privat_key)
resp = ce.push_transaction(trx, key, broadcast=True)
return 'transaction_id' in resp.keys()
def grant_achievement(category_id, achievement_id, user_id):
cleos = Cleos(url=settings.WAX_URL)
# void grantach(name ecosystem_owner, uint32_t ecosystem_id, uint32_t user_id, uint32_t category_id, uint32_t achievement_id, uint32_t timestamp)
arguments = {
"ecosystem_owner": settings.WAX_ACCOUNT_NAME,
"ecosystem_id": settings.WAXBADGES_ECOSYSTEM_ID,
"user_id": user_id,
"category_id": category_id,
"achievement_id": achievement_id,
"timestamp": math.trunc(time.time())
}
payload = {
"account":
settings.WAX_CONTRACT,
"name":
"grantach",
"authorization": [{
"actor": settings.WAX_ACCOUNT_NAME,
"permission": "active",
}],
}
#Converting payload to binary
data = cleos.abi_json_to_bin(payload['account'], payload['name'],
arguments)
#Inserting payload binary form as "data" field in original payload
payload['data'] = data['binargs']
#final transaction formed
trx = {"actions": [payload]}
trx['expiration'] = str(
(dt.datetime.utcnow() +
dt.timedelta(seconds=60)).replace(tzinfo=pytz.UTC))
key = eospy.keys.EOSKey(settings.WAX_PRIVATE_KEY)
resp = cleos.push_transaction(trx, key, broadcast=True)
return resp
