def load(self):
sizeweights = 0
sizebiases = 0
keys = struct.pack('Q', N('sizeweights'))
values = bytes(8)
if eoslib.load(mnist, mnist, table_network, keys, 0, 0, values) > 0:
sizeweights = int.from_bytes(values, 'little')
if sizeweights <= 0:
return False
keys = struct.pack('Q', N('sizebiases'))
values = bytes(8)
if eoslib.load(mnist, mnist, table_network, keys, 0, 0, values) > 0:
sizebiases = int.from_bytes(values, 'little')
if sizebiases <= 0:
return False
print("+++++++++++++++++", sizeweights, sizebiases)
keys = struct.pack('Q', N('weights'))
values = bytes(sizeweights)
if eoslib.load(mnist, mnist, table_network, keys, 0, 0, values) <= 0:
return False
self.weights = pickle.loads(values)
keys = struct.pack('Q', N('biases'))
values = bytes(sizebiases)
if eoslib.load(mnist, mnist, table_network, keys, 0, 0, values) <= 0:
return False
self.biases = pickle.loads(values)
print('load success!')
return True
def test_ts():
import wallet
from eostypes import PySignedTransaction, PyMessage
import time
print('hello')
ts = PySignedTransaction()
ts.reqire_scope(b'test')
ts.reqire_scope(b'currency')
data = struct.pack("QQQ", N(b'currency'), N(b'test'), 50)
for i in range(10):
msg = PyMessage()
msg.init(b'currency', b'transfer', [[b'currency', b'active']], data)
ts.add_message(msg)
# print('+++++++++++++:',ts.get_messages())
# ret = wallet.sign_transaction(ts)
# print('sign ts return',ret)
# r = eosapi.get_table('test','currency','account')
# print(r)
start = time.time()
eosapi.push_transaction2(ts, True)
print('cost:', time.time() - start)
start = time.time()
with producer:
pass
print('cost:', time.time() - start)
def test_performance():
import wallet
import struct
from eoslib import N
from eostypes import PySignedTransaction, PyMessage
import time
ts = PySignedTransaction()
ts.reqire_scope(b'test')
ts.reqire_scope(b'currency')
data = struct.pack("QQQ", N(b'currency'), N(b'test'), 1)
for i in range(900):
msg = PyMessage()
msg.init(b'currency', b'transfer', [[b'currency',b'active']], data)
ts.add_message(msg)
print('++++ push_transaction2')
start = time.time()
eosapi.push_transaction2(ts, True)
print('cost:',time.time() - start)
print('++++ produce_block')
start = time.time()
with producer:
pass
print('cost:',time.time() - start)
def test2():
with producer:
if not eosapi.get_account('currency'):
r = eosapi.create_account('inita', 'currency', key1, key2)
assert r
if not eosapi.get_account('test'):
if not eosapi.get_account('test'):
r = eosapi.create_account('inita', 'test', key1, key2)
assert r
r = eosapi.set_contract('currency',
'../../contracts/currency/currency.py',
'../../contracts/currency/currency.abi', 1)
start = time.time()
ts = PySignedTransaction()
ts.reqire_scope(b'test')
ts.reqire_scope(b'currency')
for i in range(1):
data = struct.pack("QQQ", N(b'currency'), N(b'test'), 1)
msg = PyMessage()
msg.init(b'currency', b'transfer', [[b'currency', b'active']], data)
ts.add_message(msg)
ctl = chain_controller()
ctl.process_transaction(ts)
r = eosapi.get_table(b'test', b'currency', b'account')
print(r)
print('cost:', time.time() - start)
def apply(receiver, code, action):
# print('++++++apply:', n2s(name))
if action == N('transfer'):
transfer_()
elif action == N('issue'):
issue_()
elif action == N('create'):
create_()
def apply(name, type):
return
# print('++++++apply:', n2s(name))
if type == N('transfer'):
transfer_()
elif type == N('issue'):
issue_()
elif type == N('create'):
create_()
def apply(receiver, code, action):
if action == N('setgreeting'):
greeter = Greeter()
# print('original greeting:',greeter.greeting)
value = read_action()
greeter.greeting = value.decode('utf8')
elif action == N('greeting'):
greeter = Greeter()
print(greeter.greeting)
def apply(receiver, account, act):
if act == N('create'):
msg = eoslib.read_action()
_create(msg)
elif act == N('issue'):
msg = eoslib.read_action()
_issue(msg)
elif act == N('transfer'):
msg = eoslib.read_action()
_transfer(msg)
def test_util():
import util
from eoslib import N
keys = struct.pack('Q', N('currency'))
values = bytes(16)
eos = N('eos')
ret = util.load(eos, eos, N('test'), keys, 0, 0, values)
print('+++++++eoslib.load return:', ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
def apply(receiver, code, action):
if action == N('sayhello'):
sayHello()
elif action == N('deploy'):
src_code = read_action()
print(src_code)
eoslib.set_code_ext(receiver, 1, N('lib'), src_code)
elif action == N('deploytest'):
print('import lib test...')
import lib
print('lib', lib)
lib.sayHello()
def test_message():
# '{"from":"currency","to":"test","amount":50}'
data = struct.pack("QQQ", N(b'test'), N(b'inita'), 50)
msghandle = eoslib.messageCreate(b'currency', b'transfer', data)
eoslib.messageRequirePermission(msghandle, b'test', b'active')
eoslib.messageSend(msghandle)
#{"from":"test", "to":"inita", "amount":50, "memo":"hello"}
data = struct.pack("QQQ", N(b'test'), N(b'inita'), 50)
data += eoslib.pack(b'hello')
msghandle = eoslib.messageCreate(b'eos', b'transfer', data)
eoslib.messageRequirePermission(msghandle, b'test', b'active')
eoslib.messageSend(msghandle)
def apply(code, action):
# print(eoslib.n2s(code),eoslib.n2s(action))
if code == test:
eoslib.requireAuth(test)
if action == N(b'transfer'):
msg = eoslib.readMessage()
result = struct.unpack('QQQ', msg)
print(result)
from_ = result[0]
to_ = result[1]
amount = result[2]
elif action == N(b'test'):
test_rw_db()
elif action == N(b'testdb'):
test_db()
elif action == N(b'callwasm'):
test_call_wasm_function()
elif action == N(b'testmsg'):
print('testmsg')
test_message()
elif action == N(b'testts'):
test_transaction()
elif action == N(b'testmem'):
test_memory_limit()
elif action == N(b'testtimeout'):
test_time_out()
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 save(self):
biases = pickle.dumps(self.biases)
weights = pickle.dumps(self.weights)
keys = struct.pack('Q', N('sizeweights'))
values = struct.pack('Q', len(weights))
eoslib.store(mnist, mnist, table_network, keys, 0, values)
keys = struct.pack('Q', N('sizebiases'))
values = struct.pack('Q', len(biases))
eoslib.store(mnist, mnist, table_network, keys, 0, values)
keys = struct.pack('Q', N('weights'))
eoslib.store(mnist, mnist, table_network, keys, 0, weights)
keys = struct.pack('Q', N('biases'))
eoslib.store(mnist, mnist, table_network, keys, 0, biases)
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 __init__(self, owner, symbol):
self.owner = owner
self.a = Asset(0, symbol)
self.symbol_name = to_symbol_name(symbol)
table_id = N('accounts')
multi_index.__init__(self, _code, self.owner, table_id)
self.load()
def __init__(self, symbol):
table_id = N('stat')
self.primary_key = scope = to_symbol_name(symbol)
multi_index.__init__(self, _code, scope, table_id)
self.supply = Asset(0, symbol)
self.max_supply = Asset(0, symbol)
self.issuer = 0
self.load()
def test_load_str():
code = N(b'test')
table = N(b'test')
ret = eoslib.remove_str(code, table, b'abc')
print(ret)
ret = eoslib.remove_str(code, table, b'abc')
print(ret)
test = eoslib.N(b'test')
ret = eoslib.load_str(code, code, table, b'abc')
print(ret)
ret = eoslib.store_str(code, table, b'abc', b'def')
print(ret)
ret = eoslib.load_str(code, code, table, b'abc')
print(ret)
def apply(receiver, code, action):
print('+++++action:', n2s(action))
if not action == N('sayhello'):
return
if 1:
test_crash2()
# test_base_exception()
test_base_exception2()
test_memory_out()
test_memory_out2()
if 1:
test_crash1()
# test_crash2()
test_recursive_call()
test_delete1()
test_delete2()
test_delete3()
if 1:
test_reload()
test_context_manager()
#----------------------------
test_getattr()
test_setattr()
# test_code_object()
test_code_object2()
test_builtin_types()
test_builtins()
#--------------------------
test_call_with_key_words()
test_change_builtin_module()
test_change_builtin_module2()
test_change_builtin_module3()
test_change_builtin_module4()
test_set_func()
test_import()
test_import2()
test_str_format()
test_open()
test_yield()
test_large_pow()
test_large_pack()
test_large_pack2()
def apply(receiver, code, action):
if action == N('sayhello'):
eoslib.require_auth(N('call'))
msg = eoslib.read_action()
print(msg.decode('utf8'))
elif action == N('call'):
msg = eoslib.read_action()
_from, to, amount = struct.unpack('QQQ', msg)
symbol = bytearray(8)
symbol[0] = 4
symbol[1] = ord('E')
symbol[2] = ord('O')
symbol[3] = ord('S')
memo = eoslib.pack_bytes(b'hello')
args = struct.pack('QQQ8s%ds' % (len(memo), ), _from, to, amount,
symbol, memo)
print('++++call')
eoslib.send_inline(N('eosio.token'), N('transfer'), args,
{'call': 'active'})
def test_transaction():
print("------------------test_transaction---------------")
#transaction will apply in the next block
tshandle = eoslib.transactionCreate()
eoslib.transactionRequireScope(tshandle, b'test', 0)
eoslib.transactionRequireScope(tshandle, b'inita', 0)
# '{"from":"test","to":"inita","amount":50}'
data = struct.pack("QQQ", N(b'test'), N(b'inita'), 50)
msghandle = eoslib.messageCreate(b'currency', b'transfer', data)
eoslib.messageRequirePermission(msghandle, b'test', b'active')
eoslib.transactionAddMessage(tshandle, msghandle)
#{"from":"test", "to":"inita", "amount":50, "memo":"hello"}
data = struct.pack("QQQ", N(b'test'), N(b'inita'), 50)
data += eoslib.pack(b'hello')
msghandle = eoslib.messageCreate(b'eos', b'transfer', data)
eoslib.messageRequirePermission(msghandle, b'test', b'active')
eoslib.transactionAddMessage(tshandle, msghandle)
eoslib.transactionSend(tshandle)
print('-------end-------------')
def test():
net = Network([784, 30, 10])
biases = pickle.dumps(net.biases)
weights = pickle.dumps(net.weights)
print(len(weights))
keys = struct.pack('Q', N('sizeweights'))
values = struct.pack('Q', len(weights))
ret = eoslib.store(mnist, mnist, table_network, keys, 0, values)
print('store return:', ret)
keys = struct.pack('Q', N('sizeweights'))
values = bytes(8)
eoslib.load(mnist, mnist, table_network, keys, 0, 0, values)
print('load return:', int.from_bytes(values, 'little'))
keys = struct.pack('Q', N('weights'))
ret = eoslib.store(mnist, mnist, table_network, keys, 0, weights)
print('store return:', ret)
keys = struct.pack('Q', N('weights'))
values = bytes(len(weights))
ret = eoslib.load(mnist, mnist, table_network, keys, 0, 0, values)
print('load return:', ret)
def test_db2():
msg = eoslib.readMessage()
print(len(msg))
test = N(b'eos')
result = int.from_bytes(msg[:8], 'little')
size = msg[8]
for i in range(size):
result = int.from_bytes(msg[9 + i * 8:9 + i * 8 + 8], 'little')
print(result)
keys = msg[:8]
values = msg[8:]
eoslib.store(test, test, test, keys, 0, values)
keys = msg[:8]
values = msg[8:]
eoslib.load(test, test, test, keys, 0, 0, values)
print(values)
def apply(code, action):
if code == exchange:
if action == N(b'buy'):
apply_exchange_buy()
elif action == N(b'sell'):
apply_exchange_sell()
elif action == N(b'cancelbuy'):
apply_exchange_cancel_buy()
elif action == N(b'cancelsell'):
apply_exchange_cancel_sell()
elif action == N(b'dotest'):
dotest()
else:
assert False, "unknown action"
elif code == currency:
if action == N(b'transfer'):
apply_currency_transfer()
elif code == N(b'eos'):
if action == N(b'transfer'):
apply_eos_transfer()
def test_rw_db():
keys = struct.pack('Q', N('currency'))
values = bytes(16)
eos = N('eos')
ret = eoslib.load(eos, eos, N('test'), keys, 0, 0, values)
print('+++++++eoslib.load return:',ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
print('--------------------------------')
keys = struct.pack('Q', N('currency'))
values = struct.pack('QQ', 77, 88)
ret = eoslib.store(test, eos, N('test'), keys, 0, values)
print('++++++++eoslib.store return:',ret)
values = bytes(16)
ret = eoslib.load(test, eos, N('test'), keys, 0, 0, values)
print('+++++++eoslib.load return:',ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
print('--------------------------------')
keys = struct.pack('Q', N('currency'))
values = struct.pack('QQ', 44, 33)
ret = eoslib.store(test, test, N('test'), keys, 0, values)
print('++++++++eoslib.store return:',ret)
values = bytes(16)
ret = eoslib.load(test, test, N('test'), keys, 0, 0, values)
print('+++++++eoslib.load return:',ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
def test_rw_db():
a = Account('test')
print('+++++++++balance:', a.balance)
a.balance += 100
a.store()
a = Account('test')
print('+++++++++balance:', a.balance)
db_keys = struct.pack('Q', N('currency'))
values = bytes(16)
eos = N('eos')
ret = eoslib.load(eos, eos, N('test'), db_keys, 0, 0, values)
print('+++++++eoslib.load return:', ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
print('--------------------------------')
values = struct.pack('QQ', 0x778899, 0x112233)
ret = eoslib.store(test, N('test'), db_keys, 0, values)
print('++++++++eoslib.store return:', ret)
values = bytes(16)
ret = eoslib.load(test, eos, N('test'), db_keys, 0, 0, values)
print('+++++++eoslib.load return:', ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
print('--------------------------------')
values = struct.pack('QQ', 44, 33)
ret = eoslib.store(test, N('test'), db_keys, 0, values)
print('++++++++eoslib.store return:', ret)
values = bytes(16)
ret = eoslib.load(test, test, N('test'), db_keys, 0, 0, values)
print('+++++++eoslib.load return:', ret)
print(values)
results = struct.unpack('QQ', values)
print(results)
from exchange import *
import eoslib as eoslib
from eoslib import N, readMessage, writeMessage
init()
writeMessage(bytes(512))
order = BuyOrder()
order.buyer = OrderID()
order.buyer.name = eoslib.N(b'buyer')
order.buyer.id = 0
order.price = uint128(11)
order.quantity = 12
order.expiration = int(time.time()) + 100
writeMessage(order())
apply(exchange, N(b'buy'))
order = SellOrder()
order.seller = OrderID()
order.seller.name = eoslib.N(b'seller')
order.seller.id = 0
order.price = uint128(11)
order.quantity = 12
order.expiration = int(time.time()) + 100
writeMessage(order())
apply(exchange, N(b'sell'))
id = OrderID()
id.name = eoslib.N(b'buyer')
import eoslib
from eoslib import N, readMessage, requireAuth, now
import struct
import logging
print = logging.info
exchange = N(b'exchange')
currency = N(b'currency')
table_account = N(b'account')
table_asks = N(b'asks')
table_bids = N(b'bids')
Name = eoslib.n2s
def min(a, b):
if a > b:
return uint64(b)
return uint64(a)
class uint64(int):
def __new__(cls, value):
if isinstance(value, bytes):
return int.__new__(cls, int.from_bytes(value, 'little'))
return int.__new__(cls, value)
def __div__(self, other):
return int(int.__div__(self, other))
from eoslib import read_action, N, n2s, unpack
from backyard.token import create, issue, transfer
try:
import ustruct as struct
except Exception as e:
import struct
code = N(b'currency')
table = N(b'account')
#{"to":"currency","quantity":"1000.0000 CUR","memo":""}
def issue_():
iss = issue()
# iss.p()
#{"from":"currency","to":"eosio","quantity":"20.0000 CUR","memo":"my first transfer"}
def transfer_():
t = transfer()
# t.p()
def create_():
c = create()
def test_call_wasm_function():
eoslib.call_wasm_function(N('test2'), N(b'hello'), [1,2])