def withdraw_ong(project_dir_path: str, claimer: str, to: str, amount, gas_limit, gas_price, network):
if project_dir_path == '':
project_dir_path = os.getcwd()
if not os.path.isdir(project_dir_path):
raise PunicaException(PunicaError.dir_path_error)
rpc_address = handle_network_config(project_dir_path, network)
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
sdk.wallet_manager = Account.get_wallet_manager(project_dir_path)
if len(sdk.wallet_manager.wallet_in_mem.accounts) == 0:
print('there is not account in the wallet.json')
return
has_sender = False
for acc in sdk.wallet_manager.wallet_in_mem.accounts:
if claimer == acc.address:
has_sender = True
break
if not has_sender:
print('there is not sender in the wallet.json')
return
claimer_pwd = getpass.getpass('Please input claimer password: '******'tx_hash: ', tx_hash)
def test_send_transfer_from(self):
private_key = '75de8489fcb2dcaf2ef3cd607feffde18789de7da129b5e97c81e001793cb7cf'
sender = Account(private_key, SignatureScheme.SHA256withECDSA)
payer = sender
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
b58_from_address = 'ANH5bHrrt111XwNEnuPZj6u95Dd6u7G4D6'
b58_recv_address = sender.get_address_base58()
old_from_balance = sdk.rpc.get_balance(b58_from_address)
old_recv_balance = sdk.rpc.get_balance(b58_recv_address)
amount = 1
gas_limit = 20000
gas_price = 500
tx_hash = asset.send_transfer_from('ont', sender, b58_from_address,
b58_recv_address, amount, payer,
gas_limit, gas_price)
self.assertEqual(64, len(tx_hash))
time.sleep(6)
new_from_balance = sdk.rpc.get_balance(b58_from_address)
new_recv_balance = sdk.rpc.get_balance(b58_recv_address)
self.assertEqual(
int(old_from_balance['ont']) - amount,
int(new_from_balance['ont']))
self.assertEqual(
int(old_recv_balance['ont']) + amount,
int(new_recv_balance['ont']))
def transfer(project_dir_path, asset: str, sender, to, amount, gas_price, gas_limit, network):
if asset == '' or asset.lower() != 'ont' and asset.lower() != 'ong':
print('asset should be ont or ong')
return
if project_dir_path == '':
project_dir_path = os.getcwd()
if not os.path.isdir(project_dir_path):
raise PunicaException(PunicaError.dir_path_error)
rpc_address = handle_network_config(project_dir_path, network)
sdk = OntologySdk()
sdk.set_rpc(rpc_address)
wallet_manager = Account.get_wallet_manager(project_dir_path)
if len(wallet_manager.wallet_in_mem.accounts) == 0:
print('there is not account in the wallet.json')
return
has_sender = False
for acc in wallet_manager.wallet_in_mem.accounts:
if sender == acc.address:
has_sender = True
break
if not has_sender:
print('there is not sender in the wallet.json')
return
sender_account = Invoke.unlock_account(sender, wallet_manager)
if sender_account is None:
return
tx_hash = sdk.native_vm().asset().send_transfer(asset, sender_account, to, amount, sender_account,
gas_limit, gas_price)
print('tx_hash: ', tx_hash)
def test_send_approve(self):
private_key1 = '523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f'
private_key2 = '1383ed1fe570b6673351f1a30a66b21204918ef8f673e864769fa2a653401114'
sender = Account(private_key1, SignatureScheme.SHA256withECDSA)
payer = Account(private_key2, SignatureScheme.SHA256withECDSA)
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
b58_recv_address = 'AazEvfQPcQ2GEFFPLF1ZLwQ7K5jDn81hve'
amount = 1
gas_limit = 20000
gas_price = 500
try:
tx_hash = asset.send_approve('ont', sender, b58_recv_address,
amount, payer, gas_limit, gas_price)
self.assertEqual(len(tx_hash), 64)
except SDKException as e:
msg = 'has no balance enough to cover gas cost 10000000'
self.assertEqual(59000, e.args[0])
self.assertIn(msg, e.args[1])
try:
tx_hash = asset.send_approve('ong', sender, b58_recv_address,
amount, payer, gas_limit, gas_price)
self.assertEqual(len(tx_hash), 64)
except SDKException as e:
msg = 'has no balance enough to cover gas cost 10000000'
self.assertEqual(59000, e.args[0])
self.assertIn(msg, e.args[1])
def test_send_transfer(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
private_key = '523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f'
from_acct = Account(private_key, SignatureScheme.SHA256withECDSA)
payer = Account(private_key, SignatureScheme.SHA256withECDSA)
b58_from_address = from_acct.get_address_base58()
b58_to_address = 'Ad4H6AB3iY7gBGNukgBLgLiB6p3v627gz1'
old_from_acct_balance = asset.query_balance('ont', b58_from_address)
old_to_acct_balance = asset.query_balance('ont', b58_to_address)
amount = 1
gas_price = 500
gas_limit = 20000
tx_hash = asset.send_transfer('ont', from_acct, b58_to_address, amount,
payer, gas_limit, gas_price)
time.sleep(6)
new_from_acct_balance = asset.query_balance('ont', b58_from_address)
new_to_acct_balance = asset.query_balance('ont', b58_to_address)
self.assertEqual(old_from_acct_balance - amount, new_from_acct_balance)
self.assertEqual(old_to_acct_balance + amount, new_to_acct_balance)
event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash)
self.assertEqual('0100000000000000000000000000000000000000',
event['Notify'][0]['ContractAddress'])
self.assertEqual('0200000000000000000000000000000000000000',
event['Notify'][1]['ContractAddress'])
def test_query_decimals(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
decimals = asset.query_decimals('ong')
self.assertEqual(9, decimals)
decimals = asset.query_decimals('ont')
self.assertEqual(1, decimals)
def test_query_symbol(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
token_symbol = asset.query_symbol('ont')
self.assertEqual('ONT', token_symbol)
token_symbol = asset.query_symbol('ong')
self.assertEqual('ONG', token_symbol)
def test_get_asset_address(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
ont_address = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01'
ong_address = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02'
self.assertEqual(ont_address, asset.get_asset_address('ont'))
self.assertEqual(ong_address, asset.get_asset_address('ong'))
def query_unbound_ong(project_dir_path, address, network):
if project_dir_path == '':
project_dir_path = os.getcwd()
if not os.path.isdir(project_dir_path):
raise PunicaException(PunicaError.dir_path_error)
rpc_address = handle_network_config(project_dir_path, network)
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
balance = sdk.native_vm().asset().query_unbound_ong(address)
print(address + ' UnboundOng: ', balance)
def balance_of(project_dir_path: str, asset: str, address: str, network: str):
if asset == '' or asset.lower() != 'ont' and asset.lower() != 'ong':
print(asset, ' asset should be ont or ong')
return
if project_dir_path == '':
project_dir_path = os.getcwd()
if not os.path.isdir(project_dir_path):
raise PunicaException(PunicaError.dir_path_error)
rpc_address = handle_network_config(project_dir_path, network)
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
balance = sdk.native_vm().asset().query_balance(asset, address)
print(address + ' Balance: ', balance)
def test_query_allowance(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
b58_from_address = 'ANH5bHrrt111XwNEnuPZj6u95Dd6u7G4D6'
b58_to_address = 'AazEvfQPcQ2GEFFPLF1ZLwQ7K5jDn81hve'
allowance = asset.query_allowance('ont', b58_from_address,
b58_to_address)
self.assertGreaterEqual(allowance, 0)
allowance = asset.query_allowance('ong', b58_from_address,
b58_to_address)
self.assertGreaterEqual(allowance, 0)
def test_query_balance(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
private_key = util.get_random_hex_str(64)
acct = Account(private_key, SignatureScheme.SHA256withECDSA)
b58_address = acct.get_address_base58()
balance = asset.query_balance('ont', b58_address)
self.assertTrue(isinstance(balance, int))
self.assertGreaterEqual(balance, 0)
balance = asset.query_balance('ong', b58_address)
self.assertTrue(isinstance(balance, int))
self.assertGreaterEqual(balance, 0)
def test_unbound_ong(self):
b58_address1 = 'ANH5bHrrt111XwNEnuPZj6u95Dd6u7G4D6'
b58_address2 = 'AazEvfQPcQ2GEFFPLF1ZLwQ7K5jDn81hve'
b58_address3 = 'Ad4H6AB3iY7gBGNukgBLgLiB6p3v627gz1'
b58_address4 = 'AHX1wzvdw9Yipk7E9MuLY4GGX4Ym9tHeDe'
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
acct1_unbound_ong = asset.query_unbound_ong(b58_address1)
self.assertGreaterEqual(acct1_unbound_ong, 0)
acct2_unbound_ong = asset.query_unbound_ong(b58_address2)
self.assertGreaterEqual(acct2_unbound_ong, 0)
acct3_unbound_ong = asset.query_unbound_ong(b58_address3)
self.assertGreaterEqual(acct3_unbound_ong, 0)
acct4_unbound_ong = asset.query_unbound_ong(b58_address4)
self.assertGreaterEqual(acct4_unbound_ong, 0)
class OntBlockSync:
def __init__(self):
rpc_address = 'http://polaris1.ont.io:20336'
self.rest_address = 'http://polaris3.ont.io:20334'
self.sdk = OntologySdk()
self.sdk.rpc.set_address(rpc_address)
base58_address = "AKErtiRYq83f4f54WhiDHxs2piqG1QoNE4"
address_balance = self.sdk.rpc.get_balance(base58_address)
self.ont_balance = address_balance['ont']
self.ong_balance = address_balance['ong']
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["ont"]
self.smt_block = mydb["smt_block"]
self.oep_token = mydb["oep_token"]
def query_symbol(self):
asset = self.sdk.native_vm().asset()
token_symbol_ont = asset.query_symbol('ont')
token_symbol_ong = asset.query_symbol('ong')
print(token_symbol_ont, token_symbol_ong)
def print_balance(self):
return {"ont": self.ont_balance, "ong": self.ong_balance}
def get_oep4_name(self):
oep4 = self.sdk.neo_vm().oep4()
contract_address = '9d70f2d7fd2a2318c611ae8feb4f7bf067ba680e'
oep4.set_contract_address(contract_address)
oep4_name = oep4.get_name()
oep4_symbol = oep4.get_symbol()
oep4_total_supply = oep4.get_total_supply()
balance = oep4.balance_of('AKErtiRYq83f4f54WhiDHxs2piqG1QoNE4')
balance2 = oep4.balance_of('AecaeSEBkt5GcBCxwz1F41TvdjX3dnKBkJ')
print(oep4_name, oep4_symbol, oep4_total_supply, balance, balance2)
return oep4_name
def create_account(self):
wm = WalletManager()
label = 'leec'
password = '******'
acct = wm.create_account(label, password)
print(acct)
def get_leatest_block(self):
res = requests.get(self.rest_address + '/api/v1/block/height')
snapshot = res.json()
print(snapshot['Result']) # 当前高度
def get_smartcode_by_height(self, height):
res = requests.get(self.rest_address +
'/api/v1/smartcode/event/transactions/' + height)
snapshot = res.json()
print(snapshot)
def get_smartcode_by_hash(self, hash):
res = requests.get(self.rest_address +
'/api/v1/smartcode/event/txhash/' + hash)
snapshot = res.json()
print(snapshot['Result'])
# 通过 python sdk
def get_curr_block_height(self):
current_block_height = self.sdk.rpc.get_block_count()
print(current_block_height)
def get_curr_block(self):
current_block_hash = self.sdk.rpc.get_current_block_hash()
print(current_block_hash)
def get_block_by_height(self, height):
block = self.sdk.rpc.get_block_by_height(height)
print(block)
def get_block_by_hash(self, hash):
block = self.sdk.rpc.get_block_by_hash(hash)
print(block)
def get_sm_evt_by_hash(self, hash):
event = self.sdk.rpc.get_smart_contract_event_by_tx_hash(hash)
print(event)
def get_sm_evt_by_height(self, height):
event = self.sdk.rpc.get_smart_contract_event_by_height(height)
print(event)
# 开始同步区块
def save_block_to_db(self, sync_block_height):
print('开始后同步区块 height:', sync_block_height)
current_block = self.sdk.rpc.get_block_by_height(sync_block_height)
curr_timestamp = current_block['Header']['Timestamp']
print('当前区块的 timestamp', curr_timestamp) # 当前区块的 timestamp
curr_smc_evt = self.sdk.rpc.get_smart_contract_event_by_height(
sync_block_height)
if curr_smc_evt == None: # 如果当前区块没有smart contract交易数据
# print('curr smc evt none ')
insert_data_one = {
'block_height': sync_block_height,
'timestamp': curr_timestamp
}
insert_res = self.smt_block.insert_one(insert_data_one)
# print(insert_res)
print('height:', sync_block_height, ' 同步完成，该区块没有智能合约交易')
return False
if len(curr_smc_evt) > 0: # 如果当前区块有smart contract交易数据
insert_data = []
for transation in curr_smc_evt:
# print(transation['Notify'])
for n in transation['Notify']:
contractAddress = n['ContractAddress']
states = n['States']
# print(contractAddress, states)
insert_data.append({
'block_height': sync_block_height,
'timestamp': curr_timestamp,
'contractAddress': contractAddress,
'states': states
})
# print(insert_data)
insert_res = self.smt_block.insert_many(insert_data)
# print(insert_res)
print('height:', sync_block_height, ' 同步完成，该区块存在智能合约交易',
len(insert_data), ' tx')
def sync_block_loop(self):
start_block_height = 431300 # 设置从哪个区块高度开始同步
current_block_height = self.sdk.rpc.get_block_count() - 1
# current_block_height = 431183
# print(current_block_height)
# 查询当前数据库中的区块高度
sort_block_res_count = self.smt_block.find().count()
if (sort_block_res_count == 0):
print('数据库中没有数据')
least_db_block_height = start_block_height
else:
sort_block_res = self.smt_block.find().sort('block_height', -1)
# print(sort_block_res)
least_db_block_height = sort_block_res[0]['block_height']
print('数据库中的block height max:', least_db_block_height)
# return False
# 比较数据库中存在数据的最高高度 与 当前高度对比
print('当前高度：', current_block_height)
print('数据库中存在数据的最高高度：', least_db_block_height)
if (current_block_height <= least_db_block_height):
return False
sync_block_height = least_db_block_height # 当前同步区块
while (sync_block_height <
current_block_height - 1): # if 当前要同步的区块height < 当前主网的区块高度
sync_block_height = sync_block_height + 1
time.sleep(1) # 1s 同步一笔
print('-' * 50)
if self.save_block_to_db(sync_block_height) == False:
continue
print('全部数据同步完成')
print('*' * 50)
# 永久循环 同步db
def sync_block_loop_forever(self):
while True:
self.sync_block_loop()
time.sleep(3) # wait 3s
# 列出认证的oep4 token list
def list_oep4_token(self):
res = []
for t in self.oep_token.find():
res.append({
"smc_addr": t['contractAddress'],
"name": t['name'],
"symbol": t['symbol']
})
return res
# 查询 oep4 token detail
def query_oep4_detail(self, contractAddress):
oep4 = self.sdk.neo_vm().oep4()
oep4.set_contract_address(contractAddress)
print(oep4.get_symbol())
print(oep4.get_total_supply())
decimal = oep4.get_decimal()
total_supply = oep4.get_total_supply() / (10**decimal)
return {
"smc_addr": contractAddress,
"name": oep4.get_name(),
"symbol": oep4.get_symbol(),
"total_supply": total_supply,
"decimal": decimal
}
# 查询 oep4 数据
def query_oep4_token_transfer(self, contractAddress):
sm_res = self.smt_block.find({'contractAddress': contractAddress})
res = []
oep4 = self.sdk.neo_vm().oep4()
oep4.set_contract_address(contractAddress)
decimal = oep4.get_decimal()
for sm in sm_res:
print(sm)
if len(sm['states']) != 4:
continue
if self.hex_to_str(sm['states'][0]) == 'transfer':
# 需要进行转换
timestamp = sm['timestamp']
from_addr = sm['states'][1]
to_addr = sm['states'][2]
trans_amount = sm['states'][3]
trans_amount = bytearray(binascii.a2b_hex(trans_amount))
trans_amount.reverse()
trans_amount = binascii.b2a_hex(trans_amount)
trans_amount = int(trans_amount, 16) / (10**decimal)
from_addr = Address(binascii.a2b_hex(from_addr)).b58encode()
to_addr = Address(binascii.a2b_hex(to_addr)).b58encode()
print(from_addr, to_addr, trans_amount, timestamp)
res.append({
"from_addr": from_addr,
"to_addr": to_addr,
"trans_amount": trans_amount,
"timestamp": timestamp
})
return res
# 将 hex 转成 string
def hex_to_str(self, hex):
return bytes.fromhex(hex).decode('utf-8')
class DemoClient(object):
"""
"""
def __init__(self, rpc_addr: str, wallet_file: str, is_maker: bool, pwd,
avm_file, abi_file):
self.sdk = OntologySdk()
self.sdk.rpc.set_address(rpc_addr)
self.sdk.open_wallet(wallet_file)
self.is_maker = is_maker # 可以查询一个合约存不存在，存在就可以让maker是True，而不必自己指定了
self.__pwd = pwd
self.__get_code_from_avm(avm_file)
self.__get_abi_from_file(abi_file)
@staticmethod
def is_transaction_success(txid):
if len(txid) != 64:
return False
return True
def start_game(self, acc_index):
if not self.is_maker:
return
acc = self.get_account_by_index(acc_index)
txid = self.deploy_contract(need_storage=True,
name="sixsixsix",
code_ver="1.0",
author="tomzou",
email="*****@*****.**",
desp="demo",
acc=acc,
gas_limit=20200000,
gas_price=500)
if not self.is_transaction_success(txid):
raise Exception(txid)
return txid
def get_account_by_index(self, acc_index):
wm = self.sdk.get_wallet_manager()
return wm.get_account(
wm.get_wallet().get_account_by_index(acc_index).get_address(),
self.__pwd[acc_index])
def deploy_contract(self, need_storage, name, code_ver, author, email,
desp, acc, gas_limit, gas_price):
tx = self.sdk.neo_vm().make_deploy_transaction(
self.code,
need_storage=need_storage,
name=name,
code_version=code_ver,
author=author,
email=email,
desp=desp,
payer=acc.get_address_base58(),
gas_limit=gas_limit,
gas_price=gas_price)
self.sdk.sign_transaction(tx, acc)
return self.sdk.get_rpc().send_raw_transaction(tx)
def __get_code_from_avm(self, avm_file):
f = open(avm_file)
self.code = f.readline()
code_addr_obj = Address.address_from_vm_code(self.code)
self.code_addr = code_addr_obj.to_reverse_hex_str()
self.contract_acc = code_addr_obj.to_base58()
self.contract_addr = code_addr_obj.to_byte_array()
f.close()
def __get_abi_from_file(self, abi_file):
f = open(abi_file)
abi_str = f.readline()
abi = json.loads(abi_str,
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
self.abi_info = AbiInfo("0x" + self.code_addr, "main", abi.functions,
[])
def luck_roll(self, amount, acc_index):
"""
玩家通过本方法参与游戏
:param amount:
:param acc_index:
:return:
"""
self.join_game(amount, acc_index)
if self.bet(amount, acc_index) is True:
print('I win, you bitch')
else:
print('Go back and work, FOOL')
def join_game(self, amount, acc_index):
acc = self.get_account_by_index(acc_index)
# 调用相应的函数，需写完合约再回头搞
func_join = self.abi_info.get_function("join")
func_join.set_params_value(acc.get_address_base58(), amount)
func_read_res = self.abi_info.get_function("is_game_ready")
txid = self.sdk.neo_vm().send_transaction(self.contract_addr, acc, acc,
2000000, 500, func_join,
False)
print(txid)
if not self.is_transaction_success(txid):
raise Exception(txid)
before = time.time()
tx_info = self.sdk.get_rpc().get_smart_contract_event_by_txhash(txid)
while tx_info == 'unknown transaction' or tx_info is None:
tx_info = self.sdk.get_rpc().get_smart_contract_event_by_txhash(
txid)
print('cost %f seconds to confirm tx' % (time.time() - before))
try:
notify_info = tx_info['Notify'][0]['States']
except Exception:
raise Exception(tx_info)
print(notify_info)
if notify_info == '4e6f206d6f72652073656174':
raise Exception("No more seat")
elif notify_info == '6a6f696e207375636365737366756c6c79':
# 等待游戏结束，不停滴向合约pull结果
while True:
time.sleep(1)
res = self.sdk.neo_vm().send_transaction(
self.contract_addr, acc, acc, 2000000, 500, func_read_res,
True)
if res is True:
print(res)
break
def bet(self, amount, acc_index):
"""
人都坐好了，开赌！
掷出骰子并等待结果，返回输赢
:param amount: 需与join相同
:param acc_index: 使用钱包中第几个账户，需和join方法统一
:return: True代表胜利，False代表输了。。
"""
acc = self.get_account_by_index(acc_index)
tx = self.sdk.native_vm().asset().new_transfer_transaction(
'ont', acc.get_address_base58(), self.contract_acc, amount,
acc.get_address_base58(), 2000000, 500)
self.sdk.sign_transaction(tx, acc)
txid = self.sdk.get_rpc().send_raw_transaction(tx)
if not self.is_transaction_success(txid):
raise Exception('Some thing wrong with tx:%s' % txid)
func_get_amounts = self.abi_info.get_function('get_amounts')
sum_amounts = self.sdk.neo_vm().send_transaction(
self.contract_addr, acc, acc, 2000000, 500, func_get_amounts, True)
contract_balance = self.sdk.get_rpc().get_balance(self.contract_acc)
while sum_amounts > contract_balance:
contract_balance = self.sdk.get_rpc().get_balance(
self.contract_acc)
time.sleep(0.5)
# 直接开始游戏，获取随机数
func_roll_dice = self.abi_info.get_function('roll_dice')
func_roll_dice.set_params_value(acc.get_address_base58())
txid = self.sdk.neo_vm().send_transaction(self.contract_addr, acc, acc,
2000000, 500, func_roll_dice,
False)
if not self.is_transaction_success(txid):
raise Exception('Some thing wrong with tx:%s' % txid)
before = time.time()
tx_info = self.sdk.get_rpc().get_smart_contract_event_by_txhash(txid)
while tx_info == 'unknown transaction' or tx_info is None:
tx_info = self.sdk.get_rpc().get_smart_contract_event_by_txhash(
txid)
print('cost %f seconds to confirm tx' % (time.time() - before))
try:
notify_info = tx_info['Notify'][0]['States']
except Exception:
raise Exception(tx_info)
if type(notify_info) is int:
print('your game is done and your dice number is %d' % notify_info)
else:
raise Exception(bytes.fromhex(notify_info).decode())
func_get_res = self.abi_info.get_function('get_res')
res = self.sdk.neo_vm().send_transaction(self.contract_addr, acc, acc,
2000000, 500, func_get_res,
True)
while res is False:
res = self.sdk.neo_vm().send_transaction(self.contract_addr, acc,
acc, 2000000, 500,
func_get_res, True)
time.sleep(0.5)
if res == acc.get_address_base58():
return True
else:
return False
def test_new_transfer_transaction(self):
rpc_address = 'http://polaris3.ont.io:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
asset = sdk.native_vm().asset()
private_key1 = '523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f'
private_key2 = '75de8489fcb2dcaf2ef3cd607feffde18789de7da129b5e97c81e001793cb7cf'
from_acct = Account(private_key1, SignatureScheme.SHA256withECDSA)
to_acct = Account(private_key2, SignatureScheme.SHA256withECDSA)
b58_from_address = from_acct.get_address_base58()
b58_to_address = to_acct.get_address_base58()
b58_payer_address = b58_from_address
balance_1 = sdk.rpc.get_balance(b58_from_address)
balance_2 = sdk.rpc.get_balance(b58_to_address)
old_ont_balance_1 = 0
old_ont_balance_2 = 0
old_ong_balance_1 = 0
old_ong_balance_2 = 0
try:
old_ont_balance_1 = balance_1['ont']
old_ont_balance_2 = balance_2['ont']
except KeyError:
raised = True
self.assertFalse(raised, 'Exception raised')
try:
old_ong_balance_1 = balance_1['ong']
old_ong_balance_2 = balance_2['ong']
except KeyError:
raised = True
self.assertFalse(raised, 'Exception raised')
amount = 1
gas_price = 500
gas_limit = 20000
tx = asset.new_transfer_transaction('ont', b58_from_address,
b58_to_address, amount,
b58_payer_address, gas_limit,
gas_price)
tx = sdk.sign_transaction(tx, from_acct)
tx = sdk.add_sign_transaction(tx, to_acct)
tx_hash = sdk.rpc.send_raw_transaction(tx)
self.assertEqual(64, len(tx_hash))
time.sleep(6)
balance_1 = sdk.rpc.get_balance(b58_from_address)
balance_2 = sdk.rpc.get_balance(b58_to_address)
new_ont_balance_1 = 0
new_ont_balance_2 = 0
new_ong_balance_1 = 0
new_ong_balance_2 = 0
try:
new_ont_balance_1 = balance_1['ont']
new_ont_balance_2 = balance_2['ont']
except KeyError:
raised = True
self.assertFalse(raised, 'Exception raised')
try:
new_ong_balance_1 = balance_1['ong']
new_ong_balance_2 = balance_2['ong']
except KeyError:
raised = True
self.assertFalse(raised, 'Exception raised')
gas = gas_limit * gas_price
self.assertEqual(int(old_ont_balance_1) - 1, int(new_ont_balance_1))
self.assertEqual(int(old_ont_balance_2) + 1, int(new_ont_balance_2))
self.assertEqual((int(old_ong_balance_1) - int(new_ong_balance_1)),
gas)
self.assertEqual(int(old_ong_balance_2), int(new_ong_balance_2))
