def send_transaction(self, contract_address: bytes or bytearray, acct: Account, payer_acct: Account, gas_limit: int,
gas_price: int, func: AbiFunction, pre_exec: bool):
if func is not None:
params = BuildParams.serialize_abi_function(func)
else:
params = bytearray()
if pre_exec:
if isinstance(contract_address, bytes):
tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 0, 0)
elif isinstance(contract_address, bytearray):
tx = NeoVm.make_invoke_transaction(contract_address, bytearray(params), b'', 0, 0)
else:
raise SDKException(ErrorCode.param_err('the data type of contract address is incorrect.'))
if acct is not None:
self.__sdk.sign_transaction(tx, acct)
return self.__sdk.rpc.send_raw_transaction_pre_exec(tx)
else:
unix_time_now = int(time())
params.append(0x67)
for i in contract_address:
params.append(i)
if payer_acct is None:
raise SDKException(ErrorCode.param_err('payer account is None.'))
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_acct.get_address().to_array(),
params, bytearray(), [], bytearray())
self.__sdk.sign_transaction(tx, acct)
if acct.get_address_base58() != payer_acct.get_address_base58():
self.__sdk.add_sign_transaction(tx, payer_acct)
return self.__sdk.rpc.send_raw_transaction(tx)
def test_invokeRead(self, payerAcct, param_list):
params = BuildParams.create_code_params_script(param_list)
tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 20000, 500)
sdk.sign_transaction(tx, payerAcct)
res, gaslimit = sdk.rpc.send_raw_transaction_pre_exec(tx)
return res
def test_end(self):
param_list = []
param_list.append("endCurrentRound".encode())
param_list1 = []
param_list1.append(explodePoint)
param_list1.append(salt)
param_list2 = []
param_list3 = []
param_list3.append(adminAcct.get_address().to_array())
param_list3.append(escapePoint)
param_list2.append(param_list3)
param_list1.append(param_list2)
param_list.append(param_list1)
params = BuildParams.create_code_params_script(param_list)
params.append(0x67)
for i in contract_address:
params.append(i)
unix_time_now = int(time.time())
tx = Transaction(0, 0xd1, unix_time_now, 500, 20000000,
adminAcct.get_address().to_array(), params,
bytearray(), [], bytearray())
sdk.sign_transaction(tx, adminAcct)
res1 = sdk.rpc.send_raw_transaction(tx)
print(res1)
return res1
async def send_neo_vm_transaction(self,
contract_address: str or bytes
or bytearray,
signer: Account or None,
payer: Account or None,
gas_limit: int,
gas_price: int,
func: AbiFunction or InvokeFunction,
is_full: bool = False):
if isinstance(func, AbiFunction):
params = BuildParams.serialize_abi_function(func)
elif isinstance(func, InvokeFunction):
params = func.create_invoke_code()
else:
raise SDKException(
ErrorCode.other_error('the type of func is error.'))
contract_address = ensure_bytearray_contract_address(contract_address)
params.append(0x67)
for i in contract_address:
params.append(i)
if payer is None:
raise SDKException(ErrorCode.param_err('payer account is None.'))
tx = Transaction(0, 0xd1, int(time()), gas_price, gas_limit,
payer.get_address_bytes(), params, bytearray(), [])
tx.sign_transaction(payer)
if isinstance(
signer, Account
) and signer.get_address_base58() != payer.get_address_base58():
tx.add_sign_transaction(signer)
return await self.send_raw_transaction(tx, is_full)
def send_transaction(self, contract_address: bytearray, acct: Account,
payer_acct: Account, gas_limit: int, gas_price: int,
func: AbiFunction, pre_exec: bool):
params = bytearray()
if func is not None:
params = BuildParams.serialize_abi_function(func)
if pre_exec:
tx = NeoVm.make_invoke_transaction(bytearray(contract_address),
bytearray(params), b'', 0, 0)
if acct is not None:
self.__sdk.sign_transaction(tx, acct)
return self.__sdk.rpc.send_raw_transaction_pre_exec(tx)
unix_time_now = int(time())
params.append(0x67)
for i in contract_address:
params.append(i)
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer_acct.get_address().to_array(), params,
bytearray(), [], bytearray())
if acct is not None:
self.__sdk.sign_transaction(tx, acct)
if payer_acct is not None and acct is not None and acct.get_address_base58(
) != payer_acct.get_address_base58():
self.__sdk.add_sign_transaction(tx, payer_acct)
return self.__sdk.rpc.send_raw_transaction(tx)
def test_create_code_params_script(self):
m = {}
m["key"] = "value"
l = []
l.append(m)
aa = BuildParams.create_code_params_script(l)
print(aa.hex())
def test_invoke(self, payerAcct, param_list):
params = BuildParams.create_code_params_script(param_list)
#
# tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 20000, 500)
# sdk.sign_transaction(tx, payerAcct)
# nil, gaslimit = sdk.rpc.send_raw_transaction_pre_exec(tx)
#
params.append(0x67)
for i in contract_address:
params.append(i)
gaslimit = 20000000
gaslimit = gaslimit * 2
unix_time_now = int(time.time())
tx = Transaction(0, 0xd1, unix_time_now, 500, gaslimit, payerAcct.get_address().to_array(), params, bytearray(), [], bytearray())
sdk.sign_transaction(tx, payerAcct)
loopFlag = True
hash = None
while loopFlag:
try:
hash = sdk.rpc.send_raw_transaction(tx)
except requests.exceptions.ConnectTimeout or requests.exceptions.ConnectionError:
loopFlag = True
if hash != None:
loopFlag = False
print("hash is", hash)
return hash
def __send_init(self,
acct: Account,
payer_acct: Account,
gas_limit: int,
gas_price: int,
pre_exec=False):
if self.contract_addr is None or self.contract_addr == "":
raise Exception("null code_address")
abi = json.loads(self.nep5_abi,
object_hook=lambda d: namedtuple('X', d.keys())
(*d.values()))
abi_info = AbiInfo(abi.hash, abi.entrypoint, abi.functions, abi.events)
func = abi_info.get_function("init")
if pre_exec:
params = BuildParams.serialize_abi_function(func)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
bytearray(), params, bytearray(), [], bytearray())
if acct is not None:
self.__sdk.sign_transaction(tx, acct)
obj = self.__sdk.rpc.send_raw_transaction_pre_exec(tx)
if int(obj["Result"]) is not 1:
raise Exception("send_raw_transaction PreExec error:", obj)
return obj["Gas"]
if acct is None or payer_acct is None:
raise Exception("acct or payer_acct should not be None")
return self.__sdk.neo_vm().send_transaction(
bytearray(self.contract_addr), acct, payer_acct, gas_limit,
gas_price, func, pre_exec)
def send_neo_vm_transaction(self, contract_address: str or bytes or bytearray, acct: Account, payer_acct: Account,
gas_limit: int, gas_price: int, func: AbiFunction or InvokeFunction, pre_exec: bool,
is_full: bool = False):
if isinstance(func, AbiFunction):
params = BuildParams.serialize_abi_function(func)
elif isinstance(func, InvokeFunction):
params = func.create_invoke_code()
else:
raise SDKException(ErrorCode.other_error('the type of func is error.'))
if isinstance(contract_address, str) and len(contract_address) == 40:
contract_address = bytearray(binascii.a2b_hex(contract_address))
contract_address.reverse()
if pre_exec:
if isinstance(contract_address, bytes):
tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 0, 0)
elif isinstance(contract_address, bytearray):
tx = NeoVm.make_invoke_transaction(contract_address, bytearray(params), b'', 0, 0)
else:
raise SDKException(ErrorCode.param_err('the data type of contract address is incorrect.'))
if acct is not None:
tx.sign_transaction(acct)
return self.send_raw_transaction_pre_exec(tx, is_full)
else:
unix_time_now = int(time())
params.append(0x67)
for i in contract_address:
params.append(i)
if payer_acct is None:
raise SDKException(ErrorCode.param_err('payer account is None.'))
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_acct.get_address().to_bytes(),
params, bytearray(), [])
tx.sign_transaction(payer_acct)
if isinstance(acct, Account) and acct.get_address_base58() != payer_acct.get_address_base58():
tx.add_sign_transaction(acct)
return self.send_raw_transaction(tx, is_full)
def generate_unsigned_invoke_transaction(contract_address: bytearray,
params_list: list,
payer_base58: bytearray,
gas_price: int, gas_limit: int):
# params = BuildParams.serialize_abi_function(abi_func)
params = BuildParams.create_code_params_script(params_list)
tx = NeoVm.make_invoke_transaction(contract_address, bytearray(params),
payer_base58, gas_limit, gas_price)
return tx
def transfer_from(self, spender_acct: Account, from_acct: Account,
b58_to_address: str, value: int, payer_acct: Account,
gas_limit: int, gas_price: int):
"""
This interface is used to call the Allowance method in ope4
that allow spender to withdraw amount of oep4 token from from-account to to-account.
:param spender_acct: an Account class that spend the oep4 token.
:param from_acct: an Account class that actually pay oep4 token for the spender's spending.
:param b58_to_address: a base58 encode address that receive the oep4 token.
:param value: the amount of ope4 token in this transaction.
:param payer_acct: an Account class that used to pay for the transaction.
:param gas_limit: an int value that indicate the gas limit.
:param gas_price: an int value that indicate the gas price.
:return: the hexadecimal transaction hash value.
"""
func = self.__abi_info.get_function('TransferFrom')
Oep4.__b58_address_check(b58_to_address)
if not isinstance(from_acct, Account):
raise SDKException(
ErrorCode.param_err(
'the data type of from_acct should be Account.'))
if not isinstance(spender_acct, Account):
raise SDKException(
ErrorCode.param_err(
'the data type of spender_acct should be Account.'))
spender_address_array = spender_acct.get_address().to_array()
from_address_array = from_acct.get_address().to_array()
to_address_array = Address.b58decode(b58_to_address).to_array()
if not isinstance(value, int):
raise SDKException(
ErrorCode.param_err('the data type of value should be int.'))
params = (spender_address_array, from_address_array, to_address_array,
value)
func.set_params_value(params)
params = BuildParams.serialize_abi_function(func)
unix_time_now = int(time.time())
params.append(0x67)
for i in self.__contract_address:
params.append(i)
if payer_acct is None:
raise SDKException(ErrorCode.param_err('payer account is None.'))
payer_address_array = payer_acct.get_address().to_array()
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer_address_array, params, bytearray(), [],
bytearray())
self.__sdk.sign_transaction(tx, payer_acct)
if spender_acct.get_address_base58() != payer_acct.get_address_base58(
):
self.__sdk.add_sign_transaction(tx, spender_acct)
if from_acct.get_address_base58() != payer_acct.get_address_base58():
self.__sdk.add_sign_transaction(tx, payer_acct)
tx_hash = self.__sdk.rpc.send_raw_transaction(tx)
return tx_hash
def make_commit(self, issuerOntid: str, subjectOntid: str, claimId: str, payer: str,
gas_limit: int, gas_price: int):
# TODO
abi = json.loads(self.abi, object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
abi_info = AbiInfo(abi.hash, abi.entrypoint, abi.functions, abi.events)
func = abi_info.get_function("Commit")
func.set_params_value(bytes(claimId.encode()), bytes(issuerOntid.encode()), bytes(subjectOntid.encode()))
params = BuildParams.serialize_abi_function(func)
unix_time_now = int(time())
return Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, Address.b58decode(payer), params, bytearray(),
[], bytearray())
def build_params():
abi = AbiInfo(nep5abi['hash'], nep5abi['entrypoint'], nep5abi["functions"])
# func = abi.get_function("Transfer")
# func = abi.get_function("BalanceOf")
func = abi.get_function("balanceOf")
# func = abi.get_function("deploy")
# func.set_params_value((acct1.get_address().to_array(), acct2.get_address().to_array(), 19 * 10000000))
# add = acct1.get_address().to_reverse_hex_str()
func.set_params_value(
(Address.b58decode('AHX1wzvdw9Yipk7E9MuLY4GGX4Ym9tHeDe').to_array(), ))
params = BuildParams.serialize_abi_function(func)
params += bytearray([0x67])
return params
def send_neo_vm_transaction_pre_exec(self, contract_address: str or bytes or bytearray, signer: Account or None,
func: AbiFunction or InvokeFunction, is_full: bool = False):
if isinstance(func, AbiFunction):
params = BuildParams.serialize_abi_function(func)
elif isinstance(func, InvokeFunction):
params = func.create_invoke_code()
else:
raise SDKException(ErrorCode.other_error('the type of func is error.'))
contract_address = ensure_bytearray_contract_address(contract_address)
tx = NeoVm.make_invoke_transaction(contract_address, params, b'', 0, 0)
if signer is not None:
tx.sign_transaction(signer)
return self.send_raw_transaction_pre_exec(tx, is_full)
def transfer_multi(self, args: list, payer_acct: Account, signers: list,
gas_limit: int, gas_price: int):
"""
This interface is used to call the TransferMulti method in ope4
that allow transfer amount of token from multiple from-account to multiple to-account multiple times.
:param args: a parameter list with each item contains three sub-items:
base58 encode transaction sender address,
base58 encode transaction receiver address,
amount of token in transaction.
:param payer_acct: an Account class that used to pay for the transaction.
:param signers: a signer list used to sign this transaction which should contained all sender in args.
:param gas_limit: an int value that indicate the gas limit.
:param gas_price: an int value that indicate the gas price.
:return: the hexadecimal transaction hash value.
"""
func = self.__abi_info.get_function('transferMulti')
for index in range(len(args)):
item = args[index]
Oep4.__b58_address_check(item[0])
Oep4.__b58_address_check(item[1])
if not isinstance(item[2], float) or isinstance(item[2], int):
raise SDKException(
ErrorCode.param_err(
'the data type of value should be number.'))
if item[2] < 0:
raise SDKException(
ErrorCode.param_err(
'the value should be equal or great than 0.'))
from_address_array = Address.b58decode(item[0]).to_array()
to_address_array = Address.b58decode(item[1]).to_array()
args[index] = [
from_address_array, to_address_array,
self.__to_int_according_to_decimal(item[2])
]
func.set_params_value((args, ))
params = BuildParams.serialize_abi_function(func)
unix_time_now = int(time.time())
params.append(0x67)
for i in self.__contract_address:
params.append(i)
signers_len = len(signers)
if signers_len == 0:
raise SDKException(ErrorCode.param_err('payer account is None.'))
payer_address = payer_acct.get_address().to_array()
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer_address, params, bytearray(), [], bytearray())
for index in range(signers_len):
self.__sdk.add_sign_transaction(tx, signers[index])
tx_hash = self.__sdk.rpc.send_raw_transaction(tx)
return tx_hash
def handle_tx(contract_address, func_map, param_list, payer, m, sdk):
#print("param_list:", param_list)
#print('param_list is ', param_list)
params = BuildParams.create_code_params_script(param_list)
print("Second final params ------ ", param_list)
unix_time_now = int(time())
params.append(0x67)
#print("final params ------ ",params)
for i in contract_address:
params.append(i)
tx = Transaction(0, 0xd1, unix_time_now, m["gas_price"], m["gas_limit"],
payer.get_address().to_array(), params, bytearray(), [],
bytearray())
sdk.add_sign_transaction(tx, payer)
path_addr = []
if type(func_map["signers"]) is dict:
signers = func_map["signers"]
if signers["m"] == 1:
sdk.wallet_manager.open_wallet(signers["signer"]["walletpath"])
acc = sdk.wallet_manager.get_account(signers["signer"]["address"],
signers["signer"]["password"])
if acc is not None:
sdk.add_sign_transaction(tx, acc)
else:
print("not supported multi signature")
return "", "not supported multi signature"
elif type(func_map["signers"]) is list:
for signer in list(func_map["signers"]):
if signer["m"] == 1:
if signer["signer"]["walletpath"] not in path_addr:
path_addr.append(signer["signer"]["walletpath"])
sdk.wallet_manager.open_wallet(
signer["signer"]["walletpath"])
acc = sdk.wallet_manager.get_account(
signer["signer"]["address"], signer["signer"]["password"])
if acc is not None:
sdk.add_sign_transaction(tx, acc)
else:
print("not support multi signature")
return "", "not supported multi signature"
# TODO
res = sdk.rpc.send_raw_transaction(tx)
return res, ""
def send_transaction(sdk, contract_address: bytearray, acct: Account, payer_acct: Account, gas_limit: int,
gas_price: int, param_list:[], pre_exec: bool):
params = BuildParams.create_code_params_script(param_list)
if pre_exec:
tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 0, 0)
if acct is not None:
sdk.sign_transaction(tx, acct)
return sdk.rpc.send_raw_transaction_pre_exec(tx)
unix_time_now = int(time())
params.append(0x67)
for i in contract_address:
params.append(i)
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_acct.get_address().to_array(),
params, bytearray(), [], bytearray())
if acct is not None:
sdk.sign_transaction(tx, acct)
if payer_acct is not None and acct is not None and acct.get_address_base58() != payer_acct.get_address_base58():
sdk.add_sign_transaction(tx, payer_acct)
return sdk.rpc.send_raw_transaction(tx)
def test_Test(self):
payerAcct = adminAcct
param_list = []
param_list.append("test".encode())
args = []
param_list1 = []
param_list2 = []
param_list2.append(21)
param_list2.append(22)
param_list1.append(param_list2)
param_list3 = []
param_list3.append(31)
param_list3.append(32)
param_list1.append(param_list3)
args.append(param_list1)
param_list.append(args)
print("***** test", param_list)
params = BuildParams.create_code_params_script(param_list)
hash = self.test_invoke(payerAcct, param_list)
print("hash === test", hash)
return True
def generate_unsigned_invoke_transaction(contract_address: bytearray, abi_func: AbiFunction, payer_base58: bytearray, gas_price: int,
gas_limit: int):
params = BuildParams.serialize_abi_function(abi_func)
tx = NeoVm.make_invoke_transaction(contract_address, bytearray(params), payer_base58, gas_limit, gas_price)
return tx
def create_invoke_code(self):
param_list = list()
param_list.append(self.__func_name.encode('utf-8'))
param_list.append(self.__parameters)
invoke_code = BuildParams.create_code_params_script(param_list)
return invoke_code
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)
