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