def main(argv):
try:
opts, args = getopt.getopt(argv, "-h-m:-i:-p", [
"migrate=",
"invoke=",
])
except getopt.GetoptError:
print('test.py [-m|--migrate] [-i|--invoke] ')
sys.exit(2)
m = {}
invoke_func_name = ""
pre_exec = False
for opt, arg in opts:
if opt == '-h':
print('test.py [-m|--migrate] [-i|--invoke] ')
sys.exit()
elif opt in ("-m", "--migrate"):
m["func"] = "migrate"
if "json" in str(arg):
with open(arg, "r") as f:
r = json.load(
f,
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
#print("r_json_content is ", r)
m["rpc_address"] = r.rpc_address
m["need_storage"] = r.need_storage
m["name"] = r.name
m["code_version"] = r.code_version
m["author"] = r.author
m["email"] = r.email
m["desp"] = r.desp
m["payer_address"] = r.payer_address
m["payer_password"] = r.payer_password
m["wallet_file_path"] = r.wallet_file_path
m["gas_limit"] = r.gas_limit
m["gas_price"] = r.gas_price
m["save_file"] = r.save_file
if ".avm" in r.code:
with open(r.code, "r") as f2:
m["code"] = f2.read()
else:
m["code"] = r.code
m["contract_address"] = Address.address_from_vm_code(
m["code"]).to_hex_str()
else:
temp = str(arg).split(",")
for i in temp:
t = str(i).split("=")
m[t[0]] = t[1]
elif opt in ("-i", "--invoke"):
invoke_func_name = arg
print('invoke_function is ', invoke_func_name)
m["func"] = "invoke"
invoke_json_path = './invoke.json'
if "json" in str(invoke_json_path):
with open(invoke_json_path, "r") as f:
r = json.load(
f,
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
m["rpc_address"] = r.rpc_address
m["acct_address"] = r.acct_address
m["acct_password"] = r.acct_password
m["payer_address"] = r.payer_address
m["payer_password"] = r.payer_password
m["wallet_file_path"] = r.wallet_file_path
m["gas_limit"] = r.gas_limit
m["gas_price"] = r.gas_price
#m["abi_path"] = r.abi_path
m["save_file"] = r.save_file
print('m_save_file is ', m["save_file"])
#m["function"] = r.function
if "abi.json" in r.abi:
with open(r.abi, "r") as f:
m["abi"] = f.read()
else:
m["abi"] = r.abi
else:
temp = str(invoke_json_path).split(",")
for i in temp:
t = str(i).split("=")
m[t[0]] = t[1]
elif opt in ("-p", "--pre"):
pre_exec = True
print('pre_exec is True')
else:
print('test.py [-m|--migrate] [-i|--invoke] ')
sys.exit()
sdk = OntologySdk()
sdk.set_rpc(m["rpc_address"])
if m["func"] is "migrate":
need_storage = False
if m["need_storage"] is 'true':
need_storage = True
tx = sdk.neo_vm().make_deploy_transaction(
m["code"], need_storage, m["name"], m["code_version"], m["author"],
m["email"], m["desp"], m["payer_address"], m["gas_limit"],
m["gas_price"])
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
acct = sdk.wallet_manager.get_account(m["payer_address"],
m["payer_password"])
print('acct.address', acct.get_address_base58())
sdk.sign_transaction(tx, acct)
sdk.set_rpc(m["rpc_address"])
try:
print("deploying，please waiting ...")
r = sdk.rpc.send_raw_transaction(tx)
print("txhash:", r)
for i in range(10):
time.sleep(1)
r = sdk.rpc.get_smart_contract(m["contract_address"])
if r == "":
continue
else:
print("deploy success")
break
save_file(m, "success")
except Exception as e:
print(e)
save_file(m, e)
elif m["func"] is "invoke":
res_abi = json.loads(m["abi"],
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
abi_info = AbiInfo(res_abi.hash, res_abi.entrypoint, res_abi.functions,
res_abi.events)
contract_address = bytearray.fromhex(str(res_abi.hash)[2:])
contract_address.reverse()
#print("contract_address is ", contract_address)
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
acct = sdk.wallet_manager.get_account(m["acct_address"],
m["acct_password"])
payer = sdk.wallet_manager.get_account(m["payer_address"],
m["payer_password"])
print('res_abi.hash is ', res_abi.hash)
#print('res_abi.entrypoint is ', res_abi.entrypoint)
#print('res_abi.function is ', res_abi.functions, type(res_abi.functions), len(res_abi.functions))
invoke_func = abi_info.get_function(invoke_func_name)
func_params = {}
for function in res_abi.functions:
if function.name == invoke_func_name:
func_params = function.parameters
func_params_map = {}
for param in func_params:
hinter = 'Pls input ' + param.name + ' (' + param.type + ')' + ': '
raw_input = input(hinter)
if param.type == 'String':
invoke_func.parameters.append(str(raw_input))
if param.type == 'ByteArray':
invoke_func.parameters.append(bytearray(raw_input))
if param.type == 'Integer':
invoke_func.parameters.append(int(raw_input))
try:
print("")
print("invoking '" + invoke_func_name + "', please waiting ...")
#print("method: " + invoke_func_name)
res = sdk.neo_vm().send_transaction(contract_address, acct, payer,
m["gas_limit"], m["gas_price"],
invoke_func, pre_exec)
if not pre_exec:
time.sleep(6)
print("txhash:", res)
print("Event:",
sdk.rpc.get_smart_contract_event_by_tx_hash(res))
else:
print(res)
print("res:", (bytearray.fromhex(res)).decode('utf-8'))
#l.append((bytearray.fromhex(res)).decode('utf-8'))
except Exception as e:
print("Error:", e)
#l.append(e)
#func_l.append(l)
else:
print('only support migrate and invoke')
def push_address(self, value: Address):
if not isinstance(value, Address):
raise SDKException(ErrorCode.other_error('invalid data'))
self.write_bytes(value.to_bytearray())
#!/usr/bin/env python3
import time
import unittest
from test import sdk, acct1, acct2, acct3
from ontology.common.address import Address
from ontology.account.account import Account
from ontology.utils.utils import get_random_hex_str
from ontology.exception.exception import SDKException
from ontology.utils.contract_data import ContractDataParser
pub_keys = [acct1.get_public_key_bytes(), acct2.get_public_key_bytes(), acct3.get_public_key_bytes()]
multi_address = Address.address_from_multi_pub_keys(2, pub_keys)
class TestRpcClient(unittest.TestCase):
def test_get_version(self):
try:
version = sdk.rpc.get_version()
self.assertTrue(isinstance(version, str))
if version != '':
self.assertIn('v', version)
except SDKException as e:
self.assertTrue('ConnectTimeout' in e.args[1])
def test_get_connection_count(self):
try:
count = sdk.rpc.get_connection_count()
self.assertGreaterEqual(count, 0)
def test_multi_serialize(self):
pub_keys = [
acct1.get_public_key_bytes(),
acct2.get_public_key_bytes(),
acct3.get_public_key_bytes()
]
m = 2
multi_address = Address.address_from_multi_pub_keys(m, pub_keys)
b58_multi_address = multi_address.b58encode()
b58_acct1_address = acct1.get_address_base58()
b58_acct2_address = acct2.get_address_base58()
gas_price = 500
gas_limit = 20000
tx1 = sdk.native_vm.asset().new_transfer_transaction(
'ong', b58_multi_address, b58_acct2_address, 1000000000,
b58_acct1_address, gas_limit, gas_price)
tx_bytes = tx1.serialize()
tx2 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx1), dict(tx2))
tx2.sign_transaction(acct1)
tx_bytes = tx2.serialize()
tx3 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx2), dict(tx3))
tx3.add_multi_sign_transaction(m, pub_keys, acct1)
tx_bytes = tx3.serialize()
tx4 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx3), dict(tx4))
tx4.add_multi_sign_transaction(m, pub_keys, acct2)
tx_bytes = tx4.serialize()
tx5 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx4), dict(tx5))
tx_hash = sdk.rpc.send_raw_transaction(tx5)
self.assertEqual(64, len(tx_hash))
sleep(6)
event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash)
contract_address = '0200000000000000000000000000000000000000'
notify = ContractEventParser.get_notify_list_by_contract_address(
event, contract_address)
for event in notify:
self.assertEqual(event['States'][0], 'transfer')
multi_address = Address.address_from_multi_pub_keys(m, pub_keys[::-1])
b58_multi_address = multi_address.b58encode()
b58_acct1_address = acct1.get_address_base58()
b58_acct2_address = acct2.get_address_base58()
tx1 = sdk.native_vm.asset().new_transfer_transaction(
'ong', b58_multi_address, b58_acct2_address, 100000,
b58_acct1_address, gas_limit, gas_price)
tx_bytes = tx1.serialize()
tx2 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx1), dict(tx2))
tx2.sign_transaction(acct1)
tx_bytes = tx2.serialize()
tx3 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx2), dict(tx3))
tx3.add_multi_sign_transaction(m, pub_keys, acct1)
tx_bytes = tx3.serialize()
tx4 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx3), dict(tx4))
tx4.add_multi_sign_transaction(m, pub_keys, acct2)
tx_bytes = tx4.serialize()
tx5 = Transaction.deserialize_from(tx_bytes)
self.assertEqual(dict(tx4), dict(tx5))
tx_hash = sdk.rpc.send_raw_transaction(tx5)
self.assertEqual(64, len(tx_hash))
sleep(6)
event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash)
contract_address = '0200000000000000000000000000000000000000'
notify = ContractEventParser.get_notify_list_by_contract_address(
event, contract_address)
for event in notify:
self.assertEqual(event['States'][0], 'transfer')
import requests from datetime import datetime from ontology.smart_contract.neo_vm import NeoVm from ontology.crypto.digest import Digest from ontology.utils.util import bigint_to_neo_bytes rpc_address = 'http://127.0.0.1:20336' sdk = OntologySdk() sdk.rpc.set_address(rpc_address) wallet_path = "D:\\test-python-sdk\\wallet.dat" sdk.wallet_manager.open_wallet(wallet_path) admin_addr = "ASwaf8mj2E3X18MHvcJtXoDsMqUjJswRWS" admin_pwd = "123123" ownerAcct = sdk.wallet_manager.get_account(admin_addr, admin_pwd) ownerAddress = Address.b58decode(admin_addr).to_array() challengerAddress = "ARDskfQuvTa7TvbCVNX8MP5zjg7SUdDgSa" challengerAccount = Address.b58decode(challengerAddress).to_array() challengerAcct = sdk.wallet_manager.get_account(challengerAddress, admin_pwd) challengerAddress1 = "ASJeGy7CPoa2EvTEAyQFd5uxD9mr8ejVxE" challengerAccount1 = Address.b58decode(challengerAddress1).to_array() challengerAcct1 = sdk.wallet_manager.get_account(challengerAddress1, admin_pwd) tokenAddress = "3cf3cd1332a4c7eabcb3665d2b6e3388047bd6e4" token_address = bytearray.fromhex(tokenAddress) token_address.reverse() PLCRAddress = "b7e54aa69c0c60a93104a8613e3935cf7db7294f" PLCR_address = bytearray.fromhex(PLCRAddress)
def contract_address(self) -> Address:
return Address(self._contract_address)
def address_to_hex(address):
if address is None or address == '':
print('address is none')
return
print('Result is:')
print('\t', Address.b58decode(address).to_bytes().hex())
def deserialize(self, reader: BinaryReader):
self.address = Address(reader.read_bytes(20))
self.amount = reader.read_int64()
def test_open_wallet_account_from_path(self):
''' Open wallet and get account'''
wallet_path = "C:\\Go_WorkSpace\\src\\github.com\\ontio\\ontology\\_Wallet_\\wallet.dat"
sdk.wallet_manager.open_wallet(wallet_path)
acct1_addr = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
acct2_addr = "ASUwFccvYFrrWR6vsZhhNszLFNvCLA5qS6"
acct3_addr = "AWf8NiLzXSDf1JB2Ae6YUKSHke4yLHMVCm"
acct1_pwd = "xinhao"
acct1 = sdk.wallet_manager.get_account(acct1_addr, acct1_pwd)
acct2 = sdk.wallet_manager.get_account(acct2_addr, acct1_pwd)
acct3 = sdk.wallet_manager.get_account(acct3_addr, acct1_pwd)
'''export several keys'''
account = acct3
wif_key = account.export_wif()
print("wif_key is ", wif_key)
private_key_bytes = account.get_privatekey_from_wif(wif_key)
print("private_key_bytes is ", private_key_bytes,
type(private_key_bytes))
private_key_str = private_key_bytes.hex()
print("private_key_str is ", private_key_str, type(private_key_str))
pwd = acct1_pwd
addr = "ANjLDUU9htLKe41yxzVKpiPmFNseA3N9gc"
salt = "XeK1Nkv8F8qKxXtLEPSbRw=="
nounce = 16384
scheme = SignatureScheme.SHA256withECDSA
private_key_str = private_key_bytes.hex()
print("private_key_str is ", private_key_str, type(private_key_str))
''' send transaction without signer'''
version = 0
tx_type = 0xd1
unix_time_now = int(time.time())
nonce = unix_time_now
gas_price = 0
gas_limit = 20000
payer = None
payload = None
attributes = None
sigs = None
hash = None
'''
contract_address_str = "749a701ae89c0dbdab9b4b660ba84ee478004219"
contract_address_bytearray = bytearray.fromhex(contract_address_str)
contract_address = contract_address_bytearray
contract_address.reverse()
print('contract_address is ', contract_address)
'''
'''
contract_address = util.get_asset_address("ont")
#state = [{"address": "ASUwFccvYFrrWR6vsZhhNszLFNvCLA5qS6", "to": "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p", "amount": 10000}]
b58_address = "ASUwFccvYFrrWR6vsZhhNszLFNvCLA5qS6"
raw_address = Address.b58decode(b58_address)
#sdk.neo_vm().send_transaction(contract_address, acct1,[],20000, 0, )
invoke_code = build_native_invoke_code(contract_address, bytes([0]), "balanceOf", raw_address)
payer = raw_address
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer, invoke_code, bytearray(), [], bytearray())
#Transaction(0, 0xd1, unix_time_now, 0, 0, payer, invoke_code, bytearray(), [], bytearray())
res = sdk.rpc.send_raw_transaction_pre_exec(tx)
print('res is ', res)
'''
# Check balanceOf through NeoVm.make_invoke_transaction
contract_address_str = "f328cb02bb1bd3a25c32f3db9b5f20b6fc4e04ea"
contract_address_bytearray = bytearray.fromhex(contract_address_str)
contract_address = contract_address_bytearray
contract_address.reverse()
print('contract_address is ', contract_address)
params_list = []
params_list.append(str("BalanceOf").encode())
param = []
b58_address = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
param.append(Address.b58decode(b58_address).to_array())
params_list.append(param)
params = BuildParams.create_code_params_script(params_list)
# when pre-execute, don't use 0x67
tx = NeoVm.make_invoke_transaction(bytearray(contract_address),
bytearray(params), b'', 20000, 0)
res = sdk.rpc.send_raw_transaction_pre_exec(tx)
print("BalanceOf is ", res)
# # Check totalsupply
# params_list = []
# params_list.append(str("totalSupply").encode())
# param = [10]
# params_list.append(param)
# params = BuildParams.create_code_params_script(params_list)
# # when pre-execute, don't use 0x67
# tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 20000, 0)
# res = sdk.rpc.send_raw_transaction_pre_exec(tx)
# print('totalsupply is ', res)
#
# # Transfer through Transaction, send_raw_transaction
# params_list = []
# params_list.append(str("transfer").encode())
# from_addr = "ASUwFccvYFrrWR6vsZhhNszLFNvCLA5qS6"
# to_addr = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
# value = 100
# param = []
# param.append(Address.b58decode(from_addr).to_array())
# param.append(Address.b58decode(to_addr).to_array())
# param.append(value)
# params_list.append(param)
# params = BuildParams.create_code_params_script(params_list)
# # when execute, use 0x67, then add the contract_address
# params.append(0x67)
# for i in contract_address:
# params.append(i)
# payer_raw_address = acct2.get_address().to_array()
# payer_acct = acc2
# unix_time_now = int(time.time())
# tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_raw_address, params, bytearray(), [], bytearray())
# sdk.sign_transaction(tx, acct2)
# #sdk.add_sign_transaction(tx, payer_acct)
# sdk.rpc.send_raw_transaction(tx)
# # # Transfer through send_Transaction
# # balance_Of_Addr = "ASUwFccvYFrrWR6vsZhhNszLFNvCLA5qS6"
# # func = AbiFunction("balanceOf", "Integer", [])
# # func.set_params_value((binascii.a2b_hex(balance_Of_Addr)))
# # balance = sdk.neo_vm().send_transaction(contract_address, None, None, 0, 0, func, True)
# # Transfer through Transaction, send_raw_transaction
### check balance before transferMulti###
print('### check balance Before transferMulti ###')
params_list = []
params_list.append(str("BalanceOf").encode())
param = []
b58_address = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
param.append(Address.b58decode(b58_address).to_array())
params_list.append(param)
params = BuildParams.create_code_params_script(params_list)
# when pre-execute, don't use 0x67
tx = NeoVm.make_invoke_transaction(bytearray(contract_address),
bytearray(params), b'', 20000, 0)
res = sdk.rpc.send_raw_transaction_pre_exec(tx)
print("before TransferMulti, the balance is ", res)
### transferMulti
params_list = []
params_list.append(str("TransferMulti").encode())
from_addr1 = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
from_addr2 = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
to_addr1 = "ASUwFccvYFrrWR6vsZhhNszLFNvCLA5qS6"
to_addr2 = "AWf8NiLzXSDf1JB2Ae6YUKSHke4yLHMVCm"
value1 = 10000
value2 = 10000
param1 = []
param1.append(Address.b58decode(from_addr1).to_array())
param1.append(Address.b58decode(to_addr1).to_array())
param1.append(value1)
param2 = []
param2.append(Address.b58decode(from_addr2).to_array())
param2.append(Address.b58decode(to_addr2).to_array())
param2.append(value2)
params_list_tmp = []
params_list_tmp.append(param1)
params_list_tmp.append(param2)
params_list.append(params_list_tmp)
# params_list.append(param1)
# params_list.append(param2)
print(" params_list is ", params_list)
print(" contract_address is ", contract_address)
params = BuildParams.create_code_params_script(params_list)
# when execute, use 0x67, then add the contract_address
params.append(0x67)
for i in contract_address:
params.append(i)
payer_raw_address = acct1.get_address().to_array()
unix_time_now = int(time.time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price,
gas_limit, payer_raw_address, params, bytearray(), [],
bytearray())
tx = sdk.sign_transaction(tx, acct1)
# sdk.add_sign_transaction(tx, payer_acct)
tx_hash = sdk.rpc.send_raw_transaction(tx)
print('tx_hash is ', tx_hash)
time.sleep(12)
event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash)
# event = sdk.rpc.get_block_by_hash(tx_hash)
print("event is ", event)
# print("tx_hash is ", tx_hash)
# event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash)
# print("event is ", event)
#check balance After transferMulti
print('### check balance After transferMulti ###')
params_list = []
params_list.append(str("BalanceOf").encode())
param = []
b58_address = "AQf4Mzu1YJrhz9f3aRkkwSm9n3qhXGSh4p"
param.append(Address.b58decode(b58_address).to_array())
params_list.append(param)
params = BuildParams.create_code_params_script(params_list)
# when pre-execute, don't use 0x67
tx = NeoVm.make_invoke_transaction(bytearray(contract_address),
bytearray(params), b'', 20000, 0)
res = sdk.rpc.send_raw_transaction_pre_exec(tx)
print("After TransferMulti, the balance is ", res)
def avm_code_to_bytearray_contract_address(avm_code: str):
bytearray_contract_address = Address.address_from_vm_code(
avm_code).to_bytearray()
return bytearray_contract_address
def deserialize(self, reader: BinaryReader):
self.address = Address(reader.read_bytes(20))
self.stake = reader.read_int64()
self.time_offset = reader.read_int32()
def avm_code_to_hex_contract_address(avm_code: str):
hex_contract_address = Address.address_from_vm_code(
avm_code).to_hex_str()
return hex_contract_address
sig_data = self.sign_to_data(tx_hash, signer)
sig = [Sig([signer.get_public_key()], 1, [sig_data])]
tx.sigs = sig
return tx
def sign_to_data(self, data, signer: Account):
signed_data = signer.generateSignature(data,
SignatureScheme.SHA256withECDSA)
return signed_data
def send_raw_transaction(self, tx):
buf = tx.serialize()
tx_data = buf.hex()
rpc_struct = self.set_json_rpc_version(RPC_SEND_TRANSACTION, [tx_data])
print(rpc_struct)
r = HttpRequest.request("post", self.addr, rpc_struct)
print(r.content.decode())
res = json.loads(r.content.decode())["result"]
return res
if __name__ == '__main__':
cli = RpcClient(0, rpc_address)
private_key = "523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f"
acc = Account(private_key, KeyType.ECDSA)
print(acc.get_address_base58())
print(acc.get_public_key().hex())
toAddr = Address.decodeBase58("AKFMnJT1u5pyPhzGRuauD1KkyUvqjQsmGs")
print(toAddr.to_array().hex())
res = cli.transfer(500, 20000, "ont", acc, toAddr.to_array(), 1)
def parse_ddo(self, ontid: str, ddo: str):
if ddo == "":
return ""
ms = StreamManager.GetStream(a2b_hex(ddo))
reader = BinaryReader(ms)
try:
publickey_bytes = reader.ReadVarBytes()
except Exception as e:
raise e
try:
attribute_bytes = reader.ReadVarBytes()
except Exception as e:
attribute_bytes = bytearray()
try:
recovery_bytes = reader.ReadVarBytes()
except Exception as e:
recovery_bytes = bytearray()
pubKey_list = []
if len(publickey_bytes) != 0:
ms = StreamManager.GetStream(publickey_bytes)
reader2 = BinaryReader(ms)
while True:
try:
index = reader2.ReadInt32()
d = {}
d['PubKeyId'] = ontid + "#keys-" + str(index)
pubkey = reader2.ReadVarBytes()
if len(pubkey) == 33:
d["Type"] = KeyType.ECDSA.name
d["Curve"] = Curve.P256.name
d["Value"] = pubkey.hex()
else:
print(pubkey)
d["Type"] = KeyType.from_label(pubkey[0])
d["Curve"] = Curve.from_label(pubkey[1])
d["Value"] = pubkey.hex()
pubKey_list.append(d)
except Exception as e:
break
attribute_list = []
if len(attribute_bytes) != 0:
ms = StreamManager.GetStream(attribute_bytes)
reader2 = BinaryReader(ms)
while True:
try:
d = {}
key = reader2.ReadVarBytes()
if len(key) == 0:
break
d["Key"] = str(key, 'utf-8')
d["Type"] = str(reader2.ReadVarBytes(), 'utf-8')
d["Value"] = str(reader2.ReadVarBytes(), 'utf-8')
attribute_list.append(d)
except Exception as e:
break
d2 = {}
d2["Owners"] = pubKey_list
d2["Attributes"] = attribute_list
if len(recovery_bytes) != 0:
addr = Address(recovery_bytes)
print(addr.to_base58())
d2["Recovery"] = addr.to_base58()
d2["OntId"] = ontid
return d2
def unbound_ong(self, base58_address: str) -> str:
contract_address = util.get_asset_address("ont")
return self.__sdk.rpc.get_allowance("ong", Address(contract_address).b58encode(), base58_address)
import requests
from datetime import datetime
from ontology.smart_contract.neo_vm import NeoVm
from ontology.crypto.digest import Digest
from ontology.utils.util import bigint_to_neo_bytes
rpc_address = 'http://127.0.0.1:20336'
sdk = OntologySdk()
sdk.rpc.set_address(rpc_address)
wallet_path = "D:\\test-python-sdk\\wallet.dat"
sdk.wallet_manager.open_wallet(wallet_path)
admin_addr = "ASwaf8mj2E3X18MHvcJtXoDsMqUjJswRWS"
admin_pwd = "123123"
adminAcct = sdk.wallet_manager.get_account(admin_addr, admin_pwd)
ad = Address.b58decode(admin_addr).to_array()
toAccount = "ARDskfQuvTa7TvbCVNX8MP5zjg7SUdDgSa"
toAcct = Address.b58decode(toAccount).to_array()
ContractAddress = "491b4c202b1f83a6f0d609b1680dc66b0590260e"
contract_address_str = ContractAddress
contract_address = bytearray.fromhex(contract_address_str)
contract_address.reverse()
DNA1 = 111101666666104
class Test(unittest.TestCase):
def test_createProperty(self):
def setUp(self):
pub_keys = [acct1.get_public_key_bytes(), acct2.get_public_key_bytes(), acct3.get_public_key_bytes()]
multi_address = Address.from_multi_pub_keys(2, pub_keys)
self.address_list = [acct1.get_address_base58(), acct2.get_address_base58(), acct3.get_address_base58(),
acct4.get_address_base58(), multi_address.b58encode()]
def invoke(sdk, m, function_name=None):
func_maps = {}
for i in dict(m["function"]).values():
if function_name is not None:
if i["function_name"] not in function_name:
continue
func_map = {}
param_list = []
func_map["function_name"] = i["function_name"]
func_map["pre_exec"] = i["pre_exec"]
try:
if type(i["function_param"]) is dict:
for value in dict(i["function_param"]).values():
if type(value) is list:
p_temp = []
for v in list(value):
p_temp.append(v)
param_list.append(p_temp)
else:
param_list.append(value)
elif type(i["function_param"]) is list:
temp_list = []
for para in list(i["function_param"]):
if type(para) is dict:
temp_list2 = []
for para2 in dict(para).values():
temp_list2.append(para2)
temp_list.append(temp_list2)
# if type(para) is :
else:
temp_list.append(para)
param_list.append(temp_list)
func_map["param_list"] = param_list
except Exception as e:
pass
if not i["pre_exec"]:
try:
func_map["signers"] = i["signers"]
except AttributeError as e:
func_map["signers"] = None
func_maps[i["function_name"]] = func_map
with open(str(m["abi_path"]), "r") as f:
abi = json.loads(f.read(),
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
abi_info = AbiInfo(abi.hash, abi.entrypoint, abi.functions, abi.events)
# print("abi_info is ", abi_info.hash, abi_info.entrypoint, abi_info.events, abi_info.functions)
tmp = str(abi.hash)[2:]
# print("tmp is ", tmp, type(tmp))
contract_address = bytearray.fromhex(tmp)
# print("contract_address is ", contract_address, type(contract_address))
m["contract_address"] = contract_address.hex()
contract_address.reverse()
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
payer = sdk.wallet_manager.get_account(m["payer_address"],
m["payer_password"])
func_l = []
no = 0
for func_map in func_maps.values():
if function_name is not None:
if func_map["function_name"] not in function_name:
# params = BuildParams.create_code_params_script(function_name)
continue
func = abi_info.get_function(func_map["function_name"])
# print('func is ', func)
if func is not None:
func_map["return_type"] = func.return_type
else:
func_map["return_type"] = ""
func = AbiFunction(func_map["function_name"],
func_map["return_type"],
func_map["param_list"])
#print("func_map is ", func_map)
#print("func is ", func)
# print("func = "+str(func.name)+" -- "+str(func.parameters[0:])+" -- " +str(func.return_type))
no = no + 1
l = []
l.append(no)
l.append(func_map["function_name"])
l.append(func_map["pre_exec"])
# 用来放参数
# print("func_map is ", func_map)
# print("func is ", func)
temp_l, params = convert_params(func, func_map)
print("********", params)
l.append(temp_l[:len(temp_l) - 1])
if params is None:
l.append("failed")
func_l.append(l)
continue
try:
print("")
print("invoking, please waiting ...")
print("method: " + func_map["function_name"])
if func_map["pre_exec"]:
res = send_transaction(sdk, contract_address, None, None,
0, 0, params, True)
# print("res in pre_exec part :", res)
if res["error"] != 0:
print(res["desc"])
l.append(res["desc"])
else:
# print('**** res **** is ', res)
# print("######## res[result][Result] is ",res["result"]["Result"], type(res["result"]["Result"]))
if res["result"]["Result"] is None or res["result"][
"Result"] == "":
# print("res:", res["result"]["Result"])
l.append("")
else:
if func_map["return_type"] == "Integer":
value = bytearray.fromhex(
res["result"]["Result"])
value.reverse()
print("res:", int(value.hex(), 16))
l.append(int(value.hex(), 16))
elif func_map["return_type"] == "ByteArray":
# print("res:", (bytearray.fromhex(res["result"]["Result"])))
print("res:", res["result"]["Result"])
l.append(res["result"]["Result"])
elif func_map["return_type"] == "":
print("res:", res["result"]["Result"])
l.append(res["result"]["Result"])
elif func_map["return_type"] == "IntegerArray":
# print(" returntype = IntegerArray ")
print("res For IntegerArray is ",
res["result"]["Result"])
returnedList = res["result"]["Result"]
intReturnList = []
for element in returnedList:
if not element:
element = "00"
value = bytearray.fromhex(element)
value.reverse()
intValue = int(value.hex(), 16)
intReturnList.append(intValue)
print("res: ", intReturnList)
l.append(intReturnList)
elif func_map["return_type"] == "ByetArrayArray":
print(" returntype = ByteArrayArray ")
print("res For ByetArrayArray is ",
res["result"]["Result"])
returnedList = res["result"]["Result"]
ByteArrayReturnList = []
for element in returnedList:
# Address.b58decode(func_map["param_list"][i], False).to_array()
# ByteArrayValue = (bytearray.fromhex(element))
# str1 = "7575526bc066a3acc6abb134119cd6d4a9041969"
# address1=Address(binascii.a2b_hex(str1))
address1 = Address(
binascii.a2b_hex(element))
ByteArrayValue = address1.b58encode()
ByteArrayReturnList.append(ByteArrayValue)
print("res: ", ByteArrayReturnList)
l.append(ByteArrayReturnList)
else:
print("res:", (bytearray.fromhex(
res["result"]["Result"])).decode('utf-8'))
l.append((bytearray.fromhex(
res["result"]["Result"])).decode('utf-8'))
else:
txhash, err = handle_tx(contract_address, func_map, params,
payer, m, sdk)
if txhash == "":
l.append(err)
else:
for i in range(10):
time2.sleep(1)
event = sdk.rpc.get_smart_contract_event_by_tx_hash(
txhash)
if event is not None:
print("txhash:", txhash)
print("event:", event)
break
l.append(txhash)
except Exception as e:
print("Error:", e)
l.append(e)
func_l.append(l)
save_file(m, "", func_l)
from ontology.common.address import Address
avm = "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"
Addr = Address.address_from_vm_code(avm)
print("contract hash is ", Addr.to_reverse_hex_str())
def to_b58_address(value: Union[str, bytes]) -> str:
if isinstance(value, str):
value = bytes.fromhex(value)
return Address(value).b58encode()
def main(argv):
try:
opts, args = getopt.getopt(argv, "hm:i:", ["migrate=", "invoke="])
except getopt.GetoptError:
print('test.py [-m|--migrate] [-i|--invoke] ')
sys.exit(2)
m = {}
for opt, arg in opts:
if opt == '-h':
print('test.py [-m|--migrate] [-i|--invoke] ')
sys.exit()
elif opt in ("-m", "--migrate"):
m["func"] = "migrate"
if "json" in str(arg):
with open(arg, "r") as f:
r = json.load(
f,
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
m["rpc_address"] = r.rpc_address
m["need_storage"] = r.need_storage
m["name"] = r.name
m["code_version"] = r.code_version
m["author"] = r.author
m["email"] = r.email
m["desp"] = r.desp
m["payer_address"] = r.payer_address
m["payer_password"] = r.payer_password
m["wallet_file_path"] = r.wallet_file_path
m["gas_limit"] = r.gas_limit
m["gas_price"] = r.gas_price
m["save_file"] = r.save_file
if ".avm" in r.code:
with open(r.code, "r") as f2:
m["code"] = f2.read()
else:
m["code"] = r.code
m["contract_address"] = Address.address_from_vm_code(
m["code"]).to_hex_str()
else:
temp = str(arg).split(",")
for i in temp:
t = str(i).split("=")
m[t[0]] = t[1]
elif opt in ("-i", "--invoke"):
m["func"] = "invoke"
if "json" in str(arg):
with open(arg, "r") as f:
r = json.load(
f,
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
m["rpc_address"] = r.rpc_address
m["acct_address"] = r.acct_address
m["acct_password"] = r.acct_password
m["payer_address"] = r.payer_address
m["payer_password"] = r.payer_password
m["wallet_file_path"] = r.wallet_file_path
m["gas_limit"] = r.gas_limit
m["gas_price"] = r.gas_price
m["abi_path"] = r.abi_path
m["save_file"] = r.save_file
m["function"] = r.function
else:
temp = str(arg).split(",")
for i in temp:
t = str(i).split("=")
m[t[0]] = t[1]
else:
print('test.py [-m|--migrate] [-i|--invoke] ')
sys.exit()
sdk = OntologySdk()
sdk.set_rpc(m["rpc_address"])
if m["func"] is "migrate":
need_storage = False
if m["need_storage"] is 'true':
need_storage = True
tx = sdk.neo_vm().make_deploy_transaction(
m["code"], need_storage, m["name"], m["code_version"], m["author"],
m["email"], m["desp"], m["payer_address"], m["gas_limit"],
m["gas_price"])
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
acct = sdk.wallet_manager.get_account(m["payer_address"],
m["payer_password"])
sdk.sign_transaction(tx, acct)
sdk.set_rpc(m["rpc_address"])
try:
print("deploying，please waiting ...")
res = sdk.rpc.send_raw_transaction(tx)
print("txhash:", res)
for i in range(10):
time.sleep(1)
res = sdk.rpc.get_smart_contract(m["contract_address"])
if res == "":
continue
else:
print("deploy success")
break
save_file(m, "success")
except Exception as e:
print(e)
save_file(m, e)
elif m["func"] is "invoke":
func_map = {}
t = 0
for i in list(m["function"]):
func_list = []
func_list.append(i.function_name)
func_list.append(i.pre_exec)
for j in list(i.function_param):
func_list.append(j)
func_map["function" + str(t)] = func_list
t = t + 1
with open(str(m["abi_path"]), "r") as f:
abi = json.loads(f.read(),
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
abi_info = AbiInfo(abi.hash, abi.entrypoint, abi.functions,
abi.events)
contract_address = bytearray.fromhex(str(abi.hash)[2:])
m["contract_address"] = contract_address.hex()
contract_address.reverse()
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
acct = sdk.wallet_manager.get_account(m["acct_address"],
m["acct_password"])
payer = sdk.wallet_manager.get_account(m["payer_address"],
m["payer_password"])
func_l = []
for func_info in func_map.values():
func = abi_info.get_function(func_info[0])
params = []
l = []
l.append(func_info[0])
l.append(func_info[1])
temp_l = ""
for i in range(len(func_info)):
if i == 0 or i == 1:
continue
temp_l += func_info[i] + ":"
if func.parameters[i - 2].type == "String":
params.append(str(func_info[i]))
if func.parameters[i - 2].type == "ByteArray":
params.append(bytearray(func_info[i].encode()))
if func.parameters[i - 2].type == "Integer":
params.append(func_info[i])
l.append(temp_l[:len(temp_l) - 1])
if len(params) == 1:
func.set_params_value(params[0])
elif len(params) == 2:
func.set_params_value(params[0], params[1])
elif len(params) == 3:
func.set_params_value(params[0], params[1], params[2])
elif len(params) == 4:
func.set_params_value(params[0], params[1], params[2],
params[3])
elif len(params) == 5:
func.set_params_value(params[0], params[1], params[2],
params[3], params[4])
elif len(params) == 6:
func.set_params_value(params[0], params[1], params[2],
params[3], params[4], params[5])
elif len(params) == 7:
func.set_params_value(params[0], params[1], params[2],
params[3], params[4], params[5],
params[6])
pre_exec = False
if func_info[1] == "true":
pre_exec = True
try:
print("")
print("invoking, please waiting ...")
print("method: " + func_info[0])
res = sdk.neo_vm().send_transaction(
contract_address, acct, payer, m["gas_limit"],
m["gas_price"], func, pre_exec)
if not pre_exec:
time.sleep(6)
print("txhash:", res)
print("Event:",
sdk.rpc.get_smart_contract_event_by_tx_hash(res))
l.append(res)
else:
print(res)
print("res:", (bytearray.fromhex(res)).decode('utf-8'))
l.append((bytearray.fromhex(res)).decode('utf-8'))
except Exception as e:
print("Error:", e)
l.append(e)
func_l.append(l)
save_file(m, "", func_l)
else:
print("only support migrate and invoke")
import base64
import unittest
from ontology.utils import util
from ontology.account.account import Account
from ontology.wallet.wallet import WalletData
from ontology.wallet.account import AccountData
from ontology.crypto.signature_scheme import SignatureScheme
from ontology.common.address import Address
private_key = "8b6bb2bebb27f3e2c24cc8a3febb413c1ef98bd2481e2292ada6d90f9a5f5ec9"
if __name__ == '__main__':
account = Account(private_key)
publickey = account.serialize_public_key()
wif = account.export_wif()
privatekey = account.get_privatekey_from_wif(wif)
print("public key is ", publickey, type(publickey))
print("private key is ", privatekey)
print("...", account.serialize_private_key())
address = Address(publickey)
addr = address.b58decode()
print("address is ", addr)
def address_from_avm_code(avm_code: str) -> Address:
return Address.from_avm_code(avm_code)
def test_aa(self):
aa = '0000000000000000000000000000000000000006'
print(Address(a2b_hex(aa.encode())).to_array())
print(bytearray.fromhex(aa))
def test_handleEvent(self, action, hash):
res = sdk.rpc.get_smart_contract_event_by_tx_hash(hash)
if action == "setOddsTable":
events = res["Notify"]
# print("buyPaper-res-events is ", events)
notifyContents = []
for event in events:
notifyContent = []
if event["ContractAddress"] == luckyMoonContractAddress:
first = (bytearray.fromhex(
event["States"][0])).decode('utf-8')
notifyContent.append(first)
notifyContents.append(notifyContent)
print("setOddsTable-res-events is : ", notifyContents)
elif action == "setLuckyToOngRate":
events = res["Notify"]
# print("buyPaper-res-events is ", events)
notifyContents = []
for event in events:
notifyContent = []
if event["ContractAddress"] == luckyMoonContractAddress:
first = (bytearray.fromhex(
event["States"][0])).decode('utf-8')
notifyContent.append(first)
if first == "setRate":
num = event["States"][1]
if not num:
num = "0"
num = bytearray.fromhex(num)
num.reverse()
num = int(num.hex(), 16)
notifyContent.append(num)
num = event["States"][2]
if not num:
num = "0"
num = bytearray.fromhex(num)
num.reverse()
num = int(num.hex(), 16)
notifyContent.append(num)
notifyContents.append(notifyContent)
print("setLuckyToOngRate-res-events is : ", notifyContents)
elif action == "startNewRound":
events = res["Notify"]
notifyContents = []
for event in events:
notifyContent = []
if event["ContractAddress"] == luckyMoonContractAddress:
first = (bytearray.fromhex(
event["States"][0])).decode('utf-8')
notifyContent.append(first)
if first == "startNewRound":
roundNumber = event["States"][1]
if not roundNumber:
num = "0"
roundNumber = bytearray.fromhex(roundNumber)
roundNumber.reverse()
roundNumber = int(roundNumber.hex(), 16)
notifyContent.append(roundNumber)
timeStamp = str(event["States"][2])
if not timeStamp:
timeStamp = "0"
timeStamp = bytearray.fromhex(timeStamp)
timeStamp.reverse()
timeStamp = int(timeStamp.hex(), 16)
dateTime = datetime.utcfromtimestamp(
timeStamp).strftime('%Y-%m-%d %H:%M:%S')
notifyContent.append(dateTime)
hashHexString = str(event["States"][3])
notifyContent.append(hashHexString)
notifyContents.append(notifyContent)
print("startNewRound-res-events is : ", notifyContents)
elif action == "bet":
events = res["Notify"]
notifyContents = []
i = 1
for event in events:
notifyContent = []
if event["ContractAddress"] == luckyMoonContractAddress:
first = (bytearray.fromhex(
event["States"][0])).decode('utf-8')
notifyContent.append(first)
if first == "bet":
roundNumber = event["States"][1]
if not roundNumber:
num = "0"
roundNumber = bytearray.fromhex(roundNumber)
roundNumber.reverse()
roundNumber = int(roundNumber.hex(), 16)
notifyContent.append(roundNumber)
account = Address(binascii.a2b_hex(event["States"][2]))
account = account.b58encode()
notifyContent.append(account)
num = event["States"][3]
if not num:
num = "0"
num = bytearray.fromhex(num)
num.reverse()
num = int(num.hex(), 16)
notifyContent.append(num)
notifyContents.append(notifyContent)
print("bet-res-events is : ", notifyContents)
elif action == "endCurrentRound":
res = sdk.rpc.get_smart_contract_event_by_tx_hash(hash)
print("endCurrentRound-res is ", res)
events = res["Notify"]
notifyContents = []
i = 1
# print("events === ", events)
for event in events:
notifyContent = []
if event["ContractAddress"] == luckyMoonContractAddress:
first = (bytearray.fromhex(
event["States"][0])).decode('utf-8')
if first == "endCurrentRound":
notifyContent.append(first)
roundNumber = event["States"][1]
if not roundNumber:
num = "0"
roundNumber = bytearray.fromhex(roundNumber)
roundNumber.reverse()
roundNumber = int(roundNumber.hex(), 16)
notifyContent.append(roundNumber)
explodePoint = event["States"][2]
if not explodePoint:
explodePoint = "0"
explodePoint = bytearray.fromhex(explodePoint)
explodePoint.reverse()
explodePoint = int(explodePoint.hex(), 16)
notifyContent.append(explodePoint)
salt = event["States"][3]
if not salt:
salt = "0"
salt = bytearray.fromhex(salt)
salt.reverse()
salt = int(salt.hex(), 16)
notifyContent.append(salt)
effectiveEscapeAcctPointOddsProfitList = event[
"States"][4]
notify1 = []
for effectiveEscapeAcctPointOddsProfit in effectiveEscapeAcctPointOddsProfitList:
notify2 = []
account = Address(
binascii.a2b_hex(
effectiveEscapeAcctPointOddsProfit[0]))
account = account.b58encode()
notify2.append(account)
escapePoint = effectiveEscapeAcctPointOddsProfit[1]
if not escapePoint:
escapePoint = "0"
escapePoint = bytearray.fromhex(escapePoint)
escapePoint.reverse()
escapePoint = int(escapePoint.hex(), 16)
notify2.append(escapePoint)
# odds = effectiveEscapeAcctPointOddsProfit[2]
# if not odds:
# odds = "0"
# odds = bytearray.fromhex(odds)
# odds.reverse()
# odds = int(odds.hex(), 16)
# notify2.append(odds)
profit = effectiveEscapeAcctPointOddsProfit[2]
if not profit:
profit = "0"
profit = bytearray.fromhex(profit)
profit.reverse()
profit = int(profit.hex(), 16)
notify2.append(profit)
notify1.append(notify2)
notifyContent.append(notify1)
# print("endCurrentRound-res-event is : ", notifyContent)
elif first == "Error":
errorCode = event["States"][1]
if not errorCode:
errorCode = "0"
errorCode = bytearray.fromhex(errorCode)
errorCode.reverse()
errorCode = int(errorCode.hex(), 16)
notifyContent.append(errorCode)
notifyContents.append(notifyContent)
print("endCurrentRound-res-events is : ", notifyContents)
return True
from ontology.common.address import Address
from ontology.core.program import ProgramBuilder
from ontology.crypto.signature_scheme import SignatureScheme
from ontology.ont_sdk import OntologySdk
sdk = OntologySdk()
rpc_address = "http://polaris3.ont.io:20336"
sdk.rpc_client.set_address(rpc_address)
private_key = "523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f"
private_key2 = "75de8489fcb2dcaf2ef3cd607feffde18789de7da129b5e97c81e001793cb7cf"
private_key3 = "1383ed1fe570b6673351f1a30a66b21204918ef8f673e864769fa2a653401114"
acc = Account(a2b_hex(private_key.encode()), SignatureScheme.SHA256withECDSA)
acc2 = Account(a2b_hex(private_key2.encode()), SignatureScheme.SHA256withECDSA)
acc3 = Account(a2b_hex(private_key3.encode()), SignatureScheme.SHA256withECDSA)
pubkeys = [acc.get_public_key(), acc2.get_public_key(), acc3.get_public_key()]
multi_addr = Address.address_from_multi_pubKeys(2, pubkeys)
class TestOntologySdk(TestCase):
def test_open_wallet(self):
a = sdk.open_wallet("./wallet/test.json")
print(a)
def test_open_or_create_wallet(self):
a = sdk.open_or_create_wallet("./test.json")
print(a)
def test_bb(self):
print(sdk.rpc_client.get_balance(acc.get_address_base58()))
print(sdk.rpc_client.get_balance(multi_addr.to_base58()))
def address_from_wasm_code(wasm_code: str) -> Address:
return Address.from_hex_contract_code(wasm_code)
def parse_ddo(ont_id: str, ddo: str) -> dict:
"""
This interface is used to deserialize a hexadecimal string into a DDO object in the from of dict.
:param ont_id: ontid.
:param ddo: an hexadecimal string.
:return: a DDO object in the from of dict.
"""
if ddo == "":
return dict()
ms = StreamManager.GetStream(a2b_hex(ddo))
reader = BinaryReader(ms)
try:
public_key_bytes = reader.read_var_bytes()
except Exception as e:
raise e
try:
attribute_bytes = reader.read_var_bytes()
except Exception as e:
attribute_bytes = bytearray()
try:
recovery_bytes = reader.read_var_bytes()
except Exception as e:
recovery_bytes = bytearray()
pubKey_list = []
if len(public_key_bytes) != 0:
ms = StreamManager.GetStream(public_key_bytes)
reader2 = BinaryReader(ms)
while True:
try:
index = reader2.read_int32()
d = {}
d['PubKeyId'] = ont_id + "#keys-" + str(index)
pubkey = reader2.read_var_bytes()
if len(pubkey) == 33:
d["Type"] = KeyType.ECDSA.name
d["Curve"] = Curve.P256.name
d["Value"] = pubkey.hex()
else:
d["Type"] = KeyType.from_label(pubkey[0])
d["Curve"] = Curve.from_label(pubkey[1])
d["Value"] = pubkey.hex()
pubKey_list.append(d)
except Exception as e:
break
attribute_list = []
if len(attribute_bytes) != 0:
ms = StreamManager.GetStream(attribute_bytes)
reader2 = BinaryReader(ms)
while True:
try:
d = {}
key = reader2.read_var_bytes()
if len(key) == 0:
break
d["Key"] = str(key, 'utf-8')
d["Type"] = str(reader2.read_var_bytes(), 'utf-8')
d["Value"] = str(reader2.read_var_bytes(), 'utf-8')
attribute_list.append(d)
except Exception as e:
break
d2 = {}
d2["Owners"] = pubKey_list
d2["Attributes"] = attribute_list
if len(recovery_bytes) != 0:
addr = Address(recovery_bytes)
d2["Recovery"] = addr.b58encode()
d2["OntId"] = ont_id
return d2
def convert_params(func, func_map: {}):
params_list = []
params_list.append(func_map["function_name"].encode())
params = []
temp_l = ""
for i in range(len(func_map["param_list"])):
if func.parameters[i].type == "String":
params.append(str(func_map["param_list"][i]))
temp_l += str(func_map["param_list"][i]) + ":"
elif func.parameters[i].type == "ByteArray":
temp_l += str(func_map["param_list"][i]) + ":"
try:
addr = bytearray()
if func_map["param_list"][i].startswith("A"):
addr = Address.b58decode(
func_map["param_list"][i]).to_array()
else:
addr = Address(bytearray.fromhex(
func_map["param_list"][i])).to_array()
params.append(addr)
except Exception as e:
params.append(bytearray(func_map["param_list"][i].encode()))
elif func.parameters[i].type == "Integer":
params.append(func_map["param_list"][i])
temp_l += str(func_map["param_list"][i]) + ":"
elif func.parameters[i].type == "Array":
param_l = []
for param in func_map["param_list"][i]:
print(type(param))
if type(param) is dict:
temp = []
for p in dict(param).values():
if type(p) is str:
temp_l = str(p).split(":")[1] + ":"
if str(p).split(":")[0] == "String":
temp.append(str(p).split(":")[1])
elif str(p).split(":")[0] == "ByteArray":
try:
temp.append(
Address.b58decode(
str(p).split(":")[1]).to_array())
except Exception as e:
temp.append(str(p).split(":")[1].encode())
elif type(p) is bool:
temp.append(p)
if p:
temp_l += "false:"
else:
temp_l += "true:"
elif type(p) is int:
temp.append(p)
temp_l += str(p) + ":"
else:
print("not supported data type")
temp_l += "not supported data type" + ":"
return
param_l.append(temp)
elif type(param) is list:
param_l.append(param)
else:
temp_l += "not supported data type" + ":"
print("only support dict")
return temp_l, None
if len(params) == 0:
params = param_l
else:
params.append(param_l)
params_list.append(params)
return temp_l, params_list
def execute(m:[], function_name=None):
sdk = OntologySdk()
sdk.set_rpc(m["rpc_address"])
if m["func"] is "migrate":
# 判断是否已经部署
code = sdk.rpc.get_smart_contract(m["contract_address"])
if code != "unknow contract":
print("contract have been deployed")
print("contract_address:", m["contract_address"])
return
need_storage = False
if m["need_storage"] is 'true':
need_storage = True
tx = sdk.neo_vm().make_deploy_transaction(m["code"], need_storage, m["name"], m["code_version"], m["author"]
, m["email"], m["desp"], m["payer_address"], m["gas_limit"],
m["gas_price"])
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
acct = sdk.wallet_manager.get_account(m["payer_address"], m["payer_password"])
sdk.sign_transaction(tx, acct)
sdk.set_rpc(m["rpc_address"])
try:
print("deploying，please waiting ...")
res = sdk.rpc.send_raw_transaction(tx)
print("txhash:", res)
for i in range(10):
time.sleep(1)
res = sdk.rpc.get_smart_contract(m["contract_address"])
if res == "unknow contract" or res == "":
continue
else:
print("deploy success")
save_file(m, "success")
return
print("deployed failed")
save_file(m, "deployed failed")
except Exception as e:
print(e)
save_file(m, e)
elif m["func"] is "invoke":
func_maps = {}
for i in list(m["function"]):
func_map = {}
param_list = []
func_map["function_name"] = i.function_name
func_map["pre_exec"] = i.pre_exec
try:
for j in list(i.function_param):
param_list.append(j)
func_map["param_list"] = param_list
except Exception as e:
pass
if not i.pre_exec:
try:
func_map["signers"] = i.signers
except AttributeError as e:
func_map["signers"] = None
func_maps[i.function_name] = func_map
with open(str(m["abi_path"]), "r") as f:
abi = json.loads(f.read(), object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
abi_info = AbiInfo(abi.hash, abi.entrypoint, abi.functions, abi.events)
contract_address = bytearray.fromhex(str(abi.hash)[2:])
m["contract_address"] = contract_address.hex()
contract_address.reverse()
sdk.wallet_manager.open_wallet(m["wallet_file_path"])
payer = sdk.wallet_manager.get_account(m["payer_address"], m["payer_password"])
func_l = []
no = 0
for func_map in func_maps.values():
if function_name is not None:
if function_name != func_map["function_name"]:
continue
func = abi_info.get_function(func_map["function_name"])
func_map["return_type"] = func.return_type
params = []
l = []
l.append(no)
no = no + 1
l.append(func_map["function_name"])
l.append(func_map["pre_exec"])
temp_l = "" # 用来放参数
for i in range(len(func_map["param_list"])):
temp_l = ""
if type(func_map["param_list"][i]) is int:
temp_l += str(func_map["param_list"][i]) + ":"
else:
temp_l += func_map["param_list"][i] + ":"
if func.parameters[i].type == "String":
params.append(str(func_map["param_list"][i]))
if func.parameters[i].type == "ByteArray":
if func_map["param_list"][i].startswith("A"):
params.append(Address.b58decode(func_map["param_list"][i], False).to_array())
else:
params.append(bytearray(func_map["param_list"][i].encode()))
if func.parameters[i].type == "Integer":
params.append(func_map["param_list"][i])
l.append(temp_l[:len(temp_l) - 1])
if len(params) == 1:
func.set_params_value(params[0])
elif len(params) == 2:
func.set_params_value(params[0], params[1])
elif len(params) == 3:
func.set_params_value(params[0], params[1], params[2])
elif len(params) == 4:
func.set_params_value(params[0], params[1], params[2], params[3])
elif len(params) == 5:
func.set_params_value(params[0], params[1], params[2], params[3], params[4])
elif len(params) == 6:
func.set_params_value(params[0], params[1], params[2], params[3], params[4], params[5])
elif len(params) == 7:
func.set_params_value(params[0], params[1], params[2], params[3], params[4], params[5], params[6])
try:
print("")
print("invoking, please waiting ...")
print("method: " + func_map["function_name"])
if func_map["pre_exec"]:
res = sdk.neo_vm().send_transaction(contract_address, None, None, 0,
0, func, True)
if res["error"] != 0:
print(res["desc"])
l.append(res["desc"])
else:
if res["result"]["Result"] == None or res["result"]["Result"] == "":
print("res:", res["result"]["Result"])
l.append("")
else:
if func_map["return_type"] == "Integer":
value = bytearray.fromhex(res["result"]["Result"])
value.reverse()
print("res:", int(value.hex(), 16))
l.append(int(value.hex(), 16))
else:
print("res:", (bytearray.fromhex(res["result"]["Result"])).decode('utf-8'))
l.append((bytearray.fromhex(res["result"]["Result"])).decode('utf-8'))
else:
res = ""
if func_map["signers"] != None:
wm = WalletManager()
wm.open_wallet(func_map["signers"].signer.walletpath)
signer = wm.get_account(func_map["signers"].signer.address,
func_map["signers"].signer.password)
print(wm.wallet_in_mem.accounts[0].address)
print(signer)
res = sdk.neo_vm().send_transaction(contract_address, signer, payer, m["gas_limit"],
m["gas_price"], func, False)
else:
res = sdk.neo_vm().send_transaction(contract_address, payer, payer, m["gas_limit"],
m["gas_price"], func, False)
for i in range(10):
time.sleep(1)
event = sdk.rpc.get_smart_contract_event_by_tx_hash(res)
if event != None:
print("txhash:", res)
print("event:", event)
break
l.append(res)
except Exception as e:
print("Error:", e)
l.append(e)
func_l.append(l)
save_file(m, "", func_l)
else:
print("only support migrate and invoke")
