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_array(),
"init_pos": init_pos,
"ontid": identity.ont_id.encode(),
"key_no": key_no
}
invoke_code = build_native_invoke_code(contract_address, bytes([0]),
"registerCandidate", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_array(), invoke_code,
bytearray(), [], bytearray())
self.__sdk.sign_transaction(tx, account)
ontid_acc = self.__sdk.wallet_manager.get_account(
identity.ont_id, password)
self.__sdk.add_sign_transaction(tx, ontid_acc)
if account.get_address_base58() is not payer:
self.__sdk.add_sign_transaction(tx, payer)
res = self.__sdk.rpc.send_raw_transaction(tx)
return tx.hash256_explorer()
def unauthorize_for_peer(self, account: Account, peer_publickeys: [],
pos_lists: [], payer: Account, gas_limit: int,
gas_price: int):
contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS)
if len(peer_publickeys) != len(pos_lists):
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(pos_lists)
for i in range(len(pos_lists)):
param["pos_lists" + str(i)] = pos_lists[i]
invoke_code = build_native_invoke_code(contract_address, b'\x00',
"unAuthorizeForPeer", 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 revoke(self, claim_id: str, issuer: Account, payer: Account, gas_price: int, gas_limit: int):
tx = self.new_revoke_tx(claim_id, issuer.get_address(), payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(issuer)
if issuer.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = self._sdk.default_network.send_raw_transaction(tx)
return tx_hash
def get_item_list_from_contract(identity_acct: Account) -> list:
sdk = app.config['ONTOLOGY']
if not isinstance(sdk, Ontology):
return list()
get_item_list_func = WasmInvokeFunction('get_item_list')
get_item_list_func.set_params_value(identity_acct.get_address())
tx = sdk.wasm_vm.make_invoke_transaction(
app.config['CONTRACT_ADDRESS_HEX'], get_item_list_func,
identity_acct.get_address(), app.config['GAS_PRICE'],
app.config['GAS_LIMIT'])
tx.sign_transaction(identity_acct)
response = sdk.rpc.send_raw_transaction_pre_exec(tx)
if not isinstance(response, dict):
return list()
result = response.get('Result')
if result is None:
return list()
builder = WasmParamsBuilder(bytes.fromhex(result))
struct_len = builder.read_var_uint()
album_list = list()
for _ in range(struct_len):
try:
encrypted_ipfs_address_bytes = bytes.fromhex(builder.pop_str())
ext = builder.pop_str()
aes_iv = bytes.fromhex(builder.pop_str())
encode_g_tilde = bytes.fromhex(builder.pop_str())
ipfs_address = ECIES.decrypt_with_cbc_mode(
encrypted_ipfs_address_bytes,
identity_acct.get_private_key_bytes(), aes_iv, encode_g_tilde)
album_list.append([ipfs_address.decode('ascii'), ext])
except Exception as e:
print('Decrypt with cbc mode failed: ', e.args[0])
return album_list
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_array(),
"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, bytes([0]),
"withdraw", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_array(), invoke_code,
bytearray(), [], bytearray())
self.__sdk.sign_transaction(tx, account)
if payer is not None and account.get_address_base58(
) is not payer.get_address_base58():
self.__sdk.add_sign_transaction(tx, payer)
self.__sdk.rpc.send_raw_transaction(tx)
return tx.hash256_explorer()
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_array()}
invoke_code = build_native_invoke_code(contract_address, bytes([0]), "withdrawFee", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray())
self.__sdk.sign_transaction(tx, account)
if payer is not None and account.get_address_base58() is not payer.get_address_base58():
self.__sdk.add_sign_transaction(tx, payer)
self.__sdk.rpc.send_raw_transaction(tx)
return tx.hash256_explorer()
def transfer(self, from_acct: Account, to_address: Union[str, Address],
amount: int, payer: Account, gas_price: int, gas_limit: int):
"""
This interface is used to send a transfer transaction that only for ONT or ONG.
"""
tx = self.new_transfer_tx(from_acct.get_address(), to_address, amount,
payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(from_acct)
if from_acct.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
return self._sdk.default_network.send_raw_transaction(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 change_max_authorization(self, account: Account, peer_publickey: str, max_authorize: 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_array(), "maxAuthorize": max_authorize}
invoke_code = build_native_invoke_code(contract_address, bytes([0]), "changeMaxAuthorization", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray())
self.__sdk.sign_transaction(tx, account)
if payer is not None and account.get_address_base58() is not payer.get_address_base58():
self.__sdk.add_sign_transaction(tx, payer)
self.__sdk.rpc.send_raw_transaction(tx)
return tx.hash256_explorer()
def approve(self, owner: Account, spender: Union[str, bytes, Address], amount: int, payer: Account, gas_price: int,
gas_limit: int) -> str:
"""
Allows spender to withdraw from owner account multiple times, up to the value amount.
If this function is called again it overwrites the current allowance with amount value.
"""
tx = self.new_approve_tx(owner.get_address(), spender, amount, payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(owner)
if owner.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = self._sdk.default_network.send_raw_transaction(tx)
return tx_hash
def transfer(self, from_acct: Account, to_address: Union[str, Address], amount: int, payer: Account, gas_price: int,
gas_limit: int) -> str:
"""
This interface is used to transfer amount of tokens to to_address synchronously.
"""
tx = self.new_transfer_tx(from_acct.get_address(), to_address, amount, payer.get_address(), gas_price,
gas_limit)
tx.sign_transaction(from_acct)
if from_acct.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = self._sdk.default_network.send_raw_transaction(tx)
return tx_hash
def test_send_raw_transaction_preexec(self):
private_key = '75de8489fcb2dcaf2ef3cd607feffde18789de7da129b5e97c81e001793cb7cf'
acct = Account(a2b_hex(private_key.encode()))
private_key2 = get_random_bytes(32)
acct2 = Account(private_key2)
tx = Asset.new_transfer_transaction("ont",
acct.get_address().to_base58(),
acct2.get_address().to_base58(), 2,
acct.get_address_base58(), 20000,
500)
tx = sdk.sign_transaction(tx, acct)
res = sdk.rpc.send_raw_transaction_preexec(tx)
self.assertEqual(res, '01')
async def transfer_from(self, spender: Account, owner: Union[str, bytes,
Address],
to_address: Union[str, bytes, Address], value: int,
payer: Account, gas_price: int,
gas_limit: int) -> str:
tx = self.new_transfer_from_tx(spender.get_address(),
owner, to_address, value,
payer.get_address(), gas_price,
gas_limit)
tx.sign_transaction(spender)
if spender.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = await self._sdk.default_aio_network.send_raw_transaction(tx)
return tx_hash
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 send_add_public_key_by_recovery(self, ont_id: str, recovery: Account,
hex_new_public_key: str,
payer: Account, gas_limit: int,
gas_price: int):
"""
This interface is used to send a Transaction object which is used to add public key
based on the recovery account.
:param ont_id: ontid.
:param recovery: an Account object which used a recovery account.
:param hex_new_public_key: the new hexadecimal public key in the form of string.
:param payer: an Account object which indicate who will 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: a hexadecimal transaction hash value.
"""
b58_payer_address = payer.get_address_base58()
hex_recovery_address = recovery.get_address().to_hex_str()
tx = OntId.new_add_public_key_transaction(ont_id, hex_recovery_address,
hex_new_public_key,
b58_payer_address, gas_limit,
gas_price)
self.__sdk.sign_transaction(tx, recovery)
self.__sdk.add_sign_transaction(tx, payer)
tx_hash = self.__sdk.rpc.send_raw_transaction(tx)
return tx_hash
def approve(self, owner_acct: Account, b58_spender_address: str,
amount: int, payer_acct: Account, gas_limit: int,
gas_price: int):
"""
This interface is used to call the Approve method in ope4
that allows spender to withdraw a certain amount of oep4 token from owner account multiple times.
If this function is called again, it will overwrite the current allowance with new value.
:param owner_acct: an Account class that indicate the owner.
:param b58_spender_address: a base58 encode address that be allowed to spend the oep4 token in owner's account.
:param amount: an int value that indicate the amount oep4 token that will be transferred 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('approve')
if not isinstance(amount, int):
raise SDKException(
ErrorCode.param_err('the data type of amount should be int.'))
if amount < 0:
raise SDKException(
ErrorCode.param_err(
'the amount should be equal or great than 0.'))
owner_address = owner_acct.get_address().to_array()
Oep4.__b58_address_check(b58_spender_address)
spender_address = Address.b58decode(b58_spender_address).to_array()
params = (owner_address, spender_address, amount)
func.set_params_value(params)
tx_hash = self.__sdk.neo_vm().send_transaction(self.__contract_address,
owner_acct, payer_acct,
gas_limit, gas_price,
func, False)
return tx_hash
def withdraw(self, claimer: Account, receiver: Union[str,
Address], amount: int,
payer: Account, gas_price: int, gas_limit: int) -> str:
"""
This interface is used to withdraw a amount of ong and transfer them to receive address.
"""
if amount <= 0:
raise SDKException(
ErrorCode.other_error(
'the amount should be greater than than zero.'))
tx = self.new_withdraw_tx(claimer.get_address(), receiver, amount,
payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(claimer)
if claimer.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
return self._sdk.default_network.send_raw_transaction(tx)
def transfer_from(self, spender: Account, owner: Union[str, bytes,
Address],
to_address: Union[str, bytes, Address], value: int,
payer: Account, gas_price: int, gas_limit: int) -> str:
"""
Transfers value amount of tokens from address owner to address to_address, and MUST fire the Transfer event.
"""
tx = self.new_transfer_from_tx(spender.get_address(),
owner, to_address, value,
payer.get_address(), gas_price,
gas_limit)
tx.sign_transaction(spender)
if spender.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = self._sdk.default_network.send_raw_transaction(tx)
return tx_hash
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 assign_funcs_to_role(self, admin_identity: Identity, password: str,
key_no: int, contract_address: str, role: str,
function_name: 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(function_name)
for i in range(len(function_name)):
param['name' + str(i)] = function_name[i]
param['key_no'] = key_no
invoke_code = build_native_invoke_code(
bytearray.fromhex(self.contract_address), bytes([0]),
"assignFuncsToRole", param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_array(), invoke_code,
bytearray(), [], bytearray())
account = self.__sdk.wallet_manager.get_account(
admin_identity.ont_id, password)
self.__sdk.sign_transaction(tx, account)
self.__sdk.add_sign_transaction(tx, payer)
res = self.__sdk.rpc.send_raw_transaction(tx)
return res
def delegate(self, identity: Identity, password: str, key_no: int,
contract_address: str, to_ont_id: str, role: str, period: int,
level: int, payer: Account, gas_limit: int, gas_price: int):
contract_address = bytearray.fromhex(contract_address)
param = {
"contract_address": contract_address,
"ont_id": identity.ont_id.encode('utf-8'),
"to_ont_id": to_ont_id.encode('utf-8'),
"role": role.encode('utf-8'),
"period": period,
"level": level,
"key_no": key_no
}
invoke_code = build_native_invoke_code(
bytearray.fromhex(self.contract_address), bytes([0]), "delegate",
param)
unix_time_now = int(time())
tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit,
payer.get_address().to_array(), invoke_code,
bytearray(), [], bytearray())
account = self.__sdk.wallet_manager.get_account(
identity.ont_id, password)
self.__sdk.sign_transaction(tx, account)
self.__sdk.add_sign_transaction(tx, payer)
res = self.__sdk.rpc.send_raw_transaction(tx)
return res
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 transfer(self, from_acct: Account, b58_to_address: str, value: int,
payer_acct: Account, gas_limit: int, gas_price: int) -> str:
"""
This interface is used to call the Transfer method in ope4
that transfer an amount of tokens from one account to another account.
:param from_acct: an Account class that send the oep4 token.
:param b58_to_address: a base58 encode address that receive the oep4 token.
:param value: an int value that indicate the amount oep4 token that will be transferred 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('transfer')
if not isinstance(value, int):
raise SDKException(
ErrorCode.param_err('the data type of value should be int.'))
if value < 0:
raise SDKException(
ErrorCode.param_err(
'the value should be equal or great than 0.'))
if not isinstance(from_acct, Account):
raise SDKException(
ErrorCode.param_err(
'the data type of from_acct should be Account.'))
Oep4.__b58_address_check(b58_to_address)
from_address = from_acct.get_address().to_bytes()
to_address = Address.b58decode(b58_to_address).to_bytes()
func.set_params_value(from_address, to_address, value)
tx_hash = self.__sdk.get_network().send_neo_vm_transaction(
self.__hex_contract_address, from_acct, payer_acct, gas_limit,
gas_price, func, False)
return tx_hash
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)
async def init(self, founder: Account, payer: Account, gas_price: int,
gas_limit: int):
tx = self.new_init_tx(payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(founder)
if founder.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = await self._sdk.default_aio_network.send_raw_transaction(tx)
return tx_hash
def approve(self, approver: Account, spender: Union[str,
Address], amount: int,
payer: Account, gas_price: int, gas_limit: int) -> str:
"""
This is an interface used to send an approve transaction
which allow receiver to spend a amount of ONT or ONG asset in sender's account.
"""
if amount <= 0:
raise SDKException(
ErrorCode.other_error(
'the amount should be greater than than zero.'))
tx = self.new_approve_tx(approver.get_address(), spender, amount,
payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(approver)
if approver.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
return self._sdk.default_network.send_raw_transaction(tx)
def init(self, founder: Account, payer: Account, gas_price: int, gas_limit: int):
"""
Contract owner can use this interface to activate oep-4 token.
"""
tx = self.new_init_tx(payer.get_address(), gas_price, gas_limit)
tx.sign_transaction(founder)
if founder.get_address_bytes() != payer.get_address_bytes():
tx.add_sign_transaction(payer)
tx_hash = self._sdk.default_network.send_raw_transaction(tx)
return tx_hash
def test_dict(self, dict_msg: dict, payer_acct: Account, gas_limit,
gas_price):
func = InvokeFunction('testMap')
func.set_params_value(dict_msg)
tx = self.__sdk.neo_vm.make_invoke_transaction(
self.__hex_contract_address, func, payer_acct.get_address(),
gas_price, gas_limit)
tx.sign_transaction(payer_acct)
tx_hash = self.__sdk.rpc.send_raw_transaction(tx)
return tx_hash
def test_struct_list_and_str(self, struct_list, str_msg,
payer_acct: Account, gas_limit, gas_price):
func = InvokeFunction('testStructListAndStr')
func.set_params_value(struct_list, str_msg)
tx = self.__sdk.neo_vm.make_invoke_transaction(
self.__hex_contract_address, func, payer_acct.get_address(),
gas_price, gas_limit)
tx.sign_transaction(payer_acct)
tx_hash = self.__sdk.rpc.send_raw_transaction(tx)
return tx_hash
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)
