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")