async def send_neo_vm_transaction(self,
contract_address: str or bytes
or bytearray,
signer: Account or None,
payer: Account or None,
gas_price: int,
gas_limit: 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, gas_price, gas_limit,
payer.get_address_bytes(), params)
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 register_candidate(self, account: Account, peer_pubkey: str,
init_pos: int, identity: Identity, password: str,
key_no: int, payer: Account, gas_limit: int,
gas_price: int):
contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS)
param = {
"peer_pubkey": peer_pubkey,
"address": account.get_address().to_bytes(),
"init_pos": init_pos,
"ontid": identity.ont_id.encode(),
"key_no": key_no
}
invoke_code = build_native_invoke_code(contract_address, b'\x00',
"registerCandidate", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_bytes(), invoke_code,
bytearray(), [])
tx.sign_transaction(account)
ontid_acc = self.__sdk.wallet_manager.get_account_by_ont_id(
identity.ont_id, password)
tx.add_sign_transaction(ontid_acc)
if account.get_address_base58() is not payer:
tx.add_sign_transaction(payer)
return self.__sdk.get_network().send_raw_transaction(tx)
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 withdraw(self, account: Account, peer_publickeys: list,
withdraw_list: list, payer: Account, gas_limit: int,
gas_price: int):
contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS)
if len(peer_publickeys) != len(withdraw_list):
raise Exception(
"the length of peer_publickeys should equal the length of pos_lists"
)
param = {
"address": account.get_address().to_bytes(),
"publickeys_length": len(peer_publickeys)
}
for i in range(len(peer_publickeys)):
param["publickey" + str(i)] = peer_publickeys[i]
param["pos_lists_length"] = len(withdraw_list)
for i in range(len(withdraw_list)):
param["pos_lists" + str(i)] = withdraw_list[i]
invoke_code = build_native_invoke_code(contract_address, b'\x00',
"withdraw", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_bytes(), invoke_code,
bytearray(), [])
tx.sign_transaction(account)
if payer is not None and account.get_address_base58(
) is not payer.get_address_base58():
tx.add_sign_transaction(payer)
return self.__sdk.get_network().send_raw_transaction(tx)
def transfer_multi(self, transfer_list: 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 transfer_list: 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 = InvokeFunction('transferMulti')
for index, item in enumerate(transfer_list):
Oep4.__b58_address_check(item[0])
Oep4.__b58_address_check(item[1])
if not isinstance(item[2], int):
raise SDKException(
ErrorCode.param_err(
'the data type of value should be int.'))
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_bytes()
to_address_array = Address.b58decode(item[1]).to_bytes()
transfer_list[index] = [
from_address_array, to_address_array, item[2]
]
for item in transfer_list:
func.add_params_value(item)
params = func.create_invoke_code()
unix_time_now = int(time.time())
params.append(0x67)
bytearray_contract_address = bytearray.fromhex(
self.__hex_contract_address)
bytearray_contract_address.reverse()
for i in bytearray_contract_address:
params.append(i)
if len(signers) == 0:
raise SDKException(ErrorCode.param_err('payer account is None.'))
payer_address = payer_acct.get_address().to_bytes()
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer_address, params, bytearray(), [])
for signer in signers:
tx.add_sign_transaction(signer)
tx_hash = self.__sdk.get_network().send_raw_transaction(tx)
return tx_hash
def transfer_from(self, spender_acct: Account, b58_from_address: str,
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 actually spend oep4 token.
:param b58_from_address: an base58 encode address 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 = InvokeFunction('transferFrom')
Oep4.__b58_address_check(b58_from_address)
Oep4.__b58_address_check(b58_to_address)
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_bytes()
from_address_array = Address.b58decode(b58_from_address).to_bytes()
to_address_array = Address.b58decode(b58_to_address).to_bytes()
if not isinstance(value, int):
raise SDKException(
ErrorCode.param_err('the data type of value should be int.'))
func.set_params_value(spender_address_array, from_address_array,
to_address_array, value)
params = func.create_invoke_code()
unix_time_now = int(time.time())
params.append(0x67)
bytearray_contract_address = bytearray.fromhex(
self.__hex_contract_address)
bytearray_contract_address.reverse()
for i in bytearray_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_bytes()
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer_address_array, params, bytearray(), [])
tx.sign_transaction(spender_acct)
if spender_acct.get_address_base58() != payer_acct.get_address_base58(
):
tx.add_sign_transaction(payer_acct)
tx_hash = self.__sdk.get_network().send_raw_transaction(tx)
return tx_hash
def withdraw(self, initiator_identity: Identity, password: str, key_no: int, contract_address: str, delegate: str,
role: str, payer: Account, gas_limit: int, gas_price: int):
contract_address = bytearray.fromhex(contract_address)
param = {"contract_address": contract_address, "ont_id": initiator_identity.ont_id.encode('utf-8'),
"delegate": delegate.encode('utf-8'),
"role": role.encode('utf-8'), "key_no": key_no}
invoke_code = build_native_invoke_code(bytearray.fromhex(self.contract_address), b'\x00', "withdraw", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_bytes(), invoke_code,
bytearray(), [])
account = self.__sdk.wallet_manager.get_account_by_ont_id(initiator_identity.ont_id, password)
tx.sign_transaction(account)
tx.add_sign_transaction(payer)
res = self.__sdk.get_network().send_raw_transaction(tx)
return res
def withdraw_fee(self, account: Account, payer: Account, gas_limit: int,
gas_price: int):
contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS)
param = {"address": account.get_address().to_bytes()}
invoke_code = build_native_invoke_code(contract_address, b'\x00',
"withdrawFee", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_bytes(), invoke_code,
bytearray(), [])
tx.sign_transaction(account)
if payer is not None and account.get_address_base58(
) is not payer.get_address_base58():
tx.add_sign_transaction(payer)
return self.__sdk.get_network().send_raw_transaction(tx)
def reduce_init_pos(self, account: Account, peer_publickey: str, pos: int,
payer: Account, gas_limit: int, gas_price: int):
contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS)
param = {
"peer_publickey": peer_publickey,
"address": account.get_address().to_bytes(),
"pos": pos
}
invoke_code = build_native_invoke_code(contract_address, b'\x00',
"reduceInitPos", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_bytes(), invoke_code,
bytearray(), [])
tx.sign_transaction(account)
if payer is not None and account.get_address_base58(
) is not payer.get_address_base58():
tx.add_sign_transaction(payer)
return self.__sdk.get_network().send_raw_transaction(tx)
def assign_ont_ids_to_role(self, admin_identity: Identity, password: str, key_no: int, contract_address: str,
role: str, ont_ids: list,
payer: Account, gas_limit: int, gas_price: int):
contract_address = bytearray.fromhex(contract_address)
param = {"contract_address": contract_address, "ontid": admin_identity.ont_id.encode('utf-8'),
"role": role.encode('utf-8')}
param['length'] = len(ont_ids)
for i in range(len(ont_ids)):
param['name' + str(i)] = ont_ids[i]
param['key_no'] = key_no
invoke_code = build_native_invoke_code(bytearray.fromhex(self.contract_address), b'\x00',
"assignOntIDsToRole", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_bytes(), invoke_code,
bytearray(), [])
account = self.__sdk.wallet_manager.get_account_by_ont_id(admin_identity.ont_id, password)
tx.sign_transaction(account)
tx.add_sign_transaction(payer)
res = self.__sdk.get_network().send_raw_transaction(tx)
return res
