def apply(receiver, code, action):
if action == N('sayhello'):
from hello import sayhello
sayhello.sayHello('mike')
elif action == N('setcode'):
data = read_action()
# print(struct.unapck)
code_account, code_name, code_type = struct.unpack('QQB', data[:17])
src_code = eoslib.unpack_bytes(data[17:])
eoslib.set_code_ext(code_account, 1, code_name, src_code)
elif action == N('auth'):
data = read_action()
code_owner, code_name, auth_to = struct.unpack('QQQ', data)
code = N('eosio.code')
scope = code
itr = db.find_i64(code, code_owner, auth_to, code_name)
print(itr)
if itr >= 0:
return
payer = code_owner
db.store_i64(code_owner, auth_to, payer, code_name, b'1')
elif action == N('unauth'):
data = read_action()
code_owner, code_name, auth_to = struct.unpack('QQQ', data)
code = N('eosio.code')
scope = code
itr = db.find_i64(code, code_owner, auth_to, code_name)
if itr >= 0:
db.remove_i64(itr)
elif action == N('import'):
from eosio.code import hello
def deploy_mpy():
src_dir = os.path.dirname(os.path.abspath(__file__))
code = eosapi.N('backyard')
for file_name in libs:
print('deploy ', file_name)
src_code = eosapi.mp_compile(os.path.join(src_dir, file_name))
file_name = file_name.replace('.py', '.mpy')
src_id = eosapi.hash64(file_name, 0)
itr = db.find_i64(code, code, code, src_id)
if itr >= 0:
#Something went wrong in mp_compile.
#Generating different bytecode each time with the same source code, walkaround this problem for now
continue
old_src = db.get_i64(itr)
if old_src[1:] == src_code:
continue
mod_name = file_name
msg = int.to_bytes(len(mod_name), 1, 'little')
msg += mod_name.encode('utf8')
msg += int.to_bytes(1, 1, 'little') # compiled python bytecode
msg += src_code
print('++++++++++++++++deply:', file_name)
r = eosapi.push_action('backyard','deploy',msg,{'backyard':'active'})
assert r
def load(self):
it = db.find_i64(self.code, self.scope, self.table_id,
self.get_primary_key())
if it >= 0:
data = db.get_i64(it)
return self.unpack(data)
return False
def __init__(self, _code, table_id=None, value_type=None):
self.code = _code
self._dict = {}
if table_id:
self.table_id = table_id
else:
SList.table_counter += 1
table_id = hash64('list.%d' % (SList.table_counter, ))
# print('current_receiver:', n2s(code))
self.list_size_id = hash64('list.size%d')
itr = db.find_i64(self.code, self.code, table_id, self.list_size_id)
if itr >= 0:
self.list_size = db.get_i64(itr)
self.list_size = int.from_bytes(self.list_size, 'little')
else:
self.list_size = 0
self.value_type = value_type
itr = db.end_i64(self.code, self.code, table_id)
if itr == -1: #no value in table
return
def apply(receiver, code, action):
print(n2s(code), n2s(action))
if action == N('deploy'):
require_auth(code)
msg = read_action()
print('++++++len(msg):', len(msg))
scope = int.from_bytes(msg[:8], 'little')
table = int.from_bytes(msg[8:16], 'little')
id = int.from_bytes(msg[16:24], 'little')
data = msg[24:]
deploy(scope, table, id, data)
elif action == N('delete'):
require_auth(code)
vm_name = read_action()
vm_name = int.from_bytes(vm_name, 'little')
itr = db.find_i64(code, code, code, vm_name)
print('+++++++++++:', itr)
if itr >= 0:
db.remove_i64(itr)
while True:
itr = db.end_i64(code, code, vm_name)
print('+++++++++++ end_i64 :', itr)
if itr == -1:
break
itr, primary = db.previous_i64(itr)
print('+++++++++++ previous_i64 :', itr)
db.remove_i64(itr)
def deploy(account, src_code):
code = N('native')
print('++++++++++++deploy:account', account)
itr = db.find_i64(code, code, code, account)
if itr < 0:
db.store_i64(code, code, code, account, src_code)
else:
db.update_i64(itr, code, src_code)
def deploy(mod_name, src_code):
code = N('kitties')
print('++++++++++++deploy:mod_name', mod_name)
id = hash64(mod_name)
itr = db.find_i64(code, code, code, id)
if itr < 0:
db.store_i64(code, code, code, id, src_code)
else:
db.update_i64(itr, code, src_code)
if mod_name.endswith('.mpy'):
#try to remove py source to prevent micropython loading the wrong source
mod_name = mod_name[:-3] + 'py'
id = hash64(mod_name)
itr = db.find_i64(code, code, code, id)
if itr >= 0:
db.remove_i64(itr)
def store(self, payer):
it = db.find_i64(self.code, self.scope, self.table_id,
self.get_primary_key())
if it >= 0:
db.update_i64(it, payer, self.pack())
else:
db.store_i64(self.scope, self.table_id, payer,
self.get_primary_key(), self.pack())
def remove(self, index):
print('+++append:', value)
itr = db.find_i64(self.code, self.scope, self.table_id, index)
if itr <= 0:
raise Exception('index not found', index)
db.remove_i64(itr)
self.count -= 1
print('+++append return:', self.count)
def load(key):
id = get_hash(key)
itr = db.find_i64(receiver, receiver, g_table_id, id)
value = None
if itr >= 0:
value = db.get_i64(itr)
return from_raw_value(value)
return None
def update_size(self):
_value = int.to_bytes(self.list_size, 4, 'little')
itr = db.find_i64(self.code, self.code, self.table_id,
self.list_size_id)
if itr < 0:
db.store_i64(self.code, self.table_id, self.code,
self.list_size_id, _value)
else:
db.update_i64(itr, self.code, _value)
def deploy(scope, table, id, data):
code = N('vmstore')
payer = code
print('++++++++++++deploy:scope', n2s(scope), n2s(table))
itr = db.find_i64(code, scope, table, id)
if itr < 0:
db.store_i64(scope, table, payer, id, data)
else:
db.update_i64(itr, payer, data)
def store(key, value):
id = get_hash(key)
value = to_raw_value(value)
code = contract_owner
itr = db.find_i64(receiver, receiver, g_table_id, id)
if itr >= 0:
value = db.update_i64(itr, receiver, value)
else:
db.store_i64(receiver, g_table_id, receiver, id, value)
def __getitem__(self, index):
if index < 0 or index >= self.count:
raise IndexError('list index out of range')
print('index', index)
itr = db.find_i64(self.code, self.scope, self.table_id, index)
if itr < 0:
raise Exception('index not found!')
print('index', index, 'it', itr)
value = db.get_i64(itr)
return self.unpack(value)
def test2(count=100):
import time
import json
code = N('counter')
counter_id = N('counter')
counter_begin = 0
itr = db.find_i64(code, code, code, counter_id)
if itr >= 0:
counter_begin = db.get_i64(itr)
counter_begin = int.from_bytes(counter_begin, 'little')
print('counter begin: ', counter_begin)
actions = []
for i in range(count):
action = ['hello', 'sayhello', {'hello':'active'}, str(i)]
actions.append(action)
ret, cost = eosapi.push_actions(actions, True)
assert ret
print('total cost time:%.3f s, cost per action: %.3f ms, actions per second: %.3f'%(cost/1e6, cost/count/1000, 1*1e6/(cost/count)))
eosapi.produce_block()
actions = []
for i in range(count):
action = ['counter', 'count', {'counter':'active'}, str(i)]
actions.append(action)
ret, cost = eosapi.push_actions(actions, True)
assert ret
print('total cost time:%.3f s, cost per action: %.3f ms, actions per second: %.3f'%(cost/1e6, cost/count/1000, 1*1e6/(cost/count)))
eosapi.produce_block()
counter_end = 0
itr = db.find_i64(code, code, code, counter_id)
if itr >= 0:
counter_end = db.get_i64(itr)
counter_end = int.from_bytes(counter_end, 'little')
print('counter end: ', counter_end)
assert counter_begin + count == counter_end
def setitem(self, index, val):
id = index
if self.value_type:
_value = self.value_type.pack(val)
else:
_value = self.pack(val)
itr = db.find_i64(self.code, self.code, self.table_id, id)
if itr < 0:
db.store_i64(self.code, self.table_id, self.code, id, _value)
else:
db.update_i64(itr, self.code, _value)
def __getitem__(self, index):
if index < 0 or index >= self.list_size:
raise IndexError('list assignment index out of range')
if index in self._dict:
return self._dict[index]
itr = db.find_i64(self.code, self.code, self.table_id, index)
if itr >= 0:
value = db.get_i64(itr)
value = self.unpack(value)
self._dict[index] = value
return value
raise Exception('unkown error!') # code should never go here!
def count():
code = N('counter')
counter_id = N('counter')
itr = db.find_i64(code, code, code, counter_id)
if itr >= 0: # value exists, update it
counter = db.get_i64(itr)
# print('old counter', int.from_bytes(counter, 'little'))
counter = int.from_bytes(counter, 'little')
counter += 1
counter = int.to_bytes(counter, 4, 'little')
db.update_i64(itr, code, counter)
else:
counter = int.to_bytes(1, 4, 'little')
db.store_i64(code, code, code, counter_id, counter)
itr = db.find_i64(code, code, code, N('msg'))
if itr >= 0: # value exists, update it
counter = db.get_i64(itr)
db.update_i64(itr, code, b'py')
else:
db.store_i64(code, code, code, N('msg'), b'py')
def test(name=None):
code = N('counter')
counter_id = N('counter')
counter_begin = 0
itr = db.find_i64(code, code, code, counter_id)
if itr >= 0:
counter_begin = db.get_i64(itr)
counter_begin = int.from_bytes(counter_begin, 'little')
print('counter begin: ', counter_begin)
with producer:
r = eosapi.push_action('counter', 'count', '', {'counter':'active'})
assert r
counter_end = 0
itr = db.find_i64(code, code, code, counter_id)
if itr >= 0:
counter_end = db.get_i64(itr)
counter_end = int.from_bytes(counter_end, 'little')
print('counter end: ', counter_end)
assert counter_begin + 1 == counter_end
def deploy(mod_name, src_code):
code = N('backyard')
print('++++++++++++deploy:mod_name', mod_name)
id = hash64(mod_name)
itr = db.find_i64(code, code, code, id)
if itr < 0:
db.store_i64(code, code, code, id, src_code)
else:
db.update_i64(itr, code, src_code)
mod_name = mod_name.decode('utf8')
if mod_name.endswith('.mpy'):
__import__('backyard.' + mod_name[:-4])
elif mod_name.endswith('.py'):
__import__('backyard.' + mod_name[:-3])
def sayHello():
n = N('hello')
id = N('name')
name = read_action()
print('hello', name)
code = n
scope = n
table = n
payer = n
itr = db.find_i64(code, scope, table, id)
if itr >= 0: # value exist, update it
old_name = db.get_i64(itr)
print('hello,', old_name)
db.update_i64(itr, payer, name)
else:
db.store_i64(scope, table, payer, id, name)
def test2(count=100):
actions = []
for i in range(count):
action = ['greeter', 'setgreeting', str(i), {'greeter':'active'}]
actions.append(action)
ret, cost = eosapi.push_actions(actions, True)
assert ret
print('total cost time:%.3f s, cost per action: %.3f ms, actions per second: %.3f'%(cost/1e6, cost/count/1000, 1*1e6/(cost/count)))
eosapi.produce_block()
code = eosapi.N('greeter')
id = eosapi.hash64('greeting', 0)
greeting = 0
itr = db.find_i64(code, code, code, id)
if itr >= 0:
greeting = db.get_i64(itr)
print(greeting[1:])
def deploy():
src_dir = os.path.dirname(os.path.abspath(__file__))
code = eosapi.N('backyard')
for file_name in libs:
src_code = open(os.path.join(src_dir, file_name), 'rb').read()
src_id = eosapi.hash64(file_name, 0)
itr = db.find_i64(code, code, code, src_id)
if itr >= 0:
old_src = db.get_i64(itr)
if old_src[1:] == src_code:
continue
mod_name = file_name
msg = int.to_bytes(len(mod_name), 1, 'little')
msg += mod_name.encode('utf8')
msg += int.to_bytes(0, 1, 'little') # source code
msg += src_code
print('++++++++++++++++deply:', file_name)
r = eosapi.push_action('backyard','deploy',msg,{'backyard':'active'})
assert r
producer.produce_block()
def deploy_wast():
src_dir = os.path.dirname(os.path.abspath(__file__))
code = eosapi.N('backyard')
for file_name in ('math.wast',):
print('deploy ', file_name)
bin_code = None
with open(os.path.join(src_dir, file_name), 'rb') as f:
bin_code = eosapi.wast2wasm(f.read())
src_id = eosapi.hash64(file_name, 0)
itr = db.find_i64(code, code, code, src_id)
if itr >= 0:
old_src = db.get_i64(itr)
if old_src[1:] == bin_code:
continue
mod_name = file_name
msg = int.to_bytes(len(mod_name), 1, 'little')
msg += mod_name.encode('utf8')
msg += int.to_bytes(3, 1, 'little')# compiled cpp bytecode
msg += bin_code
print(msg)
print('++++++++++++++++deply:', file_name)
r = eosapi.push_action('backyard','deploy',msg,{'backyard':'active'})
assert r
def erase(self):
it = db.find_i64(self.code, self.scope, self.table_id,
self.get_primary_key())
if it >= 0:
db.remove_i64(it)
def storage_remove(code, table_id, key):
itr = db.find_i64(code, code, table_id, key)
if itr >= 0:
db.remove_i64(itr)
def storage_set(code, table_id, key, value):
itr = db.find_i64(code, code, table_id, key)
if itr >= 0:
db.update_i64(itr, code, value)
else:
db.store_i64(code, table_id, code, key, value)
def storage_find(code, table_id, id):
itr = db.find_i64(code, code, table_id, id)
if itr >= 0:
return db.get_i64(itr)
return None
